void Copyright(int Section) {
  static char information[20000];
  information[0] = '\0';
  if (Section == 1) {
    (strcat(information, "Movie version 2.0, Copyright (C) 1995 Liam Hudson"),
     strcat(information, "\n"));
    (strcat(information, "Movie v2.0 comes with ABSOLUTELY NO WARRANTY; type "
                         "WARRANTY at prompt for details."),
     strcat(information, "\n"));
    (strcat(information,
            "This is free software, and you are welcome to redistribute it"),
     strcat(information, "\n"));
    (strcat(information, "under certain conditions; type LICENSE at command "
                         "prompt for details"),
     strcat(information, "\n"));
  }
  if (Section == 2) {
    (strcat(information,
            "                    THIS PROGRAM COMES WITH NO WARRANTY"),
     strcat(information, "\n"));
    (strcat(information,
            "                    -----------------------------------"),
     strcat(information, "\n"));
    (strcat(information, "1. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, "
                         "THERE IS NO WARRANTY"),
     strcat(information, "\n"));
    (strcat(information, "   FOR THE PROGRAM, TO THE EXTENT PERMITTED BY "
                         "APPLICABLE LAW.  EXCEPT WHEN"),
     strcat(information, "\n"));
    (strcat(information, "   OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS "
                         "AND/OR OTHER PARTIES"),
     strcat(information, "\n"));
    (strcat(information, "   PROVIDE THE PROGRAM `AS IS' WITHOUT WARRANTY OF "
                         "ANY KIND, EITHER EXPRESSED"),
     strcat(information, "\n"));
    (strcat(information, "   OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE "
                         "IMPLIED WARRANTIES OF"),
     strcat(information, "\n"));
    (strcat(information, "   MERCHANTABILITY AND FITNESS FOR A PARTICULAR "
                         "PURPOSE.  THE ENTIRE RISK AS"),
     strcat(information, "\n"));
    (strcat(information, "   TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS "
                         "WITH YOU@.  SHOULD THE"),
     strcat(information, "\n"));
    (strcat(information, "   PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF "
                         "ALL NECESSARY SERVICING,"),
     strcat(information, "\n"));
    (strcat(information, "   REPAIR OR CORRECTION."),
     strcat(information, "\n"));
    (strcat(information, ""), strcat(information, "\n"));
    (strcat(information, "2. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR "
                         "AGREED TO IN WRITING"),
     strcat(information, "\n"));
    (strcat(information, "   WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO "
                         "MAY MODIFY AND/OR"),
     strcat(information, "\n"));
    (strcat(information, "   REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE "
                         "LIABLE TO YOU FOR DAMAGES,"),
     strcat(information, "\n"));
    (strcat(information, "   INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR "
                         "CONSEQUENTIAL DAMAGES ARISING"),
     strcat(information, "\n"));
    (strcat(information, "   OUT OF THE USE OR INABILITY TO USE THE PROGRAM "
                         "(INCLUDING BUT NOT LIMITED"),
     strcat(information, "\n"));
    (strcat(information, "   TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE "
                         "OR LOSSES SUSTAINED BY"),
     strcat(information, "\n"));
    (strcat(information, "   YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM "
                         "TO OPERATE WITH ANY OTHER"),
     strcat(information, "\n"));
    (strcat(information, "   PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS "
                         "BEEN ADVISED OF THE"),
     strcat(information, "\n"));
    (strcat(information, "   POSSIBILITY OF SUCH DAMAGES."),
     strcat(information, "\n"));
    (strcat(information,
            "                    -----------------------------------"),
     strcat(information, "\n"));
  }
  if (Section == 3) {
    (strcat(information, "	        GNU GENERAL PUBLIC LICENSE"),
     strcat(information, "\n"));
    (strcat(
         information,
         "   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION"),
     strcat(information, "\n"));
    (strcat(information, ""), strcat(information, "\n"));
    (strcat(information, "  0. This License applies to any program or other "
                         "work which contains"),
     strcat(information, "\n"));
    (strcat(information, "a notice placed by the copyright holder saying it "
                         "may be distributed"),
     strcat(information, "\n"));
    (strcat(information, "under the terms of this General Public License.  The "
                         "'Program', below,"),
     strcat(information, "\n"));
    (strcat(
         information,
         "refers to any such program or work, and a work based on the Program"),
     strcat(information, "\n"));
    (strcat(information, "means either the Program or any derivative work "
                         "under copyright law:"),
     strcat(information, "\n"));
    (strcat(
         information,
         "that is to say, a work containing the Program or a portion of it,"),
     strcat(information, "\n"));
    (strcat(information, "either verbatim or with modifications and/or "
                         "translated into another"),
     strcat(information, "\n"));
    (strcat(information, "language.  (Hereinafter, translation is included "
                         "without limitation in"),
     strcat(information, "\n"));
    (strcat(information,
            "the term modification.)  Each licensee is addressed as you."),
     strcat(information, "\n"));
    (strcat(information, ""), strcat(information, "\n"));
    (strcat(information, "Activities other than copying, distribution and "
                         "modification are not"),
     strcat(information, "\n"));
    (strcat(information,
            "covered by this License; they are outside its scope.  The act of"),
     strcat(information, "\n"));
    (strcat(information, "running the Program is not restricted, and the "
                         "output from the Program"),
     strcat(information, "\n"));
    (strcat(information,
            "is covered only if its contents constitute a work based on the"),
     strcat(information, "\n"));
    (strcat(
         information,
         "Program (independent of having been made by running the Program)."),
     strcat(information, "\n"));
    (strcat(information,
            "Whether that is true depends on what the Program does."),
     strcat(information, "\n"));
    (strcat(information, ""), strcat(information, "\n"));
    (strcat(
         information,
         "  1. You may copy and distribute verbatim copies of the Program's"),
     strcat(information, "\n"));
    (strcat(information,
            "source code as you receive it, in any medium, provided that you"),
     strcat(information, "\n"));
    (strcat(
         information,
         "conspicuously and appropriately publish on each copy an appropriate"),
     strcat(information, "\n"));
    (strcat(information,
            "copyright notice and disclaimer of warranty; keep intact all the"),
     strcat(information, "\n"));
    (strcat(information, "notices that refer to this License and to the "
                         "absence of any warranty;"),
     strcat(information, "\n"));
    (strcat(
         information,
         "and give any other recipients of the Program a copy of this License"),
     strcat(information, "\n"));
    (strcat(information, "along with the Program."), strcat(information, "\n"));
    (strcat(information, ""), strcat(information, "\n"));
    (strcat(information, "You may charge a fee for the physical act of "
                         "transferring a copy, and"),
     strcat(information, "\n"));
    (strcat(information, "you may at your option offer warranty protection in "
                         "exchange for a fee."),
     strcat(information, "\n"));
    (strcat(information, ""), strcat(information, "\n"));
    (strcat(information, "  2. You may modify your copy or copies of the "
                         "Program or any portion"),
     strcat(information, "\n"));
    (strcat(information,
            "of it, thus forming a work based on the Program, and copy and"),
     strcat(information, "\n"));
    (strcat(
         information,
         "distribute such modifications or work under the terms of Section 1"),
     strcat(information, "\n"));
    (strcat(information,
            "above, provided that you also meet all of these conditions:"),
     strcat(information, "\n"));
    (strcat(information, ""), strcat(information, "\n"));
    (strcat(
         information,
         "    a) You must cause the modified files to carry prominent notices"),
     strcat(information, "\n"));
    (strcat(
         information,
         "    stating that you changed the files and the date of any change."),
     strcat(information, "\n"));
    (strcat(information, ""), strcat(information, "\n"));
    (strcat(information, "    b) You must cause any work that you distribute "
                         "or publish, that in"),
     strcat(information, "\n"));
    (strcat(
         information,
         "    whole or in part contains or is derived from the Program or any"),
     strcat(information, "\n"));
    (strcat(information, "    part thereof, to be licensed as a whole at no "
                         "charge to all third"),
     strcat(information, "\n"));
    (strcat(information, "    parties under the terms of this License."),
     strcat(information, "\n"));
    (strcat(information, ""), strcat(information, "\n"));
    (strcat(information, "    c) If the modified program normally reads "
                         "commands interactively"),
     strcat(information, "\n"));
    (strcat(information,
            "    when run, you must cause it, when started running for such"),
     strcat(information, "\n"));
    (strcat(information, "    interactive use in the most ordinary way, to "
                         "print or display an"),
     strcat(information, "\n"));
    (strcat(information,
            "    announcement including an appropriate copyright notice and a"),
     strcat(information, "\n"));
    (strcat(information, "    notice that there is no warranty (or else, "
                         "saying that you provide"),
     strcat(information, "\n"));
    (strcat(
         information,
         "    a warranty) and that users may redistribute the program under"),
     strcat(information, "\n"));
    (strcat(information, "    these conditions, and telling the user how to "
                         "view a copy of this"),
     strcat(information, "\n"));
    (strcat(
         information,
         "    License.  (Exception: if the Program itself is interactive but"),
     strcat(information, "\n"));
    (strcat(information, "    does not normally print such an announcement, "
                         "your work based on"),
     strcat(information, "\n"));
    (strcat(information,
            "    the Program is not required to print an announcement.)"),
     strcat(information, "\n"));
    (strcat(information, ""), strcat(information, "\n"));
    (strcat(information,
            "These requirements apply to the modified work as a whole.  If"),
     strcat(information, "\n"));
    (strcat(information, "identifiable sections of that work are not derived "
                         "from the Program,"),
     strcat(information, "\n"));
    (strcat(
         information,
         "and can be reasonably considered independent and separate works in"),
     strcat(information, "\n"));
    (strcat(
         information,
         "themselves, then this License, and its terms, do not apply to those"),
     strcat(information, "\n"));
    (strcat(
         information,
         "sections when you distribute them as separate works.  But when you"),
     strcat(information, "\n"));
    (strcat(information, "distribute the same sections as part of a whole "
                         "which is a work based"),
     strcat(information, "\n"));
    (strcat(information, "on the Program, the distribution of the whole must "
                         "be on the terms of"),
     strcat(information, "\n"));
    (strcat(
         information,
         "this License, whose permissions for other licensees extend to the"),
     strcat(information, "\n"));
    (strcat(information, "entire whole, and thus to each and every part "
                         "regardless of who wrote it."),
     strcat(information, "\n"));
    (strcat(information, ""), strcat(information, "\n"));
    (strcat(information, "Thus, it is not the intent of this section to claim "
                         "rights or contest"),
     strcat(information, "\n"));
    (strcat(information, "your rights to work written entirely by you; rather, "
                         "the intent is to"),
     strcat(information, "\n"));
    (strcat(information,
            "exercise the right to control the distribution of derivative or"),
     strcat(information, "\n"));
    (strcat(information, "collective works based on the Program."),
     strcat(information, "\n"));
    (strcat(information, ""), strcat(information, "\n"));
    (strcat(information, "In addition, mere aggregation of another work not "
                         "based on the Program"),
     strcat(information, "\n"));
    (strcat(information, "with the Program (or with a work based on the "
                         "Program) on a volume of"),
     strcat(information, "\n"));
    (strcat(information, "a storage or distribution medium does not bring the "
                         "other work under"),
     strcat(information, "\n"));
    (strcat(information, "the scope of this License."),
     strcat(information, "\n"));
    (strcat(information, ""), strcat(information, "\n"));
    (strcat(information, "  3. You may copy and distribute the Program (or a "
                         "work based on it,"),
     strcat(information, "\n"));
    (strcat(information, "under Section 2) in object code or executable form "
                         "under the terms of"),
     strcat(information, "\n"));
    (strcat(information, "Sections 1 and 2 above provided that you also do one "
                         "of the following:"),
     strcat(information, "\n"));
    (strcat(information, ""), strcat(information, "\n"));
    (strcat(information, "    a) Accompany it with the complete corresponding "
                         "machine-readable"),
     strcat(information, "\n"));
    (strcat(information, "    source code, which must be distributed under the "
                         "terms of Sections"),
     strcat(information, "\n"));
    (strcat(information, "    1 and 2 above on a medium customarily used for "
                         "software interchange; or,"),
     strcat(information, "\n"));
    (strcat(information, ""), strcat(information, "\n"));
    (strcat(
         information,
         "    b) Accompany it with a written offer, valid for at least three"),
     strcat(information, "\n"));
    (strcat(
         information,
         "    years, to give any third party, for a charge no more than your"),
     strcat(information, "\n"));
    (strcat(
         information,
         "    cost of physically performing source distribution, a complete"),
     strcat(information, "\n"));
    (strcat(
         information,
         "    machine-readable copy of the corresponding source code, to be"),
     strcat(information, "\n"));
    (strcat(information, "    distributed under the terms of Sections 1 and 2 "
                         "above on a medium"),
     strcat(information, "\n"));
    (strcat(information, "    customarily used for software interchange; or,"),
     strcat(information, "\n"));
    (strcat(information, ""), strcat(information, "\n"));
    (strcat(information, "    c) Accompany it with the information you "
                         "received as to the offer"),
     strcat(information, "\n"));
    (strcat(
         information,
         "    to distribute corresponding source code.  (This alternative is"),
     strcat(information, "\n"));
    (strcat(information,
            "    allowed only for noncommercial distribution and only if you"),
     strcat(information, "\n"));
    (strcat(information, "    received the program in object code or "
                         "executable form with such"),
     strcat(information, "\n"));
    (strcat(information, "    an offer, in accord with Subsection b above.)"),
     strcat(information, "\n"));
    (strcat(information, ""), strcat(information, "\n"));
    (strcat(
         information,
         "The source code for a work means the preferred form of the work for"),
     strcat(information, "\n"));
    (strcat(information, "making modifications to it.  For an executable work, "
                         "complete source"),
     strcat(information, "\n"));
    (strcat(information, "code means all the source code for all modules it "
                         "contains, plus any"),
     strcat(information, "\n"));
    (strcat(information,
            "associated interface definition files, plus the scripts used to"),
     strcat(information, "\n"));
    (strcat(information, "control compilation and installation of the "
                         "executable.  However, as a"),
     strcat(information, "\n"));
    (strcat(information,
            "special exception, the source code distributed need not include"),
     strcat(information, "\n"));
    (strcat(
         information,
         "anything that is normally distributed (in either source or binary"),
     strcat(information, "\n"));
    (strcat(information, "form) with the major components (compiler, kernel, "
                         "and so on) of the"),
     strcat(information, "\n"));
    (strcat(information, "operating system on which the executable runs, "
                         "unless that component"),
     strcat(information, "\n"));
    (strcat(information, "itself accompanies the executable."),
     strcat(information, "\n"));
    (strcat(information, ""), strcat(information, "\n"));
    (strcat(information,
            "If distribution of executable or object code is made by offering"),
     strcat(information, "\n"));
    (strcat(information,
            "access to copy from a designated place, then offering equivalent"),
     strcat(information, "\n"));
    (strcat(information,
            "access to copy the source code from the same place counts as"),
     strcat(information, "\n"));
    (strcat(
         information,
         "distribution of the source code, even though third parties are not"),
     strcat(information, "\n"));
    (strcat(information,
            "compelled to copy the source along with the object code."),
     strcat(information, "\n"));
    (strcat(information, ""), strcat(information, "\n"));
    (strcat(information, "  4. You may not copy, modify, sublicense, or "
                         "distribute the Program"),
     strcat(information, "\n"));
    (strcat(information,
            "except as expressly provided under this License.  Any attempt"),
     strcat(information, "\n"));
    (strcat(
         information,
         "otherwise to copy, modify, sublicense or distribute the Program is"),
     strcat(information, "\n"));
    (strcat(information, "void, and will automatically terminate your rights "
                         "under this License."),
     strcat(information, "\n"));
    (strcat(information, "However, parties who have received copies, or "
                         "rights, from you under"),
     strcat(information, "\n"));
    (strcat(information, "this License will not have their licenses terminated "
                         "so long as such"),
     strcat(information, "\n"));
    (strcat(information, "parties remain in full compliance."),
     strcat(information, "\n"));
    (strcat(information, ""), strcat(information, "\n"));
    (strcat(information, "  5. You are not required to accept this License, "
                         "since you have not"),
     strcat(information, "\n"));
    (strcat(information, "signed it.  However, nothing else grants you "
                         "permission to modify or"),
     strcat(information, "\n"));
    (strcat(
         information,
         "distribute the Program or its derivative works.  These actions are"),
     strcat(information, "\n"));
    (strcat(
         information,
         "prohibited by law if you do not accept this License.  Therefore, by"),
     strcat(information, "\n"));
    (strcat(information,
            "modifying or distributing the Program (or any work based on the"),
     strcat(information, "\n"));
    (strcat(information, "Program), you indicate your acceptance of this "
                         "License to do so, and"),
     strcat(information, "\n"));
    (strcat(
         information,
         "all its terms and conditions for copying, distributing or modifying"),
     strcat(information, "\n"));
    (strcat(information, "the Program or works based on it."),
     strcat(information, "\n"));
    (strcat(information, ""), strcat(information, "\n"));
    (strcat(information, "  6. Each time you redistribute the Program (or any "
                         "work based on the"),
     strcat(information, "\n"));
    (strcat(
         information,
         "Program), the recipient automatically receives a license from the"),
     strcat(information, "\n"));
    (strcat(information, "original licensor to copy, distribute or modify the "
                         "Program subject to"),
     strcat(information, "\n"));
    (strcat(information,
            "these terms and conditions.  You may not impose any further"),
     strcat(information, "\n"));
    (strcat(information, "restrictions on the recipients' exercise of the "
                         "rights granted herein."),
     strcat(information, "\n"));
    (strcat(information, "You are not responsible for enforcing compliance by "
                         "third parties to"),
     strcat(information, "\n"));
    (strcat(information, "this License."), strcat(information, "\n"));
    (strcat(information, ""), strcat(information, "\n"));
    (strcat(information, "  7. If, as a consequence of a court judgment or "
                         "allegation of patent"),
     strcat(information, "\n"));
    (strcat(information, "infringement or for any other reason (not limited to "
                         "patent issues),"),
     strcat(information, "\n"));
    (strcat(
         information,
         "conditions are imposed on you (whether by court order, agreement or"),
     strcat(information, "\n"));
    (strcat(information, "otherwise) that contradict the conditions of this "
                         "License, they do not"),
     strcat(information, "\n"));
    (strcat(information,
            "excuse you from the conditions of this License.  If you cannot"),
     strcat(information, "\n"));
    (strcat(information, "distribute so as to satisfy simultaneously your "
                         "obligations under this"),
     strcat(information, "\n"));
    (strcat(information, "License and any other pertinent obligations, then as "
                         "a consequence you"),
     strcat(information, "\n"));
    (strcat(information,
            "may not distribute the Program at all.  For example, if a patent"),
     strcat(information, "\n"));
    (strcat(information, "license would not permit royalty-free redistribution "
                         "of the Program by"),
     strcat(information, "\n"));
    (strcat(information, "all those who receive copies directly or indirectly "
                         "through you, then"),
     strcat(information, "\n"));
    (strcat(
         information,
         "the only way you could satisfy both it and this License would be to"),
     strcat(information, "\n"));
    (strcat(information, "refrain entirely from distribution of the Program."),
     strcat(information, "\n"));
    (strcat(information, ""), strcat(information, "\n"));
    (strcat(information, "If any portion of this section is held invalid or "
                         "unenforceable under"),
     strcat(information, "\n"));
    (strcat(information, "any particular circumstance, the balance of the "
                         "section is intended to"),
     strcat(information, "\n"));
    (strcat(information,
            "apply and the section as a whole is intended to apply in other"),
     strcat(information, "\n"));
    (strcat(information, "circumstances."), strcat(information, "\n"));
    (strcat(information, ""), strcat(information, "\n"));
    (strcat(
         information,
         "It is not the purpose of this section to induce you to infringe any"),
     strcat(information, "\n"));
    (strcat(information, "patents or other property right claims or to contest "
                         "validity of any"),
     strcat(information, "\n"));
    (strcat(information,
            "such claims; this section has the sole purpose of protecting the"),
     strcat(information, "\n"));
    (strcat(information,
            "integrity of the free software distribution system, which is"),
     strcat(information, "\n"));
    (strcat(information,
            "implemented by public license practices.  Many people have made"),
     strcat(information, "\n"));
    (strcat(information,
            "generous contributions to the wide range of software distributed"),
     strcat(information, "\n"));
    (strcat(
         information,
         "through that system in reliance on consistent application of that"),
     strcat(information, "\n"));
    (strcat(information, "system; it is up to the author/donor to decide if he "
                         "or she is willing"),
     strcat(information, "\n"));
    (strcat(information, "to distribute software through any other system and "
                         "a licensee cannot"),
     strcat(information, "\n"));
    (strcat(information, "impose that choice."), strcat(information, "\n"));
    (strcat(information, ""), strcat(information, "\n"));
    (strcat(information, "This section is intended to make thoroughly clear "
                         "what is believed to"),
     strcat(information, "\n"));
    (strcat(information, "be a consequence of the rest of this License."),
     strcat(information, "\n"));
    (strcat(information, ""), strcat(information, "\n"));
    (strcat(
         information,
         "  8. If the distribution and/or use of the Program is restricted in"),
     strcat(information, "\n"));
    (strcat(information, "certain countries either by patents or by "
                         "copyrighted interfaces, the"),
     strcat(information, "\n"));
    (strcat(
         information,
         "original copyright holder who places the Program under this License"),
     strcat(information, "\n"));
    (strcat(
         information,
         "may add an explicit geographical distribution limitation excluding"),
     strcat(information, "\n"));
    (strcat(
         information,
         "those countries, so that distribution is permitted only in or among"),
     strcat(information, "\n"));
    (strcat(information, "countries not thus excluded.  In such case, this "
                         "License incorporates"),
     strcat(information, "\n"));
    (strcat(information,
            "the limitation as if written in the body of this License."),
     strcat(information, "\n"));
    (strcat(information, ""), strcat(information, "\n"));
    (strcat(information, "  9. The Free Software Foundation may publish "
                         "revised and/or new versions"),
     strcat(information, "\n"));
    (strcat(information, "of the General Public License from time to time.  "
                         "Such new versions will"),
     strcat(information, "\n"));
    (strcat(information, "be similar in spirit to the present version, but may "
                         "differ in detail to"),
     strcat(information, "\n"));
    (strcat(information, "address new problems or concerns."),
     strcat(information, "\n"));
    (strcat(information, ""), strcat(information, "\n"));
    (strcat(information, "Each version is given a distinguishing version "
                         "number.  If the Program"),
     strcat(information, "\n"));
    (strcat(information, "specifies a version number of this License which "
                         "applies to it and any"),
     strcat(information, "\n"));
    (strcat(information, "later version, you have the option of following the "
                         "terms and conditions"),
     strcat(information, "\n"));
    (strcat(information, "either of that version or of any later version "
                         "published by the Free"),
     strcat(information, "\n"));
    (strcat(information, "Software Foundation.  If the Program does not "
                         "specify a version number of"),
     strcat(information, "\n"));
    (strcat(information, "this License, you may choose any version ever "
                         "published by the Free Software"),
     strcat(information, "\n"));
    (strcat(information, "Foundation."), strcat(information, "\n"));
    (strcat(information, ""), strcat(information, "\n"));
    (strcat(information, "  10. If you wish to incorporate parts of the "
                         "Program into other free"),
     strcat(information, "\n"));
    (strcat(information, "programs whose distribution conditions are "
                         "different, write to the author"),
     strcat(information, "\n"));
    (strcat(information, "to ask for permission.  For software which is "
                         "copyrighted by the Free"),
     strcat(information, "\n"));
    (strcat(information, "Software Foundation, write to the Free Software "
                         "Foundation; we sometimes"),
     strcat(information, "\n"));
    (strcat(information, "make exceptions for this.  Our decision will be "
                         "guided by the two goals"),
     strcat(information, "\n"));
    (strcat(information, "of preserving the free status of all derivatives of "
                         "our free software and"),
     strcat(information, "\n"));
    (strcat(information,
            "of promoting the sharing and reuse of software generally."),
     strcat(information, "\n"));
    (strcat(information, ""), strcat(information, "\n"));
    (strcat(information, "		     END OF TERMS AND CONDITIONS"),
     strcat(information, "\n"));
    (strcat(information, "              -----------------------------------"),
     strcat(information, "\n"));
  }
  printf("%s\n", information);
}


x86 assembly (clang, -O0):
<Copyright>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %edi,-0x4(%rbp)
movb   $0x0,0x7f0e(%rip)
cmpl   $0x1,-0x4(%rbp)
jne    11d4 <Copyright+0xb4>
lea    0x7efd(%rip),%rdi
lea    0x2eb6(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7eea(%rip),%rdi
lea    0x5ff9(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7ed7(%rip),%rdi
lea    0x2ec2(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7ec4(%rip),%rdi
lea    0x5fd3(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7eb1(%rip),%rdi
lea    0x2eef(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7e9e(%rip),%rdi
lea    0x5fad(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7e8b(%rip),%rdi
lea    0x2f07(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7e78(%rip),%rdi
lea    0x5f87(%rip),%rsi
call   1040 <strcat@plt>
cmpl   $0x2,-0x4(%rbp)
jne    1522 <Copyright+0x402>
lea    0x7e5b(%rip),%rdi
lea    0x2f1c(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7e48(%rip),%rdi
lea    0x5f57(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7e35(%rip),%rdi
lea    0x2f2e(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7e22(%rip),%rdi
lea    0x5f31(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7e0f(%rip),%rdi
lea    0x2f40(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7dfc(%rip),%rdi
lea    0x5f0b(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7de9(%rip),%rdi
lea    0x2f62(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7dd6(%rip),%rdi
lea    0x5ee5(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7dc3(%rip),%rdi
lea    0x2f88(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7db0(%rip),%rdi
lea    0x5ebf(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7d9d(%rip),%rdi
lea    0x2fac(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7d8a(%rip),%rdi
lea    0x5e99(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7d77(%rip),%rdi
lea    0x2fd4(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7d64(%rip),%rdi
lea    0x5e73(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7d51(%rip),%rdi
lea    0x2ff6(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7d3e(%rip),%rdi
lea    0x5e4d(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7d2b(%rip),%rdi
lea    0x301d(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7d18(%rip),%rdi
lea    0x5e27(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7d05(%rip),%rdi
lea    0x3042(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7cf2(%rip),%rdi
lea    0x5e01(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7cdf(%rip),%rdi
lea    0x3068(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7ccc(%rip),%rdi
lea    0x5ddb(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7cb9(%rip),%rdi
lea    0x5dc9(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7ca6(%rip),%rdi
lea    0x5db5(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7c93(%rip),%rdi
lea    0x3035(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7c80(%rip),%rdi
lea    0x5d8f(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7c6d(%rip),%rdi
lea    0x3058(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7c5a(%rip),%rdi
lea    0x5d69(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7c47(%rip),%rdi
lea    0x3079(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7c34(%rip),%rdi
lea    0x5d43(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7c21(%rip),%rdi
lea    0x30a1(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7c0e(%rip),%rdi
lea    0x5d1d(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7bfb(%rip),%rdi
lea    0x30ca(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7be8(%rip),%rdi
lea    0x5cf7(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7bd5(%rip),%rdi
lea    0x30f1(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7bc2(%rip),%rdi
lea    0x5cd1(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7baf(%rip),%rdi
lea    0x3117(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7b9c(%rip),%rdi
lea    0x5cab(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7b89(%rip),%rdi
lea    0x313f(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7b76(%rip),%rdi
lea    0x5c85(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7b63(%rip),%rdi
lea    0x3162(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7b50(%rip),%rdi
lea    0x5c5f(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7b3d(%rip),%rdi
lea    0x2c36(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7b2a(%rip),%rdi
lea    0x5c39(%rip),%rsi
call   1040 <strcat@plt>
cmpl   $0x3,-0x4(%rbp)
jne    3302 <Copyright+0x21e2>
lea    0x7b0d(%rip),%rdi
lea    0x312c(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7afa(%rip),%rdi
lea    0x5c09(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7ae7(%rip),%rdi
lea    0x312a(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7ad4(%rip),%rdi
lea    0x5be3(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7ac1(%rip),%rdi
lea    0x5bd1(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7aae(%rip),%rdi
lea    0x5bbd(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7a9b(%rip),%rdi
lea    0x3121(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7a88(%rip),%rdi
lea    0x5b97(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7a75(%rip),%rdi
lea    0x3141(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7a62(%rip),%rdi
lea    0x5b71(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7a4f(%rip),%rdi
lea    0x3160(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7a3c(%rip),%rdi
lea    0x5b4b(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7a29(%rip),%rdi
lea    0x3181(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7a16(%rip),%rdi
lea    0x5b25(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7a03(%rip),%rdi
lea    0x319f(%rip),%rsi
call   1040 <strcat@plt>
lea    0x79f0(%rip),%rdi
lea    0x5aff(%rip),%rsi
call   1040 <strcat@plt>
lea    0x79dd(%rip),%rdi
lea    0x31be(%rip),%rsi
call   1040 <strcat@plt>
lea    0x79ca(%rip),%rdi
lea    0x5ad9(%rip),%rsi
call   1040 <strcat@plt>
lea    0x79b7(%rip),%rdi
lea    0x31da(%rip),%rsi
call   1040 <strcat@plt>
lea    0x79a4(%rip),%rdi
lea    0x5ab3(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7991(%rip),%rdi
lea    0x31f9(%rip),%rsi
call   1040 <strcat@plt>
lea    0x797e(%rip),%rdi
lea    0x5a8d(%rip),%rsi
call   1040 <strcat@plt>
lea    0x796b(%rip),%rdi
lea    0x321a(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7958(%rip),%rdi
lea    0x5a67(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7945(%rip),%rdi
lea    0x5a55(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7932(%rip),%rdi
lea    0x5a41(%rip),%rsi
call   1040 <strcat@plt>
lea    0x791f(%rip),%rdi
lea    0x320a(%rip),%rsi
call   1040 <strcat@plt>
lea    0x790c(%rip),%rdi
lea    0x5a1b(%rip),%rsi
call   1040 <strcat@plt>
lea    0x78f9(%rip),%rdi
lea    0x3229(%rip),%rsi
call   1040 <strcat@plt>
lea    0x78e6(%rip),%rdi
lea    0x59f5(%rip),%rsi
call   1040 <strcat@plt>
lea    0x78d3(%rip),%rdi
lea    0x3244(%rip),%rsi
call   1040 <strcat@plt>
lea    0x78c0(%rip),%rdi
lea    0x59cf(%rip),%rsi
call   1040 <strcat@plt>
lea    0x78ad(%rip),%rdi
lea    0x3265(%rip),%rsi
call   1040 <strcat@plt>
lea    0x789a(%rip),%rdi
lea    0x59a9(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7887(%rip),%rdi
lea    0x327e(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7874(%rip),%rdi
lea    0x5983(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7861(%rip),%rdi
lea    0x329a(%rip),%rsi
call   1040 <strcat@plt>
lea    0x784e(%rip),%rdi
lea    0x595d(%rip),%rsi
call   1040 <strcat@plt>
lea    0x783b(%rip),%rdi
lea    0x594b(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7828(%rip),%rdi
lea    0x5937(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7815(%rip),%rdi
lea    0x3285(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7802(%rip),%rdi
lea    0x5911(%rip),%rsi
call   1040 <strcat@plt>
lea    0x77ef(%rip),%rdi
lea    0x32a1(%rip),%rsi
call   1040 <strcat@plt>
lea    0x77dc(%rip),%rdi
lea    0x58eb(%rip),%rsi
call   1040 <strcat@plt>
lea    0x77c9(%rip),%rdi
lea    0x32bb(%rip),%rsi
call   1040 <strcat@plt>
lea    0x77b6(%rip),%rdi
lea    0x58c5(%rip),%rsi
call   1040 <strcat@plt>
lea    0x77a3(%rip),%rdi
lea    0x32d9(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7790(%rip),%rdi
lea    0x589f(%rip),%rsi
call   1040 <strcat@plt>
lea    0x777d(%rip),%rdi
lea    0x32f4(%rip),%rsi
call   1040 <strcat@plt>
lea    0x776a(%rip),%rdi
lea    0x5879(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7757(%rip),%rdi
lea    0x3315(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7744(%rip),%rdi
lea    0x5853(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7731(%rip),%rdi
lea    0x3333(%rip),%rsi
call   1040 <strcat@plt>
lea    0x771e(%rip),%rdi
lea    0x582d(%rip),%rsi
call   1040 <strcat@plt>
lea    0x770b(%rip),%rdi
lea    0x581b(%rip),%rsi
call   1040 <strcat@plt>
lea    0x76f8(%rip),%rdi
lea    0x5807(%rip),%rsi
call   1040 <strcat@plt>
lea    0x76e5(%rip),%rdi
lea    0x32ff(%rip),%rsi
call   1040 <strcat@plt>
lea    0x76d2(%rip),%rdi
lea    0x57e1(%rip),%rsi
call   1040 <strcat@plt>
lea    0x76bf(%rip),%rdi
lea    0x331f(%rip),%rsi
call   1040 <strcat@plt>
lea    0x76ac(%rip),%rdi
lea    0x57bb(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7699(%rip),%rdi
lea    0x57a9(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7686(%rip),%rdi
lea    0x5795(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7673(%rip),%rdi
lea    0x331b(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7660(%rip),%rdi
lea    0x576f(%rip),%rsi
call   1040 <strcat@plt>
lea    0x764d(%rip),%rdi
lea    0x333b(%rip),%rsi
call   1040 <strcat@plt>
lea    0x763a(%rip),%rdi
lea    0x5749(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7627(%rip),%rdi
lea    0x3353(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7614(%rip),%rdi
lea    0x5723(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7601(%rip),%rdi
lea    0x3370(%rip),%rsi
call   1040 <strcat@plt>
lea    0x75ee(%rip),%rdi
lea    0x56fd(%rip),%rsi
call   1040 <strcat@plt>
lea    0x75db(%rip),%rdi
lea    0x56eb(%rip),%rsi
call   1040 <strcat@plt>
lea    0x75c8(%rip),%rdi
lea    0x56d7(%rip),%rsi
call   1040 <strcat@plt>
lea    0x75b5(%rip),%rdi
lea    0x3360(%rip),%rsi
call   1040 <strcat@plt>
lea    0x75a2(%rip),%rdi
lea    0x56b1(%rip),%rsi
call   1040 <strcat@plt>
lea    0x758f(%rip),%rdi
lea    0x337e(%rip),%rsi
call   1040 <strcat@plt>
lea    0x757c(%rip),%rdi
lea    0x568b(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7569(%rip),%rdi
lea    0x5679(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7556(%rip),%rdi
lea    0x5665(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7543(%rip),%rdi
lea    0x3375(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7530(%rip),%rdi
lea    0x563f(%rip),%rsi
call   1040 <strcat@plt>
lea    0x751d(%rip),%rdi
lea    0x3396(%rip),%rsi
call   1040 <strcat@plt>
lea    0x750a(%rip),%rdi
lea    0x5619(%rip),%rsi
call   1040 <strcat@plt>
lea    0x74f7(%rip),%rdi
lea    0x33b4(%rip),%rsi
call   1040 <strcat@plt>
lea    0x74e4(%rip),%rdi
lea    0x55f3(%rip),%rsi
call   1040 <strcat@plt>
lea    0x74d1(%rip),%rdi
lea    0x33d4(%rip),%rsi
call   1040 <strcat@plt>
lea    0x74be(%rip),%rdi
lea    0x55cd(%rip),%rsi
call   1040 <strcat@plt>
lea    0x74ab(%rip),%rdi
lea    0x55bb(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7498(%rip),%rdi
lea    0x55a7(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7485(%rip),%rdi
lea    0x33b5(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7472(%rip),%rdi
lea    0x5581(%rip),%rsi
call   1040 <strcat@plt>
lea    0x745f(%rip),%rdi
lea    0x33d4(%rip),%rsi
call   1040 <strcat@plt>
lea    0x744c(%rip),%rdi
lea    0x555b(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7439(%rip),%rdi
lea    0x33ed(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7426(%rip),%rdi
lea    0x5535(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7413(%rip),%rdi
lea    0x340c(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7400(%rip),%rdi
lea    0x550f(%rip),%rsi
call   1040 <strcat@plt>
lea    0x73ed(%rip),%rdi
lea    0x3427(%rip),%rsi
call   1040 <strcat@plt>
lea    0x73da(%rip),%rdi
lea    0x54e9(%rip),%rsi
call   1040 <strcat@plt>
lea    0x73c7(%rip),%rdi
lea    0x3448(%rip),%rsi
call   1040 <strcat@plt>
lea    0x73b4(%rip),%rdi
lea    0x54c3(%rip),%rsi
call   1040 <strcat@plt>
lea    0x73a1(%rip),%rdi
lea    0x3464(%rip),%rsi
call   1040 <strcat@plt>
lea    0x738e(%rip),%rdi
lea    0x549d(%rip),%rsi
call   1040 <strcat@plt>
lea    0x737b(%rip),%rdi
lea    0x3484(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7368(%rip),%rdi
lea    0x5477(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7355(%rip),%rdi
lea    0x34a1(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7342(%rip),%rdi
lea    0x5451(%rip),%rsi
call   1040 <strcat@plt>
lea    0x732f(%rip),%rdi
lea    0x34c0(%rip),%rsi
call   1040 <strcat@plt>
lea    0x731c(%rip),%rdi
lea    0x542b(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7309(%rip),%rdi
lea    0x5419(%rip),%rsi
call   1040 <strcat@plt>
lea    0x72f6(%rip),%rdi
lea    0x5405(%rip),%rsi
call   1040 <strcat@plt>
lea    0x72e3(%rip),%rdi
lea    0x34af(%rip),%rsi
call   1040 <strcat@plt>
lea    0x72d0(%rip),%rdi
lea    0x53df(%rip),%rsi
call   1040 <strcat@plt>
lea    0x72bd(%rip),%rdi
lea    0x34c7(%rip),%rsi
call   1040 <strcat@plt>
lea    0x72aa(%rip),%rdi
lea    0x53b9(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7297(%rip),%rdi
lea    0x34e6(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7284(%rip),%rdi
lea    0x5393(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7271(%rip),%rdi
lea    0x3503(%rip),%rsi
call   1040 <strcat@plt>
lea    0x725e(%rip),%rdi
lea    0x536d(%rip),%rsi
call   1040 <strcat@plt>
lea    0x724b(%rip),%rdi
lea    0x3521(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7238(%rip),%rdi
lea    0x5347(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7225(%rip),%rdi
lea    0x353e(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7212(%rip),%rdi
lea    0x5321(%rip),%rsi
call   1040 <strcat@plt>
lea    0x71ff(%rip),%rdi
lea    0x355e(%rip),%rsi
call   1040 <strcat@plt>
lea    0x71ec(%rip),%rdi
lea    0x52fb(%rip),%rsi
call   1040 <strcat@plt>
lea    0x71d9(%rip),%rdi
lea    0x357e(%rip),%rsi
call   1040 <strcat@plt>
lea    0x71c6(%rip),%rdi
lea    0x52d5(%rip),%rsi
call   1040 <strcat@plt>
lea    0x71b3(%rip),%rdi
lea    0x359a(%rip),%rsi
call   1040 <strcat@plt>
lea    0x71a0(%rip),%rdi
lea    0x52af(%rip),%rsi
call   1040 <strcat@plt>
lea    0x718d(%rip),%rdi
lea    0x529d(%rip),%rsi
call   1040 <strcat@plt>
lea    0x717a(%rip),%rdi
lea    0x5289(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7167(%rip),%rdi
lea    0x3598(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7154(%rip),%rdi
lea    0x5263(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7141(%rip),%rdi
lea    0x35b8(%rip),%rsi
call   1040 <strcat@plt>
lea    0x712e(%rip),%rdi
lea    0x523d(%rip),%rsi
call   1040 <strcat@plt>
lea    0x711b(%rip),%rdi
lea    0x35d8(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7108(%rip),%rdi
lea    0x5217(%rip),%rsi
call   1040 <strcat@plt>
lea    0x70f5(%rip),%rdi
lea    0x35f2(%rip),%rsi
call   1040 <strcat@plt>
lea    0x70e2(%rip),%rdi
lea    0x51f1(%rip),%rsi
call   1040 <strcat@plt>
lea    0x70cf(%rip),%rdi
lea    0x51df(%rip),%rsi
call   1040 <strcat@plt>
lea    0x70bc(%rip),%rdi
lea    0x51cb(%rip),%rsi
call   1040 <strcat@plt>
lea    0x70a9(%rip),%rdi
lea    0x35cd(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7096(%rip),%rdi
lea    0x51a5(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7083(%rip),%rdi
lea    0x35ee(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7070(%rip),%rdi
lea    0x517f(%rip),%rsi
call   1040 <strcat@plt>
lea    0x705d(%rip),%rdi
lea    0x360e(%rip),%rsi
call   1040 <strcat@plt>
lea    0x704a(%rip),%rdi
lea    0x5159(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7037(%rip),%rdi
lea    0x362d(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7024(%rip),%rdi
lea    0x5133(%rip),%rsi
call   1040 <strcat@plt>
lea    0x7011(%rip),%rdi
lea    0x5121(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6ffe(%rip),%rdi
lea    0x510d(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6feb(%rip),%rdi
lea    0x35fc(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6fd8(%rip),%rdi
lea    0x50e7(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6fc5(%rip),%rdi
lea    0x361b(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6fb2(%rip),%rdi
lea    0x50c1(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6f9f(%rip),%rdi
lea    0x363b(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6f8c(%rip),%rdi
lea    0x509b(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6f79(%rip),%rdi
lea    0x5089(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6f66(%rip),%rdi
lea    0x5075(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6f53(%rip),%rdi
lea    0x3636(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6f40(%rip),%rdi
lea    0x504f(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6f2d(%rip),%rdi
lea    0x3655(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6f1a(%rip),%rdi
lea    0x5029(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6f07(%rip),%rdi
lea    0x3676(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6ef4(%rip),%rdi
lea    0x5003(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6ee1(%rip),%rdi
lea    0x4ff1(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6ece(%rip),%rdi
lea    0x4fdd(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6ebb(%rip),%rdi
lea    0x3677(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6ea8(%rip),%rdi
lea    0x4fb7(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6e95(%rip),%rdi
lea    0x3694(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6e82(%rip),%rdi
lea    0x4f91(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6e6f(%rip),%rdi
lea    0x36b1(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6e5c(%rip),%rdi
lea    0x4f6b(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6e49(%rip),%rdi
lea    0x36cd(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6e36(%rip),%rdi
lea    0x4f45(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6e23(%rip),%rdi
lea    0x36e9(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6e10(%rip),%rdi
lea    0x4f1f(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6dfd(%rip),%rdi
lea    0x3709(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6dea(%rip),%rdi
lea    0x4ef9(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6dd7(%rip),%rdi
lea    0x4ee7(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6dc4(%rip),%rdi
lea    0x4ed3(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6db1(%rip),%rdi
lea    0x36f0(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6d9e(%rip),%rdi
lea    0x4ead(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6d8b(%rip),%rdi
lea    0x3710(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6d78(%rip),%rdi
lea    0x4e87(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6d65(%rip),%rdi
lea    0x372d(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6d52(%rip),%rdi
lea    0x4e61(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6d3f(%rip),%rdi
lea    0x3747(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6d2c(%rip),%rdi
lea    0x4e3b(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6d19(%rip),%rdi
lea    0x3766(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6d06(%rip),%rdi
lea    0x4e15(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6cf3(%rip),%rdi
lea    0x4e03(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6ce0(%rip),%rdi
lea    0x4def(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6ccd(%rip),%rdi
lea    0x374c(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6cba(%rip),%rdi
lea    0x4dc9(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6ca7(%rip),%rdi
lea    0x376a(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6c94(%rip),%rdi
lea    0x4da3(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6c81(%rip),%rdi
lea    0x3789(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6c6e(%rip),%rdi
lea    0x4d7d(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6c5b(%rip),%rdi
lea    0x37a8(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6c48(%rip),%rdi
lea    0x4d57(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6c35(%rip),%rdi
lea    0x37c2(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6c22(%rip),%rdi
lea    0x4d31(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6c0f(%rip),%rdi
lea    0x37e3(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6bfc(%rip),%rdi
lea    0x4d0b(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6be9(%rip),%rdi
lea    0x37fd(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6bd6(%rip),%rdi
lea    0x4ce5(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6bc3(%rip),%rdi
lea    0x3819(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6bb0(%rip),%rdi
lea    0x4cbf(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6b9d(%rip),%rdi
lea    0x3838(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6b8a(%rip),%rdi
lea    0x4c99(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6b77(%rip),%rdi
lea    0x3857(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6b64(%rip),%rdi
lea    0x4c73(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6b51(%rip),%rdi
lea    0x4c61(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6b3e(%rip),%rdi
lea    0x4c4d(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6b2b(%rip),%rdi
lea    0x382e(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6b18(%rip),%rdi
lea    0x4c27(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6b05(%rip),%rdi
lea    0x3849(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6af2(%rip),%rdi
lea    0x4c01(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6adf(%rip),%rdi
lea    0x3864(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6acc(%rip),%rdi
lea    0x4bdb(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6ab9(%rip),%rdi
lea    0x387b(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6aa6(%rip),%rdi
lea    0x4bb5(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6a93(%rip),%rdi
lea    0x3898(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6a80(%rip),%rdi
lea    0x4b8f(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6a6d(%rip),%rdi
lea    0x4b7d(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6a5a(%rip),%rdi
lea    0x4b69(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6a47(%rip),%rdi
lea    0x3885(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6a34(%rip),%rdi
lea    0x4b43(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6a21(%rip),%rdi
lea    0x38a4(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6a0e(%rip),%rdi
lea    0x4b1d(%rip),%rsi
call   1040 <strcat@plt>
lea    0x69fb(%rip),%rdi
lea    0x38bc(%rip),%rsi
call   1040 <strcat@plt>
lea    0x69e8(%rip),%rdi
lea    0x4af7(%rip),%rsi
call   1040 <strcat@plt>
lea    0x69d5(%rip),%rdi
lea    0x38d9(%rip),%rsi
call   1040 <strcat@plt>
lea    0x69c2(%rip),%rdi
lea    0x4ad1(%rip),%rsi
call   1040 <strcat@plt>
lea    0x69af(%rip),%rdi
lea    0x38fa(%rip),%rsi
call   1040 <strcat@plt>
lea    0x699c(%rip),%rdi
lea    0x4aab(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6989(%rip),%rdi
lea    0x3919(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6976(%rip),%rdi
lea    0x4a85(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6963(%rip),%rdi
lea    0x3938(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6950(%rip),%rdi
lea    0x4a5f(%rip),%rsi
call   1040 <strcat@plt>
lea    0x693d(%rip),%rdi
lea    0x4a4d(%rip),%rsi
call   1040 <strcat@plt>
lea    0x692a(%rip),%rdi
lea    0x4a39(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6917(%rip),%rdi
lea    0x390f(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6904(%rip),%rdi
lea    0x4a13(%rip),%rsi
call   1040 <strcat@plt>
lea    0x68f1(%rip),%rdi
lea    0x392e(%rip),%rsi
call   1040 <strcat@plt>
lea    0x68de(%rip),%rdi
lea    0x49ed(%rip),%rsi
call   1040 <strcat@plt>
lea    0x68cb(%rip),%rdi
lea    0x394d(%rip),%rsi
call   1040 <strcat@plt>
lea    0x68b8(%rip),%rdi
lea    0x49c7(%rip),%rsi
call   1040 <strcat@plt>
lea    0x68a5(%rip),%rdi
lea    0x396a(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6892(%rip),%rdi
lea    0x49a1(%rip),%rsi
call   1040 <strcat@plt>
lea    0x687f(%rip),%rdi
lea    0x3988(%rip),%rsi
call   1040 <strcat@plt>
lea    0x686c(%rip),%rdi
lea    0x497b(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6859(%rip),%rdi
lea    0x39a2(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6846(%rip),%rdi
lea    0x4955(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6833(%rip),%rdi
lea    0x39c1(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6820(%rip),%rdi
lea    0x492f(%rip),%rsi
call   1040 <strcat@plt>
lea    0x680d(%rip),%rdi
lea    0x39df(%rip),%rsi
call   1040 <strcat@plt>
lea    0x67fa(%rip),%rdi
lea    0x4909(%rip),%rsi
call   1040 <strcat@plt>
lea    0x67e7(%rip),%rdi
lea    0x48f7(%rip),%rsi
call   1040 <strcat@plt>
lea    0x67d4(%rip),%rdi
lea    0x48e3(%rip),%rsi
call   1040 <strcat@plt>
lea    0x67c1(%rip),%rdi
lea    0x39b5(%rip),%rsi
call   1040 <strcat@plt>
lea    0x67ae(%rip),%rdi
lea    0x48bd(%rip),%rsi
call   1040 <strcat@plt>
lea    0x679b(%rip),%rdi
lea    0x39d5(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6788(%rip),%rdi
lea    0x4897(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6775(%rip),%rdi
lea    0x39f1(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6762(%rip),%rdi
lea    0x4871(%rip),%rsi
call   1040 <strcat@plt>
lea    0x674f(%rip),%rdi
lea    0x3a12(%rip),%rsi
call   1040 <strcat@plt>
lea    0x673c(%rip),%rdi
lea    0x484b(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6729(%rip),%rdi
lea    0x3a28(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6716(%rip),%rdi
lea    0x4825(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6703(%rip),%rdi
lea    0x3a49(%rip),%rsi
call   1040 <strcat@plt>
lea    0x66f0(%rip),%rdi
lea    0x47ff(%rip),%rsi
call   1040 <strcat@plt>
lea    0x66dd(%rip),%rdi
lea    0x2ce0(%rip),%rsi
call   1040 <strcat@plt>
lea    0x66ca(%rip),%rdi
lea    0x47d9(%rip),%rsi
call   1040 <strcat@plt>
lea    0x66b7(%rip),%rdi
lea    0x47c7(%rip),%rsi
call   1040 <strcat@plt>
lea    0x66a4(%rip),%rdi
lea    0x47b3(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6691(%rip),%rdi
lea    0x3a1c(%rip),%rsi
call   1040 <strcat@plt>
lea    0x667e(%rip),%rdi
lea    0x478d(%rip),%rsi
call   1040 <strcat@plt>
lea    0x666b(%rip),%rdi
lea    0x3a3c(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6658(%rip),%rdi
lea    0x4767(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6645(%rip),%rdi
lea    0x3a5b(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6632(%rip),%rdi
lea    0x4741(%rip),%rsi
call   1040 <strcat@plt>
lea    0x661f(%rip),%rdi
lea    0x3a79(%rip),%rsi
call   1040 <strcat@plt>
lea    0x660c(%rip),%rdi
lea    0x471b(%rip),%rsi
call   1040 <strcat@plt>
lea    0x65f9(%rip),%rdi
lea    0x3a9a(%rip),%rsi
call   1040 <strcat@plt>
lea    0x65e6(%rip),%rdi
lea    0x46f5(%rip),%rsi
call   1040 <strcat@plt>
lea    0x65d3(%rip),%rdi
lea    0x3ab3(%rip),%rsi
call   1040 <strcat@plt>
lea    0x65c0(%rip),%rdi
lea    0x46cf(%rip),%rsi
call   1040 <strcat@plt>
lea    0x65ad(%rip),%rdi
lea    0x3ad4(%rip),%rsi
call   1040 <strcat@plt>
lea    0x659a(%rip),%rdi
lea    0x46a9(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6587(%rip),%rdi
lea    0x3af5(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6574(%rip),%rdi
lea    0x4683(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6561(%rip),%rdi
lea    0x3b10(%rip),%rsi
call   1040 <strcat@plt>
lea    0x654e(%rip),%rdi
lea    0x465d(%rip),%rsi
call   1040 <strcat@plt>
lea    0x653b(%rip),%rdi
lea    0x3b31(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6528(%rip),%rdi
lea    0x4637(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6515(%rip),%rdi
lea    0x3b51(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6502(%rip),%rdi
lea    0x4611(%rip),%rsi
call   1040 <strcat@plt>
lea    0x64ef(%rip),%rdi
lea    0x3b6f(%rip),%rsi
call   1040 <strcat@plt>
lea    0x64dc(%rip),%rdi
lea    0x45eb(%rip),%rsi
call   1040 <strcat@plt>
lea    0x64c9(%rip),%rdi
lea    0x45d9(%rip),%rsi
call   1040 <strcat@plt>
lea    0x64b6(%rip),%rdi
lea    0x45c5(%rip),%rsi
call   1040 <strcat@plt>
lea    0x64a3(%rip),%rdi
lea    0x3b56(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6490(%rip),%rdi
lea    0x459f(%rip),%rsi
call   1040 <strcat@plt>
lea    0x647d(%rip),%rdi
lea    0x3b76(%rip),%rsi
call   1040 <strcat@plt>
lea    0x646a(%rip),%rdi
lea    0x4579(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6457(%rip),%rdi
lea    0x3b97(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6444(%rip),%rdi
lea    0x4553(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6431(%rip),%rdi
lea    0x3bb0(%rip),%rsi
call   1040 <strcat@plt>
lea    0x641e(%rip),%rdi
lea    0x452d(%rip),%rsi
call   1040 <strcat@plt>
lea    0x640b(%rip),%rdi
lea    0x451b(%rip),%rsi
call   1040 <strcat@plt>
lea    0x63f8(%rip),%rdi
lea    0x4507(%rip),%rsi
call   1040 <strcat@plt>
lea    0x63e5(%rip),%rdi
lea    0x3b73(%rip),%rsi
call   1040 <strcat@plt>
lea    0x63d2(%rip),%rdi
lea    0x44e1(%rip),%rsi
call   1040 <strcat@plt>
lea    0x63bf(%rip),%rdi
lea    0x3b91(%rip),%rsi
call   1040 <strcat@plt>
lea    0x63ac(%rip),%rdi
lea    0x44bb(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6399(%rip),%rdi
lea    0x3bb0(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6386(%rip),%rdi
lea    0x4495(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6373(%rip),%rdi
lea    0x3bcb(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6360(%rip),%rdi
lea    0x446f(%rip),%rsi
call   1040 <strcat@plt>
lea    0x634d(%rip),%rdi
lea    0x3be2(%rip),%rsi
call   1040 <strcat@plt>
lea    0x633a(%rip),%rdi
lea    0x4449(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6327(%rip),%rdi
lea    0x3bfc(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6314(%rip),%rdi
lea    0x4423(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6301(%rip),%rdi
lea    0x3c17(%rip),%rsi
call   1040 <strcat@plt>
lea    0x62ee(%rip),%rdi
lea    0x43fd(%rip),%rsi
call   1040 <strcat@plt>
lea    0x62db(%rip),%rdi
lea    0x3c33(%rip),%rsi
call   1040 <strcat@plt>
lea    0x62c8(%rip),%rdi
lea    0x43d7(%rip),%rsi
call   1040 <strcat@plt>
lea    0x62b5(%rip),%rdi
lea    0x3c54(%rip),%rsi
call   1040 <strcat@plt>
lea    0x62a2(%rip),%rdi
lea    0x43b1(%rip),%rsi
call   1040 <strcat@plt>
lea    0x628f(%rip),%rdi
lea    0x3c74(%rip),%rsi
call   1040 <strcat@plt>
lea    0x627c(%rip),%rdi
lea    0x438b(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6269(%rip),%rdi
lea    0x4379(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6256(%rip),%rdi
lea    0x4365(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6243(%rip),%rdi
lea    0x3c3c(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6230(%rip),%rdi
lea    0x433f(%rip),%rsi
call   1040 <strcat@plt>
lea    0x621d(%rip),%rdi
lea    0x3c5c(%rip),%rsi
call   1040 <strcat@plt>
lea    0x620a(%rip),%rdi
lea    0x4319(%rip),%rsi
call   1040 <strcat@plt>
lea    0x61f7(%rip),%rdi
lea    0x4307(%rip),%rsi
call   1040 <strcat@plt>
lea    0x61e4(%rip),%rdi
lea    0x42f3(%rip),%rsi
call   1040 <strcat@plt>
lea    0x61d1(%rip),%rdi
lea    0x3c3e(%rip),%rsi
call   1040 <strcat@plt>
lea    0x61be(%rip),%rdi
lea    0x42cd(%rip),%rsi
call   1040 <strcat@plt>
lea    0x61ab(%rip),%rdi
lea    0x3c5c(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6198(%rip),%rdi
lea    0x42a7(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6185(%rip),%rdi
lea    0x3c7c(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6172(%rip),%rdi
lea    0x4281(%rip),%rsi
call   1040 <strcat@plt>
lea    0x615f(%rip),%rdi
lea    0x3c9a(%rip),%rsi
call   1040 <strcat@plt>
lea    0x614c(%rip),%rdi
lea    0x425b(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6139(%rip),%rdi
lea    0x3cb7(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6126(%rip),%rdi
lea    0x4235(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6113(%rip),%rdi
lea    0x3cd5(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6100(%rip),%rdi
lea    0x420f(%rip),%rsi
call   1040 <strcat@plt>
lea    0x60ed(%rip),%rdi
lea    0x3cf5(%rip),%rsi
call   1040 <strcat@plt>
lea    0x60da(%rip),%rdi
lea    0x41e9(%rip),%rsi
call   1040 <strcat@plt>
lea    0x60c7(%rip),%rdi
lea    0x41d7(%rip),%rsi
call   1040 <strcat@plt>
lea    0x60b4(%rip),%rdi
lea    0x41c3(%rip),%rsi
call   1040 <strcat@plt>
lea    0x60a1(%rip),%rdi
lea    0x3ce3(%rip),%rsi
call   1040 <strcat@plt>
lea    0x608e(%rip),%rdi
lea    0x419d(%rip),%rsi
call   1040 <strcat@plt>
lea    0x607b(%rip),%rdi
lea    0x3d07(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6068(%rip),%rdi
lea    0x4177(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6055(%rip),%rdi
lea    0x3d2a(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6042(%rip),%rdi
lea    0x4151(%rip),%rsi
call   1040 <strcat@plt>
lea    0x602f(%rip),%rdi
lea    0x3d4d(%rip),%rsi
call   1040 <strcat@plt>
lea    0x601c(%rip),%rdi
lea    0x412b(%rip),%rsi
call   1040 <strcat@plt>
lea    0x6009(%rip),%rdi
lea    0x4119(%rip),%rsi
call   1040 <strcat@plt>
lea    0x5ff6(%rip),%rdi
lea    0x4105(%rip),%rsi
call   1040 <strcat@plt>
lea    0x5fe3(%rip),%rdi
lea    0x3d23(%rip),%rsi
call   1040 <strcat@plt>
lea    0x5fd0(%rip),%rdi
lea    0x40df(%rip),%rsi
call   1040 <strcat@plt>
lea    0x5fbd(%rip),%rdi
lea    0x3d44(%rip),%rsi
call   1040 <strcat@plt>
lea    0x5faa(%rip),%rdi
lea    0x40b9(%rip),%rsi
call   1040 <strcat@plt>
lea    0x5f97(%rip),%rdi
lea    0x3d65(%rip),%rsi
call   1040 <strcat@plt>
lea    0x5f84(%rip),%rdi
lea    0x4093(%rip),%rsi
call   1040 <strcat@plt>
lea    0x5f71(%rip),%rdi
lea    0x3d88(%rip),%rsi
call   1040 <strcat@plt>
lea    0x5f5e(%rip),%rdi
lea    0x406d(%rip),%rsi
call   1040 <strcat@plt>
lea    0x5f4b(%rip),%rdi
lea    0x3da7(%rip),%rsi
call   1040 <strcat@plt>
lea    0x5f38(%rip),%rdi
lea    0x4047(%rip),%rsi
call   1040 <strcat@plt>
lea    0x5f25(%rip),%rdi
lea    0x3dcb(%rip),%rsi
call   1040 <strcat@plt>
lea    0x5f12(%rip),%rdi
lea    0x4021(%rip),%rsi
call   1040 <strcat@plt>
lea    0x5eff(%rip),%rdi
lea    0x3df2(%rip),%rsi
call   1040 <strcat@plt>
lea    0x5eec(%rip),%rdi
lea    0x3ffb(%rip),%rsi
call   1040 <strcat@plt>
lea    0x5ed9(%rip),%rdi
lea    0x3fe9(%rip),%rsi
call   1040 <strcat@plt>
lea    0x5ec6(%rip),%rdi
lea    0x3fd5(%rip),%rsi
call   1040 <strcat@plt>
lea    0x5eb3(%rip),%rdi
lea    0x3db2(%rip),%rsi
call   1040 <strcat@plt>
lea    0x5ea0(%rip),%rdi
lea    0x3faf(%rip),%rsi
call   1040 <strcat@plt>
lea    0x5e8d(%rip),%rdi
lea    0x3dd2(%rip),%rsi
call   1040 <strcat@plt>
lea    0x5e7a(%rip),%rdi
lea    0x3f89(%rip),%rsi
call   1040 <strcat@plt>
lea    0x5e67(%rip),%rdi
lea    0x3df6(%rip),%rsi
call   1040 <strcat@plt>
lea    0x5e54(%rip),%rdi
lea    0x3f63(%rip),%rsi
call   1040 <strcat@plt>
lea    0x5e41(%rip),%rdi
lea    0x3e16(%rip),%rsi
call   1040 <strcat@plt>
lea    0x5e2e(%rip),%rdi
lea    0x3f3d(%rip),%rsi
call   1040 <strcat@plt>
lea    0x5e1b(%rip),%rdi
lea    0x3e39(%rip),%rsi
call   1040 <strcat@plt>
lea    0x5e08(%rip),%rdi
lea    0x3f17(%rip),%rsi
call   1040 <strcat@plt>
lea    0x5df5(%rip),%rdi
lea    0x3e5b(%rip),%rsi
call   1040 <strcat@plt>
lea    0x5de2(%rip),%rdi
lea    0x3ef1(%rip),%rsi
call   1040 <strcat@plt>
lea    0x5dcf(%rip),%rdi
lea    0x3e7f(%rip),%rsi
call   1040 <strcat@plt>
lea    0x5dbc(%rip),%rdi
lea    0x3ecb(%rip),%rsi
call   1040 <strcat@plt>
lea    0x5da9(%rip),%rdi
lea    0x3eb9(%rip),%rsi
call   1040 <strcat@plt>
lea    0x5d96(%rip),%rdi
lea    0x3ea5(%rip),%rsi
call   1040 <strcat@plt>
lea    0x5d83(%rip),%rdi
lea    0x3e6d(%rip),%rsi
call   1040 <strcat@plt>
lea    0x5d70(%rip),%rdi
lea    0x3e7f(%rip),%rsi
call   1040 <strcat@plt>
lea    0x5d5d(%rip),%rdi
lea    0xe5c(%rip),%rsi
call   1040 <strcat@plt>
lea    0x5d4a(%rip),%rdi
lea    0x3e59(%rip),%rsi
call   1040 <strcat@plt>
lea    0x3e4b(%rip),%rdi
lea    0x5d30(%rip),%rsi
mov    $0x0,%al
call   1030 <printf@plt>
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Copyright>:
push   %r15
push   %r14
push   %r12
push   %rbx
push   %rax
movb   $0x0,0x8f11(%rip)
cmp    $0x3,%edi
je     127a <Copyright+0x15a>
cmp    $0x2,%edi
je     4716 <Copyright+0x35f6>
cmp    $0x1,%edi
jne    4d69 <Copyright+0x3c49>
lea    0x8eef(%rip),%rbx
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3ea0(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3ea5(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3ea9(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movw   $0x6e,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3e92(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3e97(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3e9b(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3e9f(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movups 0x3ea3(%rip),%xmm0
movups %xmm0,0x40(%rax,%rbx,1)
movl   $0x2e736c,0x4f(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3e8c(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3e91(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3e95(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3e97(%rip),%xmm0
movups %xmm0,0x2e(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x736c6961746564,%rcx
mov    %rcx,0x3d(%rax,%rbx,1)
movups 0x3e76(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3e7b(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3e7f(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3e83(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
jmp    4d54 <Copyright+0x3c34>
lea    0x8dbf(%rip),%rbx
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x43d6(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x43db(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movl   $0x45534e,0x20(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x43c5(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x43ca(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x43ce(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x43d2(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movl   $0x4e4f49,0x3f(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x736e6961746e6f,%rcx
mov    %rcx,0x3e(%rax,%rbx,1)
movups 0x439e(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x43a3(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x43a7(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x43ab(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x64657475626972,%rcx
mov    %rcx,0x3d(%rax,%rbx,1)
movups 0x4390(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x4395(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x4399(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x439d(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x2c776f6c656220,%rcx
mov    %rcx,0x3f(%rax,%rbx,1)
movups 0x4381(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x4386(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x438a(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x438e(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x4383(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x4388(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x438c(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x4390(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movl   $0x6d6172,0x40(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x3a77616c207468,%rcx
mov    %rcx,0x3d(%rax,%rbx,1)
movups 0x436b(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x4370(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x4374(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x4378(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x436b(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x4370(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x4374(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x4378(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movw   $0x2c,0x40(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x726568746f6e61,%rcx
mov    %rcx,0x3d(%rax,%rbx,1)
movups 0x4352(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x4357(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x435b(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x435f(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x6e69206e6f6974,%rcx
mov    %rcx,0x3f(%rax,%rbx,1)
movups 0x4343(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x4348(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x434c(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x4350(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x4345(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x434a(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x434e(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x434e(%rip),%xmm0
movups %xmm0,0x2c(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x746f6e20657261,%rcx
mov    %rcx,0x3d(%rax,%rbx,1)
movups 0x431f(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x4324(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x4328(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x432c(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x431f(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x4324(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x4328(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x432c(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movb   $0x0,0x40(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x6d6172676f7250,%r14
mov    %r14,0x3f(%rax,%rbx,1)
movups 0x4307(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x430c(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x4310(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x4314(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x4309(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x430e(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x4312(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x4315(%rip),%xmm0
movups %xmm0,0x2f(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x4303(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x4308(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x430c(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x4310(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movw   $0x2e,0x40(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x2e73656f64206d,%rcx
mov    %rcx,0x2f(%rax,%rbx,1)
movups 0x42ea(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x42ef(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x42f3(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x42da(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x42df(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x42e3(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x42e7(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movw   $0x73,0x40(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x42d0(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x42d5(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x42d9(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x42dd(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x42cb(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x42d0(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x42d4(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x42d8(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movl   $0x657461,0x40(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x42c2(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x42c7(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x42cb(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x42cf(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movb   $0x0,0x40(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x3b79746e617272,%rcx
mov    %rcx,0x3f(%rax,%rbx,1)
movups 0x42aa(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x42af(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x42b3(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x42b7(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x42ac(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x42b1(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x42b5(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x42b9(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movl   $0x65736e,0x40(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x2e6d6172676f72,%r15
mov    %r15,0x10(%rax,%rbx,1)
movups 0x4294(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x646e61202c7970,%rcx
mov    %rcx,0x3e(%rax,%rbx,1)
movups 0x426e(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x4273(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x4277(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x427b(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x2e656566206120,%rcx
mov    %rcx,0x40(%rax,%rbx,1)
movups 0x4260(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x4265(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x4269(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x426d(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x6e6f6974726f70,%rcx
mov    %rcx,0x3e(%rax,%rbx,1)
movups 0x4246(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x424b(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x424f(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x4253(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x4247(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x424c(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x4250(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x4252(%rip),%xmm0
movups %xmm0,0x2e(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x4240(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x4245(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x4249(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x424d(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movl   $0x31206e,0x3f(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x4236(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x423b(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x423f(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x423f(%rip),%xmm0
movups %xmm0,0x2c(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x421f(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x4224(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x4228(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x422c(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movl   $0x736563,0x40(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x4216(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x421b(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x421f(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x4223(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movl   $0x2e6567,0x3f(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x6e692074616874,%rcx
mov    %rcx,0x3f(%rax,%rbx,1)
movups 0x41ef(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x41f4(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x41f8(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x41fc(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x41f1(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x41f6(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x41fa(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x41fe(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movl   $0x796e61,0x40(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x6472696874206c,%rcx
mov    %rcx,0x3e(%rax,%rbx,1)
movups 0x41d9(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x41de(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x41e2(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x41e6(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x41da(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x41df(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x41e0(%rip),%xmm0
movups %xmm0,0x1d(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x796c6576697463,%rcx
mov    %rcx,0x3d(%rax,%rbx,1)
movups 0x41b1(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x41b6(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x41ba(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x41be(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x41b1(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x41b6(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x41ba(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x41bd(%rip),%xmm0
movups %xmm0,0x2f(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x6e612079616c70,%rcx
mov    %rcx,0x3d(%rax,%rbx,1)
movups 0x419c(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x41a1(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x41a5(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x41a9(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x419c(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x41a1(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x41a5(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x41a9(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movb   $0x0,0x40(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x656469766f7270,%rcx
mov    %rcx,0x3f(%rax,%rbx,1)
movups 0x4184(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x4189(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x418d(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x4191(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x4186(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x418b(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x418f(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x4193(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movw   $0x72,0x40(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x7369687420666f,%rcx
mov    %rcx,0x3e(%rax,%rbx,1)
movups 0x416d(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x4172(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x4176(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x417a(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x416e(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x4173(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x4177(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x417b(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movl   $0x747562,0x3f(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x6e6f2064657361,%rcx
mov    %rcx,0x3d(%rax,%rbx,1)
movups 0x4155(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x415a(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x415e(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x4162(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x4155(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x415a(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x415e(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x415d(%rip),%xmm0
movups %xmm0,0x2b(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x413d(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x4142(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x4146(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x4148(%rip),%xmm0
movups %xmm0,0x2e(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x2c6d6172676f72,%rcx
mov    %rcx,0x3d(%rax,%rbx,1)
movups 0x4127(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x412c(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x4130(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x4134(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x4127(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x412c(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x4130(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x4134(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movl   $0x6e6920,0x3f(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x411d(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x4122(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x4126(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x412a(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movl   $0x65736f,0x40(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x4114(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x4119(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x411d(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x4121(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movl   $0x756f79,0x3f(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x6465736162206b,%rcx
mov    %rcx,0x3e(%rax,%rbx,1)
movups 0x40fb(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x4100(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x4104(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x4108(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x666f20736d7265,%r12
mov    %r12,0x3e(%rax,%rbx,1)
movups 0x40ed(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x40f2(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x40f6(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x40fa(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x40ee(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x40f3(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x40f7(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x40fb(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movw   $0x65,0x40(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x40e4(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x40e9(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x40ed(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x40f1(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movups 0x40ef(%rip),%xmm0
movups %xmm0,0x3a(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x747365746e6f63,%rcx
mov    %rcx,0x3e(%rax,%rbx,1)
movups 0x40c0(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x40c5(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x40c9(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x40cd(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x6f742073692074,%rcx
mov    %rcx,0x3e(%rax,%rbx,1)
movups 0x40b2(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x40b7(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x40bb(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x40bf(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x40b3(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x40b8(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x40bc(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x40c0(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
mov    %r15,0x1f(%rax,%rbx,1)
movups 0x40a9(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x40ae(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
mov    %r14,0x3f(%rax,%rbx,1)
movups 0x4090(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x4095(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x4099(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x409d(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x666f20656d756c,%rcx
mov    %rcx,0x3e(%rax,%rbx,1)
movups 0x4083(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x4088(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x408c(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x4090(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x7265646e75206b,%rcx
mov    %rcx,0x3d(%rax,%rbx,1)
movups 0x4075(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x407a(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x407e(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x4082(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x4075(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x4075(%rip),%xmm0
movups %xmm0,0xb(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x2c7469206e6f20,%rcx
mov    %rcx,0x3d(%rax,%rbx,1)
movups 0x4046(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x404b(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x404f(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x4053(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
mov    %r12,0x3e(%rax,%rbx,1)
movups 0x4041(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x4046(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x404a(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x404e(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x3a676e69776f6c,%rcx
mov    %rcx,0x3f(%rax,%rbx,1)
movups 0x4033(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x4038(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x403c(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x4040(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x656c6261646165,%rcx
mov    %rcx,0x3d(%rax,%rbx,1)
movups 0x4018(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x401d(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x4021(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x4025(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x736e6f69746365,%rcx
mov    %rcx,0x3f(%rax,%rbx,1)
movups 0x4009(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x400e(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x4012(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x4016(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x400b(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x4010(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x4014(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x4018(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movups 0x4019(%rip),%xmm0
movups %xmm0,0x3d(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3ff9(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3ffe(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x4002(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x4006(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movl   $0x656572,0x3f(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3fef(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3ff4(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3ff8(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3ffc(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movl   $0x72756f,0x3f(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3fe5(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3fea(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3fee(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3ff2(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movw   $0x65,0x40(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3fdb(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3fe0(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3fe4(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3fe8(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movw   $0x65,0x40(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x6d756964656d20,%rcx
mov    %rcx,0x3e(%rax,%rbx,1)
movups 0x3fc2(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3fc7(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3fcb(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3fcf(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3fc3(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3fc8(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3fcc(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movl   $0x2c726f,0x2f(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x726566666f2065,%rcx
mov    %rcx,0x3e(%rax,%rbx,1)
movups 0x3f98(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3f9d(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3fa1(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3fa5(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3f99(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3f9e(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3fa2(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3fa6(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movl   $0x736920,0x3f(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3f8f(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3f94(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3f98(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3f9c(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x68637573206874,%rcx
mov    %rcx,0x3d(%rax,%rbx,1)
movups 0x3f7b(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3f80(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3f84(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3f88(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3f7b(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3f80(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3f84(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movw   $0x29,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3f5f(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3f64(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3f68(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3f6c(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movl   $0x726f66,0x40(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x656372756f7320,%rcx
mov    %rcx,0x3d(%rax,%rbx,1)
movups 0x3f47(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3f4c(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3f50(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3f54(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x796e612073756c,%rcx
mov    %rcx,0x3d(%rax,%rbx,1)
movups 0x3f38(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3f3d(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3f41(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3f45(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3f38(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3f3d(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3f41(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3f45(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x61207361202c72,%rcx
mov    %rcx,0x3f(%rax,%rbx,1)
movups 0x3f24(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3f29(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3f2d(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3f31(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3f26(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3f2b(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3f2f(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3f33(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3f21(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3f26(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3f2a(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3f2e(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movw   $0x79,0x40(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x65687420666f20,%rcx
mov    %rcx,0x3d(%rax,%rbx,1)
movups 0x3f08(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3f0d(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3f11(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3f15(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x746e656e6f706d,%rcx
mov    %rcx,0x3d(%rax,%rbx,1)
movups 0x3ef9(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3efe(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3f02(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3f06(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3ef9(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3efe(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movl   $0x2e656c,0x1f(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3ed9(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3ede(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3ee2(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3ee6(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movb   $0x0,0x40(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3ed0(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3ed5(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3ed9(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3edd(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movb   $0x0,0x40(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3ec7(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3ecc(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3ed0(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3ed1(%rip),%xmm0
movups %xmm0,0x2d(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3ebf(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3ec4(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3ec8(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3ecc(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movl   $0x746f6e,0x3f(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3eb5(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3eba(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3ebe(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3ebb(%rip),%xmm0
movups %xmm0,0x29(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
mov    %r14,0x3d(%rax,%rbx,1)
movups 0x3e96(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3e9b(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3e9f(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3ea3(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3e96(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3e9b(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3e9f(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3ea1(%rip),%xmm0
movups %xmm0,0x2e(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3e8f(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3e94(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3e98(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3e9c(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movl   $0x736920,0x3f(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x2e65736e656369,%r15
mov    %r15,0x3f(%rax,%rbx,1)
movups 0x3e76(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3e7b(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3e7f(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3e83(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x7265646e752075,%rcx
mov    %rcx,0x3d(%rax,%rbx,1)
movups 0x3e69(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3e6e(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3e72(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3e76(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x68637573207361,%rcx
mov    %rcx,0x3d(%rax,%rbx,1)
movups 0x3e5a(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3e5f(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3e63(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3e67(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3e5a(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3e5f(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movl   $0x2e6563,0x1f(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x746f6e20657661,%rcx
mov    %rcx,0x3d(%rax,%rbx,1)
movups 0x3e2b(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3e30(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3e34(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3e38(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x726f2079666964,%rcx
mov    %rcx,0x3d(%rax,%rbx,1)
movups 0x3e1c(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3e21(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3e25(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3e29(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3e1c(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3e21(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3e25(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3e29(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movl   $0x657261,0x3f(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3e12(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3e17(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3e1b(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3e1f(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movl   $0x796220,0x40(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3e09(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3e0e(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3e12(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3e16(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x646e61202c6f73,%rcx
mov    %rcx,0x3d(%rax,%rbx,1)
movups 0x3df5(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3dfa(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3dfe(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3e02(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3df5(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3dfa(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3dfe(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3e02(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movl   $0x676e69,0x40(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3dec(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3df1(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movw   $0x2e,0x20(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x656874206e6f20,%rcx
mov    %rcx,0x3e(%rax,%rbx,1)
movups 0x3dbd(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3dc2(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3dc6(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3dca(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3dbe(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3dc3(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3dc7(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3dcb(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movw   $0x65,0x40(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x6f74207463656a,%rcx
mov    %rcx,0x3f(%rax,%rbx,1)
movups 0x3da5(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3daa(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3dae(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3db2(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3da7(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3dac(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3db0(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3db0(%rip),%xmm0
movups %xmm0,0x2c(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x2e6e6965726568,%rcx
mov    %rcx,0x3f(%rax,%rbx,1)
movups 0x3d8f(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3d94(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3d98(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3d9c(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x6f742073656974,%rcx
mov    %rcx,0x3d(%rax,%rbx,1)
movups 0x3d82(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3d87(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3d8b(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3d8f(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x63694c2073696874,%rcx
4c 69 63
mov    %rcx,(%rax,%rbx,1)
mov    %r15,0x6(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x746e6574617020,%rcx
mov    %rcx,0x3e(%rax,%rbx,1)
movups 0x3d3c(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3d41(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3d45(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3d49(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x2c297365757373,%rcx
mov    %rcx,0x3d(%rax,%rbx,1)
movups 0x3d2e(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3d33(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3d37(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3d3b(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3d2e(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3d33(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3d37(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3d3b(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movl   $0x726f20,0x40(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x746f6e206f6420,%rcx
mov    %rcx,0x3f(%rax,%rbx,1)
movups 0x3d16(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3d1b(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3d1f(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3d23(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3d18(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3d1d(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3d21(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3d24(%rip),%xmm0
movups %xmm0,0x2f(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x73696874207265,%rcx
mov    %rcx,0x3f(%rax,%rbx,1)
movups 0x3d03(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3d08(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3d0c(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3d10(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x756f792065636e,%rcx
mov    %rcx,0x3f(%rax,%rbx,1)
movups 0x3cf6(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3cfb(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3cff(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3d03(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3cf8(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3cfd(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3d01(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3d05(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movb   $0x0,0x40(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x7962206d617267,%rcx
mov    %rcx,0x3f(%rax,%rbx,1)
movups 0x3ce0(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3ce5(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3ce9(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3ced(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x6e656874202c75,%rcx
mov    %rcx,0x3e(%rax,%rbx,1)
movups 0x3cd3(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3cd8(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3cdc(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3ce0(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3cd4(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3cd9(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3cdd(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3ce1(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movl   $0x6f7420,0x40(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3ccb(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3cd0(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3cd4(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movl   $0x2e6d61,0x2f(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x7265646e752065,%rcx
mov    %rcx,0x3e(%rax,%rbx,1)
movups 0x3ca0(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3ca5(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3ca9(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3cad(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x6f74206465646e,%rcx
mov    %rcx,0x3f(%rax,%rbx,1)
movups 0x3c92(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3c97(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3c9b(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3c9f(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3c94(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3c99(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3c9d(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3ca0(%rip),%xmm0
movups %xmm0,0x2f(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x74736d7563726963,%rcx
6d 73 74
mov    %rcx,(%rax,%rbx,1)
movabs $0x2e7365636e6174,%rcx
mov    %rcx,0x7(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3c5c(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3c61(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3c65(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3c69(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movl   $0x796e61,0x40(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x796e6120666f20,%rcx
mov    %rcx,0x3d(%rax,%rbx,1)
movups 0x3c44(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3c49(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3c4d(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3c51(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3c44(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3c49(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3c4d(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3c51(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movb   $0x0,0x40(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3c3b(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3c40(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3c44(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3c45(%rip),%xmm0
movups %xmm0,0x2d(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3c33(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3c38(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3c3c(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3c40(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3c2e(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3c33(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3c37(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3c3b(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movb   $0x0,0x40(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3c25(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3c2a(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3c2e(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3c32(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movw   $0x74,0x40(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x676e696c6c6977,%rcx
mov    %rcx,0x3f(%rax,%rbx,1)
movups 0x3c0c(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3c11(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3c15(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3c19(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x746f6e6e616320,%rcx
mov    %rcx,0x3e(%rax,%rbx,1)
movups 0x3bff(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3c04(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3c08(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3c0c(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3c00(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movl   $0x2e6563,0x10(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x6f742064657665,%rcx
mov    %rcx,0x3e(%rax,%rbx,1)
movups 0x3bce(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3bd3(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3bd7(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3bdb(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3bcf(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3bd4(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3bd6(%rip),%xmm0
movups %xmm0,0x1e(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3bb6(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3bbb(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3bbf(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3bc3(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movl   $0x6e6920,0x40(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x656874202c7365,%rcx
mov    %rcx,0x3e(%rax,%rbx,1)
movups 0x3b9e(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3ba3(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3ba7(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3bab(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3b9f(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3ba4(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3ba8(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3bac(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movl   $0x65736e,0x40(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3b96(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3b9b(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3b9f(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3ba3(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movl   $0x676e69,0x3f(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3b8c(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3b91(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3b95(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3b99(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movl   $0x676e6f,0x40(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x73657461726f70,%rcx
mov    %rcx,0x3e(%rax,%rbx,1)
movups 0x3b74(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3b79(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3b7d(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3b81(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3b75(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3b7a(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3b7e(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3b7c(%rip),%xmm0
movups %xmm0,0x2a(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3b5c(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3b61(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3b65(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3b69(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movups 0x3b67(%rip),%xmm0
movups %xmm0,0x3a(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3b55(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3b5a(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3b5e(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3b62(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movups 0x3b5f(%rip),%xmm0
movups %xmm0,0x39(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3b4d(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3b52(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3b56(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3b5a(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movups 0x3b57(%rip),%xmm0
movups %xmm0,0x39(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3b45(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3b4a(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movw   $0x2e,0x20(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
mov    %r14,0x3f(%rax,%rbx,1)
movups 0x3b20(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3b25(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3b29(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3b2d(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x796e6120646e61,%rcx
mov    %rcx,0x3f(%rax,%rbx,1)
movups 0x3b13(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3b18(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3b1c(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3b20(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3b15(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3b1a(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3b1e(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3b22(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movups 0x3b1f(%rip),%xmm0
movups %xmm0,0x39(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x65657246206568,%r14
mov    %r14,0x3d(%rax,%rbx,1)
movups 0x3afe(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3b03(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3b07(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3b0b(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3afe(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3b03(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3b07(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3b0b(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movups 0x3b09(%rip),%xmm0
movups %xmm0,0x3a(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3af7(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3afc(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3b00(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3b04(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movups 0x3b05(%rip),%xmm0
movups %xmm0,0x3d(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x697461646e756f46,%rcx
61 74 69
mov    %rcx,(%rax,%rbx,1)
movl   $0x2e6e6f,0x8(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x65657266207265,%rcx
mov    %rcx,0x3e(%rax,%rbx,1)
movups 0x3ab6(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3abb(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3abf(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3ac3(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3ab7(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3abc(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3ac0(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3ac4(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movups 0x3ac2(%rip),%xmm0
movups %xmm0,0x3a(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
mov    %r14,0x3e(%rax,%rbx,1)
movups 0x3aab(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3ab0(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3ab4(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3ab8(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3aac(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3ab1(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3ab5(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3ab9(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movups 0x3ab6(%rip),%xmm0
movups %xmm0,0x39(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x736c616f67206f,%rcx
mov    %rcx,0x40(%rax,%rbx,1)
movups 0x3a95(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3a9a(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3a9e(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3aa2(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3a98(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3a9d(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3aa1(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3aa5(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movups 0x3aa3(%rip),%xmm0
movups %xmm0,0x3a(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3a91(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3a96(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x3a9a(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x3a98(%rip),%xmm0
movups %xmm0,0x2a(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x3a78(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x3a7d(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movl   $0x534e4f,0x1f(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0xa58(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0xa5d(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0xa61(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movw   $0x2d,0x30(%rax,%rbx,1)
jmp    4d54 <Copyright+0x3c34>
lea    0x5923(%rip),%rbx
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x59544e41525241,%r15
mov    %r15,0x30(%rax,%rbx,1)
movups 0x9cd(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x9d2(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x9d6(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x2d2d2d2d2d2d2d,%r14
mov    %r14,0x30(%rax,%rbx,1)
movups 0x9bd(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x9c2(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x9c6(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
mov    %r15,0x40(%rax,%rbx,1)
movups 0x9b7(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x9bc(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x9c0(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x9c4(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x9ba(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x9bf(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x9c3(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x9c7(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movups 0x9c7(%rip),%xmm0
movups %xmm0,0x3c(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x9b5(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x9ba(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x9be(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x9c2(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movups 0x9c0(%rip),%xmm0
movups %xmm0,0x3a(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x9ae(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x9b3(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x9b7(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x9bb(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movups 0x9bd(%rip),%xmm0
movups %xmm0,0x3e(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x464f2053454954,%rcx
mov    %rcx,0x40(%rax,%rbx,1)
movups 0x99c(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x9a1(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x9a5(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x9a9(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x99f(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x9a4(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x9a8(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x9ac(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movups 0x9ad(%rip),%xmm0
movups %xmm0,0x3d(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x99b(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x9a0(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x9a4(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x9a8(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movups 0x9a7(%rip),%xmm0
movups %xmm0,0x3b(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x995(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x99a(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x99e(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x9a2(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movups 0x9a2(%rip),%xmm0
movups %xmm0,0x3c(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x990(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x98e(%rip),%xmm0
movups %xmm0,0x9(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x96e(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x973(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x977(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x97b(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movups 0x978(%rip),%xmm0
movups %xmm0,0x39(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movabs $0x524f2f444e4120,%rcx
mov    %rcx,0x3f(%rax,%rbx,1)
movups 0x957(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x95c(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x960(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x964(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x959(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x95e(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x962(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x966(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movups 0x968(%rip),%xmm0
movups %xmm0,0x3e(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x956(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x95b(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x95f(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x963(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movups 0x966(%rip),%xmm0
movups %xmm0,0x3f(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x954(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x959(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x95d(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x961(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movups 0x962(%rip),%xmm0
movups %xmm0,0x3d(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x950(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x955(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x959(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x95d(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movups 0x95d(%rip),%xmm0
movups %xmm0,0x3c(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x94b(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x950(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x954(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x958(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movups 0x95a(%rip),%xmm0
movups %xmm0,0x3e(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x948(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x94d(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x951(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
movups 0x955(%rip),%xmm0
movups %xmm0,0x30(%rax,%rbx,1)
movups 0x952(%rip),%xmm0
movups %xmm0,0x39(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movups 0x940(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x945(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
mov    %rbx,%rdi
call   1040 <strlen@plt>
mov    %r14,0x30(%rax,%rbx,1)
movups 0x408(%rip),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups 0x40d(%rip),%xmm0
movups %xmm0,0x10(%rax,%rbx,1)
movups 0x411(%rip),%xmm0
movups %xmm0,0x20(%rax,%rbx,1)
lea    0x52e5(%rip),%rbx
mov    %rbx,%rdi
call   1040 <strlen@plt>
movw   $0xa,(%rax,%rbx,1)
lea    0x52d0(%rip),%rdi
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
jmp    1030 <puts@plt>

LLVM IR (-O0):
@Copyright.information = internal global [20000 x i8] zeroinitializer
@.str = [50 x i8] c"Movie version 2.0, Copyright (C) 1995 Liam Hudson\00"
@.str.1 = [2 x i8] c"\0A\00"
@.str.2 = [83 x i8] c"Movie v2.0 comes with ABSOLUTELY NO WARRANTY; type WARRANTY at prompt for details.\00"
@.str.3 = [62 x i8] c"This is free software, and you are welcome to redistribute it\00"
@.str.4 = [69 x i8] c"under certain conditions; type LICENSE at command prompt for details\00"
@.str.5 = [56 x i8] c" THIS PROGRAM COMES WITH NO WARRANTY\00"
@.str.6 = [56 x i8] c" -----------------------------------\00"
@.str.7 = [72 x i8] c"1. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY\00"
@.str.8 = [76 x i8] c" FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN\00"
@.str.9 = [74 x i8] c" OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES\00"
@.str.10 = [78 x i8] c" PROVIDE THE PROGRAM `AS IS' WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED\00"
@.str.11 = [72 x i8] c" OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF\00"
@.str.12 = [77 x i8] c" MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS\00"
@.str.13 = [75 x i8] c" TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU@. SHOULD THE\00"
@.str.14 = [76 x i8] c" PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,\00"
@.str.15 = [25 x i8] c" REPAIR OR CORRECTION.\00"
@.str.16 = [1 x i8] zeroinitializer
@.str.17 = [73 x i8] c"2. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING\00"
@.str.18 = [71 x i8] c" WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR\00"
@.str.19 = [78 x i8] c" REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,\00"
@.str.20 = [79 x i8] c" INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING\00"
@.str.21 = [77 x i8] c" OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED\00"
@.str.22 = [76 x i8] c" TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY\00"
@.str.23 = [78 x i8] c" YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER\00"
@.str.24 = [73 x i8] c" PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE\00"
@.str.25 = [32 x i8] c" POSSIBILITY OF SUCH DAMAGES.\00"
@.str.26 = [36 x i8] c"\09 GNU GENERAL PUBLIC LICENSE\00"
@.str.27 = [67 x i8] c" TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION\00"
@.str.28 = [70 x i8] c" 0. This License applies to any program or other work which contains\00"
@.str.29 = [69 x i8] c"a notice placed by the copyright holder saying it may be distributed\00"
@.str.30 = [71 x i8] c"under the terms of this General Public License. The 'Program', below,\00"
@.str.31 = [68 x i8] c"refers to any such program or work, and a work based on the Program\00"
@.str.32 = [69 x i8] c"means either the Program or any derivative work under copyright law:\00"
@.str.33 = [66 x i8] c"that is to say, a work containing the Program or a portion of it,\00"
@.str.34 = [69 x i8] c"either verbatim or with modifications and/or translated into another\00"
@.str.35 = [71 x i8] c"language. (Hereinafter, translation is included without limitation in\00"
@.str.36 = [60 x i8] c"the term modification.) Each licensee is addressed as you.\00"
@.str.37 = [69 x i8] c"Activities other than copying, distribution and modification are not\00"
@.str.38 = [65 x i8] c"covered by this License; they are outside its scope. The act of\00"
@.str.39 = [71 x i8] c"running the Program is not restricted, and the output from the Program\00"
@.str.40 = [63 x i8] c"is covered only if its contents constitute a work based on the\00"
@.str.41 = [66 x i8] c"Program (independent of having been made by running the Program).\00"
@.str.42 = [55 x i8] c"Whether that is true depends on what the Program does.\00"
@.str.43 = [66 x i8] c" 1. You may copy and distribute verbatim copies of the Program's\00"
@.str.44 = [64 x i8] c"source code as you receive it, in any medium, provided that you\00"
@.str.45 = [68 x i8] c"conspicuously and appropriately publish on each copy an appropriate\00"
@.str.46 = [65 x i8] c"copyright notice and disclaimer of warranty; keep intact all the\00"
@.str.47 = [71 x i8] c"notices that refer to this License and to the absence of any warranty;\00"
@.str.48 = [68 x i8] c"and give any other recipients of the Program a copy of this License\00"
@.str.49 = [24 x i8] c"along with the Program.\00"
@.str.50 = [70 x i8] c"You may charge a fee for the physical act of transferring a copy, and\00"
@.str.51 = [72 x i8] c"you may at your option offer warranty protection in exchange for a fee.\00"
@.str.52 = [70 x i8] c" 2. You may modify your copy or copies of the Program or any portion\00"
@.str.53 = [62 x i8] c"of it, thus forming a work based on the Program, and copy and\00"
@.str.54 = [67 x i8] c"distribute such modifications or work under the terms of Section 1\00"
@.str.55 = [60 x i8] c"above, provided that you also meet all of these conditions:\00"
@.str.56 = [68 x i8] c" a) You must cause the modified files to carry prominent notices\00"
@.str.57 = [67 x i8] c" stating that you changed the files and the date of any change.\00"
@.str.58 = [71 x i8] c" b) You must cause any work that you distribute or publish, that in\00"
@.str.59 = [68 x i8] c" whole or in part contains or is derived from the Program or any\00"
@.str.60 = [70 x i8] c" part thereof, to be licensed as a whole at no charge to all third\00"
@.str.61 = [45 x i8] c" parties under the terms of this License.\00"
@.str.62 = [69 x i8] c" c) If the modified program normally reads commands interactively\00"
@.str.63 = [63 x i8] c" when run, you must cause it, when started running for such\00"
@.str.64 = [69 x i8] c" interactive use in the most ordinary way, to print or display an\00"
@.str.65 = [65 x i8] c" announcement including an appropriate copyright notice and a\00"
@.str.66 = [71 x i8] c" notice that there is no warranty (or else, saying that you provide\00"
@.str.67 = [66 x i8] c" a warranty) and that users may redistribute the program under\00"
@.str.68 = [70 x i8] c" these conditions, and telling the user how to view a copy of this\00"
@.str.69 = [67 x i8] c" License. (Exception: if the Program itself is interactive but\00"
@.str.70 = [69 x i8] c" does not normally print such an announcement, your work based on\00"
@.str.71 = [59 x i8] c" the Program is not required to print an announcement.)\00"
@.str.72 = [62 x i8] c"These requirements apply to the modified work as a whole. If\00"
@.str.73 = [69 x i8] c"identifiable sections of that work are not derived from the Program,\00"
@.str.74 = [67 x i8] c"and can be reasonably considered independent and separate works in\00"
@.str.75 = [68 x i8] c"themselves, then this License, and its terms, do not apply to those\00"
@.str.76 = [67 x i8] c"sections when you distribute them as separate works. But when you\00"
@.str.77 = [70 x i8] c"distribute the same sections as part of a whole which is a work based\00"
@.str.78 = [70 x i8] c"on the Program, the distribution of the whole must be on the terms of\00"
@.str.79 = [66 x i8] c"this License, whose permissions for other licensees extend to the\00"
@.str.80 = [74 x i8] c"entire whole, and thus to each and every part regardless of who wrote it.\00"
@.str.81 = [70 x i8] c"Thus, it is not the intent of this section to claim rights or contest\00"
@.str.82 = [70 x i8] c"your rights to work written entirely by you; rather, the intent is to\00"
@.str.83 = [64 x i8] c"exercise the right to control the distribution of derivative or\00"
@.str.84 = [39 x i8] c"collective works based on the Program.\00"
@.str.85 = [71 x i8] c"In addition, mere aggregation of another work not based on the Program\00"
@.str.86 = [70 x i8] c"with the Program (or with a work based on the Program) on a volume of\00"
@.str.87 = [69 x i8] c"a storage or distribution medium does not bring the other work under\00"
@.str.88 = [27 x i8] c"the scope of this License.\00"
@.str.89 = [69 x i8] c" 3. You may copy and distribute the Program (or a work based on it,\00"
@.str.90 = [70 x i8] c"under Section 2) in object code or executable form under the terms of\00"
@.str.91 = [71 x i8] c"Sections 1 and 2 above provided that you also do one of the following:\00"
@.str.92 = [69 x i8] c" a) Accompany it with the complete corresponding machine-readable\00"
@.str.93 = [71 x i8] c" source code, which must be distributed under the terms of Sections\00"
@.str.94 = [77 x i8] c" 1 and 2 above on a medium customarily used for software interchange; or,\00"
@.str.95 = [67 x i8] c" b) Accompany it with a written offer, valid for at least three\00"
@.str.96 = [67 x i8] c" years, to give any third party, for a charge no more than your\00"
@.str.97 = [66 x i8] c" cost of physically performing source distribution, a complete\00"
@.str.98 = [66 x i8] c" machine-readable copy of the corresponding source code, to be\00"
@.str.99 = [70 x i8] c" distributed under the terms of Sections 1 and 2 above on a medium\00"
@.str.100 = [51 x i8] c" customarily used for software interchange; or,\00"
@.str.101 = [70 x i8] c" c) Accompany it with the information you received as to the offer\00"
@.str.102 = [67 x i8] c" to distribute corresponding source code. (This alternative is\00"
@.str.103 = [64 x i8] c" allowed only for noncommercial distribution and only if you\00"
@.str.104 = [69 x i8] c" received the program in object code or executable form with such\00"
@.str.105 = [50 x i8] c" an offer, in accord with Subsection b above.)\00"
@.str.106 = [68 x i8] c"The source code for a work means the preferred form of the work for\00"
@.str.107 = [69 x i8] c"making modifications to it. For an executable work, complete source\00"
@.str.108 = [69 x i8] c"code means all the source code for all modules it contains, plus any\00"
@.str.109 = [64 x i8] c"associated interface definition files, plus the scripts used to\00"
@.str.110 = [71 x i8] c"control compilation and installation of the executable. However, as a\00"
@.str.111 = [64 x i8] c"special exception, the source code distributed need not include\00"
@.str.112 = [66 x i8] c"anything that is normally distributed (in either source or binary\00"
@.str.113 = [69 x i8] c"form) with the major components (compiler, kernel, and so on) of the\00"
@.str.114 = [69 x i8] c"operating system on which the executable runs, unless that component\00"
@.str.115 = [35 x i8] c"itself accompanies the executable.\00"
@.str.116 = [65 x i8] c"If distribution of executable or object code is made by offering\00"
@.str.117 = [65 x i8] c"access to copy from a designated place, then offering equivalent\00"
@.str.118 = [61 x i8] c"access to copy the source code from the same place counts as\00"
@.str.119 = [67 x i8] c"distribution of the source code, even though third parties are not\00"
@.str.120 = [57 x i8] c"compelled to copy the source along with the object code.\00"
@.str.121 = [69 x i8] c" 4. You may not copy, modify, sublicense, or distribute the Program\00"
@.str.122 = [62 x i8] c"except as expressly provided under this License. Any attempt\00"
@.str.123 = [67 x i8] c"otherwise to copy, modify, sublicense or distribute the Program is\00"
@.str.124 = [71 x i8] c"void, and will automatically terminate your rights under this License.\00"
@.str.125 = [69 x i8] c"However, parties who have received copies, or rights, from you under\00"
@.str.126 = [69 x i8] c"this License will not have their licenses terminated so long as such\00"
@.str.127 = [35 x i8] c"parties remain in full compliance.\00"
@.str.128 = [69 x i8] c" 5. You are not required to accept this License, since you have not\00"
@.str.129 = [69 x i8] c"signed it. However, nothing else grants you permission to modify or\00"
@.str.130 = [67 x i8] c"distribute the Program or its derivative works. These actions are\00"
@.str.131 = [68 x i8] c"prohibited by law if you do not accept this License. Therefore, by\00"
@.str.132 = [64 x i8] c"modifying or distributing the Program (or any work based on the\00"
@.str.133 = [69 x i8] c"Program), you indicate your acceptance of this License to do so, and\00"
@.str.134 = [68 x i8] c"all its terms and conditions for copying, distributing or modifying\00"
@.str.135 = [34 x i8] c"the Program or works based on it.\00"
@.str.136 = [70 x i8] c" 6. Each time you redistribute the Program (or any work based on the\00"
@.str.137 = [66 x i8] c"Program), the recipient automatically receives a license from the\00"
@.str.138 = [71 x i8] c"original licensor to copy, distribute or modify the Program subject to\00"
@.str.139 = [60 x i8] c"these terms and conditions. You may not impose any further\00"
@.str.140 = [71 x i8] c"restrictions on the recipients' exercise of the rights granted herein.\00"
@.str.141 = [69 x i8] c"You are not responsible for enforcing compliance by third parties to\00"
@.str.142 = [14 x i8] c"this License.\00"
@.str.143 = [70 x i8] c" 7. If, as a consequence of a court judgment or allegation of patent\00"
@.str.144 = [69 x i8] c"infringement or for any other reason (not limited to patent issues),\00"
@.str.145 = [68 x i8] c"conditions are imposed on you (whether by court order, agreement or\00"
@.str.146 = [71 x i8] c"otherwise) that contradict the conditions of this License, they do not\00"
@.str.147 = [63 x i8] c"excuse you from the conditions of this License. If you cannot\00"
@.str.148 = [71 x i8] c"distribute so as to satisfy simultaneously your obligations under this\00"
@.str.149 = [71 x i8] c"License and any other pertinent obligations, then as a consequence you\00"
@.str.150 = [65 x i8] c"may not distribute the Program at all. For example, if a patent\00"
@.str.151 = [71 x i8] c"license would not permit royalty-free redistribution of the Program by\00"
@.str.152 = [70 x i8] c"all those who receive copies directly or indirectly through you, then\00"
@.str.153 = [68 x i8] c"the only way you could satisfy both it and this License would be to\00"
@.str.154 = [51 x i8] c"refrain entirely from distribution of the Program.\00"
@.str.155 = [70 x i8] c"If any portion of this section is held invalid or unenforceable under\00"
@.str.156 = [71 x i8] c"any particular circumstance, the balance of the section is intended to\00"
@.str.157 = [63 x i8] c"apply and the section as a whole is intended to apply in other\00"
@.str.158 = [15 x i8] c"circumstances.\00"
@.str.159 = [68 x i8] c"It is not the purpose of this section to induce you to infringe any\00"
@.str.160 = [69 x i8] c"patents or other property right claims or to contest validity of any\00"
@.str.161 = [65 x i8] c"such claims; this section has the sole purpose of protecting the\00"
@.str.162 = [61 x i8] c"integrity of the free software distribution system, which is\00"
@.str.163 = [64 x i8] c"implemented by public license practices. Many people have made\00"
@.str.164 = [65 x i8] c"generous contributions to the wide range of software distributed\00"
@.str.165 = [66 x i8] c"through that system in reliance on consistent application of that\00"
@.str.166 = [71 x i8] c"system; it is up to the author/donor to decide if he or she is willing\00"
@.str.167 = [70 x i8] c"to distribute software through any other system and a licensee cannot\00"
@.str.168 = [20 x i8] c"impose that choice.\00"
@.str.169 = [70 x i8] c"This section is intended to make thoroughly clear what is believed to\00"
@.str.170 = [46 x i8] c"be a consequence of the rest of this License.\00"
@.str.171 = [68 x i8] c" 8. If the distribution and/or use of the Program is restricted in\00"
@.str.172 = [70 x i8] c"certain countries either by patents or by copyrighted interfaces, the\00"
@.str.173 = [68 x i8] c"original copyright holder who places the Program under this License\00"
@.str.174 = [67 x i8] c"may add an explicit geographical distribution limitation excluding\00"
@.str.175 = [68 x i8] c"those countries, so that distribution is permitted only in or among\00"
@.str.176 = [70 x i8] c"countries not thus excluded. In such case, this License incorporates\00"
@.str.177 = [58 x i8] c"the limitation as if written in the body of this License.\00"
@.str.178 = [74 x i8] c" 9. The Free Software Foundation may publish revised and/or new versions\00"
@.str.179 = [73 x i8] c"of the General Public License from time to time. Such new versions will\00"
@.str.180 = [73 x i8] c"be similar in spirit to the present version, but may differ in detail to\00"
@.str.181 = [34 x i8] c"address new problems or concerns.\00"
@.str.182 = [71 x i8] c"Each version is given a distinguishing version number. If the Program\00"
@.str.183 = [71 x i8] c"specifies a version number of this License which applies to it and any\00"
@.str.184 = [73 x i8] c"later version, you have the option of following the terms and conditions\00"
@.str.185 = [69 x i8] c"either of that version or of any later version published by the Free\00"
@.str.186 = [74 x i8] c"Software Foundation. If the Program does not specify a version number of\00"
@.str.187 = [77 x i8] c"this License, you may choose any version ever published by the Free Software\00"
@.str.188 = [12 x i8] c"Foundation.\00"
@.str.189 = [70 x i8] c" 10. If you wish to incorporate parts of the Program into other free\00"
@.str.190 = [74 x i8] c"programs whose distribution conditions are different, write to the author\00"
@.str.191 = [70 x i8] c"to ask for permission. For software which is copyrighted by the Free\00"
@.str.192 = [73 x i8] c"Software Foundation, write to the Free Software Foundation; we sometimes\00"
@.str.193 = [72 x i8] c"make exceptions for this. Our decision will be guided by the two goals\00"
@.str.194 = [74 x i8] c"of preserving the free status of all derivatives of our free software and\00"
@.str.195 = [58 x i8] c"of promoting the sharing and reuse of software generally.\00"
@.str.196 = [35 x i8] c"\09\09 END OF TERMS AND CONDITIONS\00"
@.str.197 = [50 x i8] c" -----------------------------------\00"
@.str.198 = [4 x i8] c"%s\0A\00"
define void @Copyright(i32 %0) {
%2 = alloca i32
store i32 %0, i32* %2
store i8 0, i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0)
%3 = load i32, i32* %2
%4 = icmp eq i32 %3, 1
br i1 %4, label %5, label %14
5: ; preds = %1
%6 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str, i64 0, i64 0))
%7 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%8 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([83 x i8], [83 x i8]* @.str.2, i64 0, i64 0))
%9 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%10 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.3, i64 0, i64 0))
%11 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%12 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.4, i64 0, i64 0))
%13 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
br label %14
14: ; preds = %5, %1
%15 = load i32, i32* %2
%16 = icmp eq i32 %15, 2
br i1 %16, label %17, label %62
17: ; preds = %14
%18 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([56 x i8], [56 x i8]* @.str.5, i64 0, i64 0))
%19 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%20 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([56 x i8], [56 x i8]* @.str.6, i64 0, i64 0))
%21 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%22 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([72 x i8], [72 x i8]* @.str.7, i64 0, i64 0))
%23 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%24 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([76 x i8], [76 x i8]* @.str.8, i64 0, i64 0))
%25 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%26 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([74 x i8], [74 x i8]* @.str.9, i64 0, i64 0))
%27 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%28 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([78 x i8], [78 x i8]* @.str.10, i64 0, i64 0))
%29 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%30 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([72 x i8], [72 x i8]* @.str.11, i64 0, i64 0))
%31 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%32 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.12, i64 0, i64 0))
%33 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%34 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([75 x i8], [75 x i8]* @.str.13, i64 0, i64 0))
%35 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%36 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([76 x i8], [76 x i8]* @.str.14, i64 0, i64 0))
%37 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%38 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.15, i64 0, i64 0))
%39 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%40 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.16, i64 0, i64 0))
%41 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%42 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([73 x i8], [73 x i8]* @.str.17, i64 0, i64 0))
%43 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%44 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str.18, i64 0, i64 0))
%45 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%46 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([78 x i8], [78 x i8]* @.str.19, i64 0, i64 0))
%47 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%48 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([79 x i8], [79 x i8]* @.str.20, i64 0, i64 0))
%49 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%50 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.21, i64 0, i64 0))
%51 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%52 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([76 x i8], [76 x i8]* @.str.22, i64 0, i64 0))
%53 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%54 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([78 x i8], [78 x i8]* @.str.23, i64 0, i64 0))
%55 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%56 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([73 x i8], [73 x i8]* @.str.24, i64 0, i64 0))
%57 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%58 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.25, i64 0, i64 0))
%59 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%60 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([56 x i8], [56 x i8]* @.str.6, i64 0, i64 0))
%61 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
br label %62
62: ; preds = %17, %14
%63 = load i32, i32* %2
%64 = icmp eq i32 %63, 3
br i1 %64, label %65, label %468
65: ; preds = %62
%66 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.26, i64 0, i64 0))
%67 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%68 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([67 x i8], [67 x i8]* @.str.27, i64 0, i64 0))
%69 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%70 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.16, i64 0, i64 0))
%71 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%72 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([70 x i8], [70 x i8]* @.str.28, i64 0, i64 0))
%73 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%74 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.29, i64 0, i64 0))
%75 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%76 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str.30, i64 0, i64 0))
%77 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%78 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([68 x i8], [68 x i8]* @.str.31, i64 0, i64 0))
%79 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%80 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.32, i64 0, i64 0))
%81 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%82 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([66 x i8], [66 x i8]* @.str.33, i64 0, i64 0))
%83 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%84 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.34, i64 0, i64 0))
%85 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%86 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str.35, i64 0, i64 0))
%87 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%88 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([60 x i8], [60 x i8]* @.str.36, i64 0, i64 0))
%89 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%90 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.16, i64 0, i64 0))
%91 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%92 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.37, i64 0, i64 0))
%93 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%94 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.38, i64 0, i64 0))
%95 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%96 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str.39, i64 0, i64 0))
%97 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%98 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([63 x i8], [63 x i8]* @.str.40, i64 0, i64 0))
%99 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%100 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([66 x i8], [66 x i8]* @.str.41, i64 0, i64 0))
%101 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%102 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([55 x i8], [55 x i8]* @.str.42, i64 0, i64 0))
%103 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%104 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.16, i64 0, i64 0))
%105 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%106 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([66 x i8], [66 x i8]* @.str.43, i64 0, i64 0))
%107 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%108 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.44, i64 0, i64 0))
%109 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%110 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([68 x i8], [68 x i8]* @.str.45, i64 0, i64 0))
%111 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%112 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.46, i64 0, i64 0))
%113 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%114 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str.47, i64 0, i64 0))
%115 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%116 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([68 x i8], [68 x i8]* @.str.48, i64 0, i64 0))
%117 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%118 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.49, i64 0, i64 0))
%119 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%120 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.16, i64 0, i64 0))
%121 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%122 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([70 x i8], [70 x i8]* @.str.50, i64 0, i64 0))
%123 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%124 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([72 x i8], [72 x i8]* @.str.51, i64 0, i64 0))
%125 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%126 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.16, i64 0, i64 0))
%127 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%128 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([70 x i8], [70 x i8]* @.str.52, i64 0, i64 0))
%129 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%130 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.53, i64 0, i64 0))
%131 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%132 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([67 x i8], [67 x i8]* @.str.54, i64 0, i64 0))
%133 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%134 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([60 x i8], [60 x i8]* @.str.55, i64 0, i64 0))
%135 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%136 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.16, i64 0, i64 0))
%137 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%138 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([68 x i8], [68 x i8]* @.str.56, i64 0, i64 0))
%139 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%140 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([67 x i8], [67 x i8]* @.str.57, i64 0, i64 0))
%141 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%142 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.16, i64 0, i64 0))
%143 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%144 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str.58, i64 0, i64 0))
%145 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%146 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([68 x i8], [68 x i8]* @.str.59, i64 0, i64 0))
%147 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%148 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([70 x i8], [70 x i8]* @.str.60, i64 0, i64 0))
%149 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%150 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.61, i64 0, i64 0))
%151 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%152 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.16, i64 0, i64 0))
%153 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%154 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.62, i64 0, i64 0))
%155 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%156 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([63 x i8], [63 x i8]* @.str.63, i64 0, i64 0))
%157 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%158 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.64, i64 0, i64 0))
%159 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%160 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.65, i64 0, i64 0))
%161 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%162 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str.66, i64 0, i64 0))
%163 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%164 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([66 x i8], [66 x i8]* @.str.67, i64 0, i64 0))
%165 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%166 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([70 x i8], [70 x i8]* @.str.68, i64 0, i64 0))
%167 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%168 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([67 x i8], [67 x i8]* @.str.69, i64 0, i64 0))
%169 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%170 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.70, i64 0, i64 0))
%171 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%172 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([59 x i8], [59 x i8]* @.str.71, i64 0, i64 0))
%173 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%174 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.16, i64 0, i64 0))
%175 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%176 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.72, i64 0, i64 0))
%177 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%178 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.73, i64 0, i64 0))
%179 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%180 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([67 x i8], [67 x i8]* @.str.74, i64 0, i64 0))
%181 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%182 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([68 x i8], [68 x i8]* @.str.75, i64 0, i64 0))
%183 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%184 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([67 x i8], [67 x i8]* @.str.76, i64 0, i64 0))
%185 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%186 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([70 x i8], [70 x i8]* @.str.77, i64 0, i64 0))
%187 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%188 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([70 x i8], [70 x i8]* @.str.78, i64 0, i64 0))
%189 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%190 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([66 x i8], [66 x i8]* @.str.79, i64 0, i64 0))
%191 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%192 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([74 x i8], [74 x i8]* @.str.80, i64 0, i64 0))
%193 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%194 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.16, i64 0, i64 0))
%195 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%196 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([70 x i8], [70 x i8]* @.str.81, i64 0, i64 0))
%197 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%198 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([70 x i8], [70 x i8]* @.str.82, i64 0, i64 0))
%199 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%200 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.83, i64 0, i64 0))
%201 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%202 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.84, i64 0, i64 0))
%203 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%204 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.16, i64 0, i64 0))
%205 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%206 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str.85, i64 0, i64 0))
%207 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%208 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([70 x i8], [70 x i8]* @.str.86, i64 0, i64 0))
%209 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%210 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.87, i64 0, i64 0))
%211 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%212 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.88, i64 0, i64 0))
%213 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%214 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.16, i64 0, i64 0))
%215 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%216 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.89, i64 0, i64 0))
%217 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%218 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([70 x i8], [70 x i8]* @.str.90, i64 0, i64 0))
%219 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%220 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str.91, i64 0, i64 0))
%221 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%222 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.16, i64 0, i64 0))
%223 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%224 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.92, i64 0, i64 0))
%225 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%226 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str.93, i64 0, i64 0))
%227 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%228 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.94, i64 0, i64 0))
%229 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%230 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.16, i64 0, i64 0))
%231 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%232 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([67 x i8], [67 x i8]* @.str.95, i64 0, i64 0))
%233 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%234 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([67 x i8], [67 x i8]* @.str.96, i64 0, i64 0))
%235 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%236 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([66 x i8], [66 x i8]* @.str.97, i64 0, i64 0))
%237 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%238 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([66 x i8], [66 x i8]* @.str.98, i64 0, i64 0))
%239 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%240 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([70 x i8], [70 x i8]* @.str.99, i64 0, i64 0))
%241 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%242 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str.100, i64 0, i64 0))
%243 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%244 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.16, i64 0, i64 0))
%245 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%246 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([70 x i8], [70 x i8]* @.str.101, i64 0, i64 0))
%247 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%248 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([67 x i8], [67 x i8]* @.str.102, i64 0, i64 0))
%249 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%250 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.103, i64 0, i64 0))
%251 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%252 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.104, i64 0, i64 0))
%253 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%254 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.105, i64 0, i64 0))
%255 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%256 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.16, i64 0, i64 0))
%257 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%258 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([68 x i8], [68 x i8]* @.str.106, i64 0, i64 0))
%259 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%260 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.107, i64 0, i64 0))
%261 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%262 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.108, i64 0, i64 0))
%263 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%264 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.109, i64 0, i64 0))
%265 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%266 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str.110, i64 0, i64 0))
%267 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%268 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.111, i64 0, i64 0))
%269 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%270 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([66 x i8], [66 x i8]* @.str.112, i64 0, i64 0))
%271 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%272 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.113, i64 0, i64 0))
%273 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%274 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.114, i64 0, i64 0))
%275 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%276 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.115, i64 0, i64 0))
%277 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%278 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.16, i64 0, i64 0))
%279 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%280 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.116, i64 0, i64 0))
%281 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%282 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.117, i64 0, i64 0))
%283 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%284 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([61 x i8], [61 x i8]* @.str.118, i64 0, i64 0))
%285 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%286 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([67 x i8], [67 x i8]* @.str.119, i64 0, i64 0))
%287 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%288 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str.120, i64 0, i64 0))
%289 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%290 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.16, i64 0, i64 0))
%291 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%292 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.121, i64 0, i64 0))
%293 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%294 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.122, i64 0, i64 0))
%295 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%296 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([67 x i8], [67 x i8]* @.str.123, i64 0, i64 0))
%297 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%298 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str.124, i64 0, i64 0))
%299 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%300 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.125, i64 0, i64 0))
%301 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%302 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.126, i64 0, i64 0))
%303 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%304 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.127, i64 0, i64 0))
%305 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%306 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.16, i64 0, i64 0))
%307 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%308 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.128, i64 0, i64 0))
%309 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%310 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.129, i64 0, i64 0))
%311 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%312 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([67 x i8], [67 x i8]* @.str.130, i64 0, i64 0))
%313 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%314 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([68 x i8], [68 x i8]* @.str.131, i64 0, i64 0))
%315 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%316 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.132, i64 0, i64 0))
%317 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%318 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.133, i64 0, i64 0))
%319 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%320 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([68 x i8], [68 x i8]* @.str.134, i64 0, i64 0))
%321 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%322 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.135, i64 0, i64 0))
%323 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%324 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.16, i64 0, i64 0))
%325 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%326 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([70 x i8], [70 x i8]* @.str.136, i64 0, i64 0))
%327 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%328 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([66 x i8], [66 x i8]* @.str.137, i64 0, i64 0))
%329 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%330 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str.138, i64 0, i64 0))
%331 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%332 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([60 x i8], [60 x i8]* @.str.139, i64 0, i64 0))
%333 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%334 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str.140, i64 0, i64 0))
%335 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%336 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.141, i64 0, i64 0))
%337 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%338 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.142, i64 0, i64 0))
%339 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%340 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.16, i64 0, i64 0))
%341 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%342 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([70 x i8], [70 x i8]* @.str.143, i64 0, i64 0))
%343 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%344 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.144, i64 0, i64 0))
%345 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%346 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([68 x i8], [68 x i8]* @.str.145, i64 0, i64 0))
%347 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%348 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str.146, i64 0, i64 0))
%349 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%350 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([63 x i8], [63 x i8]* @.str.147, i64 0, i64 0))
%351 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%352 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str.148, i64 0, i64 0))
%353 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%354 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str.149, i64 0, i64 0))
%355 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%356 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.150, i64 0, i64 0))
%357 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%358 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str.151, i64 0, i64 0))
%359 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%360 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([70 x i8], [70 x i8]* @.str.152, i64 0, i64 0))
%361 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%362 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([68 x i8], [68 x i8]* @.str.153, i64 0, i64 0))
%363 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%364 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str.154, i64 0, i64 0))
%365 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%366 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.16, i64 0, i64 0))
%367 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%368 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([70 x i8], [70 x i8]* @.str.155, i64 0, i64 0))
%369 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%370 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str.156, i64 0, i64 0))
%371 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%372 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([63 x i8], [63 x i8]* @.str.157, i64 0, i64 0))
%373 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%374 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.158, i64 0, i64 0))
%375 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%376 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.16, i64 0, i64 0))
%377 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%378 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([68 x i8], [68 x i8]* @.str.159, i64 0, i64 0))
%379 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%380 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.160, i64 0, i64 0))
%381 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%382 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.161, i64 0, i64 0))
%383 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%384 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([61 x i8], [61 x i8]* @.str.162, i64 0, i64 0))
%385 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%386 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.163, i64 0, i64 0))
%387 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%388 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.164, i64 0, i64 0))
%389 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%390 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([66 x i8], [66 x i8]* @.str.165, i64 0, i64 0))
%391 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%392 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str.166, i64 0, i64 0))
%393 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%394 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([70 x i8], [70 x i8]* @.str.167, i64 0, i64 0))
%395 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%396 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.168, i64 0, i64 0))
%397 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%398 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.16, i64 0, i64 0))
%399 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%400 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([70 x i8], [70 x i8]* @.str.169, i64 0, i64 0))
%401 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%402 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.170, i64 0, i64 0))
%403 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%404 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.16, i64 0, i64 0))
%405 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%406 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([68 x i8], [68 x i8]* @.str.171, i64 0, i64 0))
%407 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%408 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([70 x i8], [70 x i8]* @.str.172, i64 0, i64 0))
%409 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%410 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([68 x i8], [68 x i8]* @.str.173, i64 0, i64 0))
%411 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%412 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([67 x i8], [67 x i8]* @.str.174, i64 0, i64 0))
%413 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%414 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([68 x i8], [68 x i8]* @.str.175, i64 0, i64 0))
%415 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%416 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([70 x i8], [70 x i8]* @.str.176, i64 0, i64 0))
%417 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%418 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([58 x i8], [58 x i8]* @.str.177, i64 0, i64 0))
%419 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%420 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.16, i64 0, i64 0))
%421 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%422 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([74 x i8], [74 x i8]* @.str.178, i64 0, i64 0))
%423 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%424 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([73 x i8], [73 x i8]* @.str.179, i64 0, i64 0))
%425 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%426 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([73 x i8], [73 x i8]* @.str.180, i64 0, i64 0))
%427 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%428 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.181, i64 0, i64 0))
%429 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%430 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.16, i64 0, i64 0))
%431 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%432 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str.182, i64 0, i64 0))
%433 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%434 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str.183, i64 0, i64 0))
%435 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%436 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([73 x i8], [73 x i8]* @.str.184, i64 0, i64 0))
%437 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%438 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.185, i64 0, i64 0))
%439 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%440 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([74 x i8], [74 x i8]* @.str.186, i64 0, i64 0))
%441 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%442 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.187, i64 0, i64 0))
%443 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%444 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.188, i64 0, i64 0))
%445 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%446 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.16, i64 0, i64 0))
%447 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%448 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([70 x i8], [70 x i8]* @.str.189, i64 0, i64 0))
%449 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%450 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([74 x i8], [74 x i8]* @.str.190, i64 0, i64 0))
%451 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%452 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([70 x i8], [70 x i8]* @.str.191, i64 0, i64 0))
%453 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%454 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([73 x i8], [73 x i8]* @.str.192, i64 0, i64 0))
%455 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%456 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([72 x i8], [72 x i8]* @.str.193, i64 0, i64 0))
%457 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%458 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([74 x i8], [74 x i8]* @.str.194, i64 0, i64 0))
%459 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%460 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([58 x i8], [58 x i8]* @.str.195, i64 0, i64 0))
%461 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%462 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.16, i64 0, i64 0))
%463 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%464 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.196, i64 0, i64 0))
%465 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%466 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.197, i64 0, i64 0))
%467 = call i8* @strcat(i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
br label %468
468: ; preds = %65, %62
%469 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.198, i64 0, i64 0), i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
ret void
}

LLVM IR (-O2):
@Copyright.information = internal global [20000 x i8] zeroinitializer
@.str = [50 x i8] c"Movie version 2.0, Copyright (C) 1995 Liam Hudson\00"
@.str.2 = [83 x i8] c"Movie v2.0 comes with ABSOLUTELY NO WARRANTY; type WARRANTY at prompt for details.\00"
@.str.3 = [62 x i8] c"This is free software, and you are welcome to redistribute it\00"
@.str.4 = [69 x i8] c"under certain conditions; type LICENSE at command prompt for details\00"
@.str.5 = [56 x i8] c" THIS PROGRAM COMES WITH NO WARRANTY\00"
@.str.6 = [56 x i8] c" -----------------------------------\00"
@.str.7 = [72 x i8] c"1. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY\00"
@.str.8 = [76 x i8] c" FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN\00"
@.str.9 = [74 x i8] c" OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES\00"
@.str.10 = [78 x i8] c" PROVIDE THE PROGRAM `AS IS' WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED\00"
@.str.11 = [72 x i8] c" OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF\00"
@.str.12 = [77 x i8] c" MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS\00"
@.str.13 = [75 x i8] c" TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU@. SHOULD THE\00"
@.str.14 = [76 x i8] c" PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,\00"
@.str.15 = [25 x i8] c" REPAIR OR CORRECTION.\00"
@.str.17 = [73 x i8] c"2. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING\00"
@.str.18 = [71 x i8] c" WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR\00"
@.str.19 = [78 x i8] c" REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,\00"
@.str.20 = [79 x i8] c" INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING\00"
@.str.21 = [77 x i8] c" OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED\00"
@.str.22 = [76 x i8] c" TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY\00"
@.str.23 = [78 x i8] c" YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER\00"
@.str.24 = [73 x i8] c" PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE\00"
@.str.25 = [32 x i8] c" POSSIBILITY OF SUCH DAMAGES.\00"
@.str.26 = [36 x i8] c"\09 GNU GENERAL PUBLIC LICENSE\00"
@.str.27 = [67 x i8] c" TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION\00"
@.str.28 = [70 x i8] c" 0. This License applies to any program or other work which contains\00"
@.str.29 = [69 x i8] c"a notice placed by the copyright holder saying it may be distributed\00"
@.str.30 = [71 x i8] c"under the terms of this General Public License. The 'Program', below,\00"
@.str.31 = [68 x i8] c"refers to any such program or work, and a work based on the Program\00"
@.str.32 = [69 x i8] c"means either the Program or any derivative work under copyright law:\00"
@.str.33 = [66 x i8] c"that is to say, a work containing the Program or a portion of it,\00"
@.str.34 = [69 x i8] c"either verbatim or with modifications and/or translated into another\00"
@.str.35 = [71 x i8] c"language. (Hereinafter, translation is included without limitation in\00"
@.str.36 = [60 x i8] c"the term modification.) Each licensee is addressed as you.\00"
@.str.37 = [69 x i8] c"Activities other than copying, distribution and modification are not\00"
@.str.38 = [65 x i8] c"covered by this License; they are outside its scope. The act of\00"
@.str.39 = [71 x i8] c"running the Program is not restricted, and the output from the Program\00"
@.str.40 = [63 x i8] c"is covered only if its contents constitute a work based on the\00"
@.str.41 = [66 x i8] c"Program (independent of having been made by running the Program).\00"
@.str.42 = [55 x i8] c"Whether that is true depends on what the Program does.\00"
@.str.43 = [66 x i8] c" 1. You may copy and distribute verbatim copies of the Program's\00"
@.str.44 = [64 x i8] c"source code as you receive it, in any medium, provided that you\00"
@.str.45 = [68 x i8] c"conspicuously and appropriately publish on each copy an appropriate\00"
@.str.46 = [65 x i8] c"copyright notice and disclaimer of warranty; keep intact all the\00"
@.str.47 = [71 x i8] c"notices that refer to this License and to the absence of any warranty;\00"
@.str.48 = [68 x i8] c"and give any other recipients of the Program a copy of this License\00"
@.str.49 = [24 x i8] c"along with the Program.\00"
@.str.50 = [70 x i8] c"You may charge a fee for the physical act of transferring a copy, and\00"
@.str.51 = [72 x i8] c"you may at your option offer warranty protection in exchange for a fee.\00"
@.str.52 = [70 x i8] c" 2. You may modify your copy or copies of the Program or any portion\00"
@.str.53 = [62 x i8] c"of it, thus forming a work based on the Program, and copy and\00"
@.str.54 = [67 x i8] c"distribute such modifications or work under the terms of Section 1\00"
@.str.55 = [60 x i8] c"above, provided that you also meet all of these conditions:\00"
@.str.56 = [68 x i8] c" a) You must cause the modified files to carry prominent notices\00"
@.str.57 = [67 x i8] c" stating that you changed the files and the date of any change.\00"
@.str.58 = [71 x i8] c" b) You must cause any work that you distribute or publish, that in\00"
@.str.59 = [68 x i8] c" whole or in part contains or is derived from the Program or any\00"
@.str.60 = [70 x i8] c" part thereof, to be licensed as a whole at no charge to all third\00"
@.str.61 = [45 x i8] c" parties under the terms of this License.\00"
@.str.62 = [69 x i8] c" c) If the modified program normally reads commands interactively\00"
@.str.63 = [63 x i8] c" when run, you must cause it, when started running for such\00"
@.str.64 = [69 x i8] c" interactive use in the most ordinary way, to print or display an\00"
@.str.65 = [65 x i8] c" announcement including an appropriate copyright notice and a\00"
@.str.66 = [71 x i8] c" notice that there is no warranty (or else, saying that you provide\00"
@.str.67 = [66 x i8] c" a warranty) and that users may redistribute the program under\00"
@.str.68 = [70 x i8] c" these conditions, and telling the user how to view a copy of this\00"
@.str.69 = [67 x i8] c" License. (Exception: if the Program itself is interactive but\00"
@.str.70 = [69 x i8] c" does not normally print such an announcement, your work based on\00"
@.str.71 = [59 x i8] c" the Program is not required to print an announcement.)\00"
@.str.72 = [62 x i8] c"These requirements apply to the modified work as a whole. If\00"
@.str.73 = [69 x i8] c"identifiable sections of that work are not derived from the Program,\00"
@.str.74 = [67 x i8] c"and can be reasonably considered independent and separate works in\00"
@.str.75 = [68 x i8] c"themselves, then this License, and its terms, do not apply to those\00"
@.str.76 = [67 x i8] c"sections when you distribute them as separate works. But when you\00"
@.str.77 = [70 x i8] c"distribute the same sections as part of a whole which is a work based\00"
@.str.78 = [70 x i8] c"on the Program, the distribution of the whole must be on the terms of\00"
@.str.79 = [66 x i8] c"this License, whose permissions for other licensees extend to the\00"
@.str.80 = [74 x i8] c"entire whole, and thus to each and every part regardless of who wrote it.\00"
@.str.81 = [70 x i8] c"Thus, it is not the intent of this section to claim rights or contest\00"
@.str.82 = [70 x i8] c"your rights to work written entirely by you; rather, the intent is to\00"
@.str.83 = [64 x i8] c"exercise the right to control the distribution of derivative or\00"
@.str.84 = [39 x i8] c"collective works based on the Program.\00"
@.str.85 = [71 x i8] c"In addition, mere aggregation of another work not based on the Program\00"
@.str.86 = [70 x i8] c"with the Program (or with a work based on the Program) on a volume of\00"
@.str.87 = [69 x i8] c"a storage or distribution medium does not bring the other work under\00"
@.str.88 = [27 x i8] c"the scope of this License.\00"
@.str.89 = [69 x i8] c" 3. You may copy and distribute the Program (or a work based on it,\00"
@.str.90 = [70 x i8] c"under Section 2) in object code or executable form under the terms of\00"
@.str.91 = [71 x i8] c"Sections 1 and 2 above provided that you also do one of the following:\00"
@.str.92 = [69 x i8] c" a) Accompany it with the complete corresponding machine-readable\00"
@.str.93 = [71 x i8] c" source code, which must be distributed under the terms of Sections\00"
@.str.94 = [77 x i8] c" 1 and 2 above on a medium customarily used for software interchange; or,\00"
@.str.95 = [67 x i8] c" b) Accompany it with a written offer, valid for at least three\00"
@.str.96 = [67 x i8] c" years, to give any third party, for a charge no more than your\00"
@.str.97 = [66 x i8] c" cost of physically performing source distribution, a complete\00"
@.str.98 = [66 x i8] c" machine-readable copy of the corresponding source code, to be\00"
@.str.99 = [70 x i8] c" distributed under the terms of Sections 1 and 2 above on a medium\00"
@.str.100 = [51 x i8] c" customarily used for software interchange; or,\00"
@.str.101 = [70 x i8] c" c) Accompany it with the information you received as to the offer\00"
@.str.102 = [67 x i8] c" to distribute corresponding source code. (This alternative is\00"
@.str.103 = [64 x i8] c" allowed only for noncommercial distribution and only if you\00"
@.str.104 = [69 x i8] c" received the program in object code or executable form with such\00"
@.str.105 = [50 x i8] c" an offer, in accord with Subsection b above.)\00"
@.str.106 = [68 x i8] c"The source code for a work means the preferred form of the work for\00"
@.str.107 = [69 x i8] c"making modifications to it. For an executable work, complete source\00"
@.str.108 = [69 x i8] c"code means all the source code for all modules it contains, plus any\00"
@.str.109 = [64 x i8] c"associated interface definition files, plus the scripts used to\00"
@.str.110 = [71 x i8] c"control compilation and installation of the executable. However, as a\00"
@.str.111 = [64 x i8] c"special exception, the source code distributed need not include\00"
@.str.112 = [66 x i8] c"anything that is normally distributed (in either source or binary\00"
@.str.113 = [69 x i8] c"form) with the major components (compiler, kernel, and so on) of the\00"
@.str.114 = [69 x i8] c"operating system on which the executable runs, unless that component\00"
@.str.115 = [35 x i8] c"itself accompanies the executable.\00"
@.str.116 = [65 x i8] c"If distribution of executable or object code is made by offering\00"
@.str.117 = [65 x i8] c"access to copy from a designated place, then offering equivalent\00"
@.str.118 = [61 x i8] c"access to copy the source code from the same place counts as\00"
@.str.119 = [67 x i8] c"distribution of the source code, even though third parties are not\00"
@.str.120 = [57 x i8] c"compelled to copy the source along with the object code.\00"
@.str.121 = [69 x i8] c" 4. You may not copy, modify, sublicense, or distribute the Program\00"
@.str.122 = [62 x i8] c"except as expressly provided under this License. Any attempt\00"
@.str.123 = [67 x i8] c"otherwise to copy, modify, sublicense or distribute the Program is\00"
@.str.124 = [71 x i8] c"void, and will automatically terminate your rights under this License.\00"
@.str.125 = [69 x i8] c"However, parties who have received copies, or rights, from you under\00"
@.str.126 = [69 x i8] c"this License will not have their licenses terminated so long as such\00"
@.str.127 = [35 x i8] c"parties remain in full compliance.\00"
@.str.128 = [69 x i8] c" 5. You are not required to accept this License, since you have not\00"
@.str.129 = [69 x i8] c"signed it. However, nothing else grants you permission to modify or\00"
@.str.130 = [67 x i8] c"distribute the Program or its derivative works. These actions are\00"
@.str.131 = [68 x i8] c"prohibited by law if you do not accept this License. Therefore, by\00"
@.str.132 = [64 x i8] c"modifying or distributing the Program (or any work based on the\00"
@.str.133 = [69 x i8] c"Program), you indicate your acceptance of this License to do so, and\00"
@.str.134 = [68 x i8] c"all its terms and conditions for copying, distributing or modifying\00"
@.str.135 = [34 x i8] c"the Program or works based on it.\00"
@.str.136 = [70 x i8] c" 6. Each time you redistribute the Program (or any work based on the\00"
@.str.137 = [66 x i8] c"Program), the recipient automatically receives a license from the\00"
@.str.138 = [71 x i8] c"original licensor to copy, distribute or modify the Program subject to\00"
@.str.139 = [60 x i8] c"these terms and conditions. You may not impose any further\00"
@.str.140 = [71 x i8] c"restrictions on the recipients' exercise of the rights granted herein.\00"
@.str.141 = [69 x i8] c"You are not responsible for enforcing compliance by third parties to\00"
@.str.142 = [14 x i8] c"this License.\00"
@.str.143 = [70 x i8] c" 7. If, as a consequence of a court judgment or allegation of patent\00"
@.str.144 = [69 x i8] c"infringement or for any other reason (not limited to patent issues),\00"
@.str.145 = [68 x i8] c"conditions are imposed on you (whether by court order, agreement or\00"
@.str.146 = [71 x i8] c"otherwise) that contradict the conditions of this License, they do not\00"
@.str.147 = [63 x i8] c"excuse you from the conditions of this License. If you cannot\00"
@.str.148 = [71 x i8] c"distribute so as to satisfy simultaneously your obligations under this\00"
@.str.149 = [71 x i8] c"License and any other pertinent obligations, then as a consequence you\00"
@.str.150 = [65 x i8] c"may not distribute the Program at all. For example, if a patent\00"
@.str.151 = [71 x i8] c"license would not permit royalty-free redistribution of the Program by\00"
@.str.152 = [70 x i8] c"all those who receive copies directly or indirectly through you, then\00"
@.str.153 = [68 x i8] c"the only way you could satisfy both it and this License would be to\00"
@.str.154 = [51 x i8] c"refrain entirely from distribution of the Program.\00"
@.str.155 = [70 x i8] c"If any portion of this section is held invalid or unenforceable under\00"
@.str.156 = [71 x i8] c"any particular circumstance, the balance of the section is intended to\00"
@.str.157 = [63 x i8] c"apply and the section as a whole is intended to apply in other\00"
@.str.158 = [15 x i8] c"circumstances.\00"
@.str.159 = [68 x i8] c"It is not the purpose of this section to induce you to infringe any\00"
@.str.160 = [69 x i8] c"patents or other property right claims or to contest validity of any\00"
@.str.161 = [65 x i8] c"such claims; this section has the sole purpose of protecting the\00"
@.str.162 = [61 x i8] c"integrity of the free software distribution system, which is\00"
@.str.163 = [64 x i8] c"implemented by public license practices. Many people have made\00"
@.str.164 = [65 x i8] c"generous contributions to the wide range of software distributed\00"
@.str.165 = [66 x i8] c"through that system in reliance on consistent application of that\00"
@.str.166 = [71 x i8] c"system; it is up to the author/donor to decide if he or she is willing\00"
@.str.167 = [70 x i8] c"to distribute software through any other system and a licensee cannot\00"
@.str.168 = [20 x i8] c"impose that choice.\00"
@.str.169 = [70 x i8] c"This section is intended to make thoroughly clear what is believed to\00"
@.str.170 = [46 x i8] c"be a consequence of the rest of this License.\00"
@.str.171 = [68 x i8] c" 8. If the distribution and/or use of the Program is restricted in\00"
@.str.172 = [70 x i8] c"certain countries either by patents or by copyrighted interfaces, the\00"
@.str.173 = [68 x i8] c"original copyright holder who places the Program under this License\00"
@.str.174 = [67 x i8] c"may add an explicit geographical distribution limitation excluding\00"
@.str.175 = [68 x i8] c"those countries, so that distribution is permitted only in or among\00"
@.str.176 = [70 x i8] c"countries not thus excluded. In such case, this License incorporates\00"
@.str.177 = [58 x i8] c"the limitation as if written in the body of this License.\00"
@.str.178 = [74 x i8] c" 9. The Free Software Foundation may publish revised and/or new versions\00"
@.str.179 = [73 x i8] c"of the General Public License from time to time. Such new versions will\00"
@.str.180 = [73 x i8] c"be similar in spirit to the present version, but may differ in detail to\00"
@.str.181 = [34 x i8] c"address new problems or concerns.\00"
@.str.182 = [71 x i8] c"Each version is given a distinguishing version number. If the Program\00"
@.str.183 = [71 x i8] c"specifies a version number of this License which applies to it and any\00"
@.str.184 = [73 x i8] c"later version, you have the option of following the terms and conditions\00"
@.str.185 = [69 x i8] c"either of that version or of any later version published by the Free\00"
@.str.186 = [74 x i8] c"Software Foundation. If the Program does not specify a version number of\00"
@.str.187 = [77 x i8] c"this License, you may choose any version ever published by the Free Software\00"
@.str.188 = [12 x i8] c"Foundation.\00"
@.str.189 = [70 x i8] c" 10. If you wish to incorporate parts of the Program into other free\00"
@.str.190 = [74 x i8] c"programs whose distribution conditions are different, write to the author\00"
@.str.191 = [70 x i8] c"to ask for permission. For software which is copyrighted by the Free\00"
@.str.192 = [73 x i8] c"Software Foundation, write to the Free Software Foundation; we sometimes\00"
@.str.193 = [72 x i8] c"make exceptions for this. Our decision will be guided by the two goals\00"
@.str.194 = [74 x i8] c"of preserving the free status of all derivatives of our free software and\00"
@.str.195 = [58 x i8] c"of promoting the sharing and reuse of software generally.\00"
@.str.196 = [35 x i8] c"\09\09 END OF TERMS AND CONDITIONS\00"
@.str.197 = [50 x i8] c" -----------------------------------\00"
define void @Copyright(i32 %0) {
store i8 0, i8* getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0)
switch i32 %0, label %1075 [
i32 1, label %2
i32 2, label %20
i32 3, label %126
]
2: ; preds = %1
%3 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%4 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %3
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(50) %4, i8* align 1 dereferenceable(50) getelementptr inbounds ([50 x i8], [50 x i8]* @.str, i64 0, i64 0), i64 50, i1 false)
%5 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%6 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %5
%7 = bitcast i8* %6 to i16*
store i16 10, i16* %7
%8 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%9 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %8
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(83) %9, i8* align 1 dereferenceable(83) getelementptr inbounds ([83 x i8], [83 x i8]* @.str.2, i64 0, i64 0), i64 83, i1 false)
%10 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%11 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %10
%12 = bitcast i8* %11 to i16*
store i16 10, i16* %12
%13 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%14 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %13
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(62) %14, i8* align 1 dereferenceable(62) getelementptr inbounds ([62 x i8], [62 x i8]* @.str.3, i64 0, i64 0), i64 62, i1 false)
%15 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%16 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %15
%17 = bitcast i8* %16 to i16*
store i16 10, i16* %17
%18 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%19 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %18
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(69) %19, i8* align 1 dereferenceable(69) getelementptr inbounds ([69 x i8], [69 x i8]* @.str.4, i64 0, i64 0), i64 69, i1 false)
br label %1071
20: ; preds = %1
%21 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%22 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %21
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(56) %22, i8* align 1 dereferenceable(56) getelementptr inbounds ([56 x i8], [56 x i8]* @.str.5, i64 0, i64 0), i64 56, i1 false)
%23 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%24 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %23
%25 = bitcast i8* %24 to i16*
store i16 10, i16* %25
%26 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%27 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %26
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(56) %27, i8* align 1 dereferenceable(56) getelementptr inbounds ([56 x i8], [56 x i8]* @.str.6, i64 0, i64 0), i64 56, i1 false)
%28 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%29 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %28
%30 = bitcast i8* %29 to i16*
store i16 10, i16* %30
%31 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%32 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %31
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(72) %32, i8* align 1 dereferenceable(72) getelementptr inbounds ([72 x i8], [72 x i8]* @.str.7, i64 0, i64 0), i64 72, i1 false)
%33 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%34 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %33
%35 = bitcast i8* %34 to i16*
store i16 10, i16* %35
%36 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%37 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %36
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(76) %37, i8* align 1 dereferenceable(76) getelementptr inbounds ([76 x i8], [76 x i8]* @.str.8, i64 0, i64 0), i64 76, i1 false)
%38 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%39 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %38
%40 = bitcast i8* %39 to i16*
store i16 10, i16* %40
%41 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%42 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %41
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(74) %42, i8* align 1 dereferenceable(74) getelementptr inbounds ([74 x i8], [74 x i8]* @.str.9, i64 0, i64 0), i64 74, i1 false)
%43 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%44 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %43
%45 = bitcast i8* %44 to i16*
store i16 10, i16* %45
%46 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%47 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %46
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(78) %47, i8* align 1 dereferenceable(78) getelementptr inbounds ([78 x i8], [78 x i8]* @.str.10, i64 0, i64 0), i64 78, i1 false)
%48 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%49 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %48
%50 = bitcast i8* %49 to i16*
store i16 10, i16* %50
%51 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%52 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %51
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(72) %52, i8* align 1 dereferenceable(72) getelementptr inbounds ([72 x i8], [72 x i8]* @.str.11, i64 0, i64 0), i64 72, i1 false)
%53 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%54 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %53
%55 = bitcast i8* %54 to i16*
store i16 10, i16* %55
%56 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%57 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %56
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(77) %57, i8* align 1 dereferenceable(77) getelementptr inbounds ([77 x i8], [77 x i8]* @.str.12, i64 0, i64 0), i64 77, i1 false)
%58 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%59 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %58
%60 = bitcast i8* %59 to i16*
store i16 10, i16* %60
%61 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%62 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %61
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(75) %62, i8* align 1 dereferenceable(75) getelementptr inbounds ([75 x i8], [75 x i8]* @.str.13, i64 0, i64 0), i64 75, i1 false)
%63 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%64 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %63
%65 = bitcast i8* %64 to i16*
store i16 10, i16* %65
%66 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%67 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %66
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(76) %67, i8* align 1 dereferenceable(76) getelementptr inbounds ([76 x i8], [76 x i8]* @.str.14, i64 0, i64 0), i64 76, i1 false)
%68 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%69 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %68
%70 = bitcast i8* %69 to i16*
store i16 10, i16* %70
%71 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%72 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %71
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(25) %72, i8* align 1 dereferenceable(25) getelementptr inbounds ([25 x i8], [25 x i8]* @.str.15, i64 0, i64 0), i64 25, i1 false)
%73 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%74 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %73
%75 = bitcast i8* %74 to i16*
store i16 10, i16* %75
%76 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%77 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %76
%78 = bitcast i8* %77 to i16*
store i16 10, i16* %78
%79 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%80 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %79
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(73) %80, i8* align 1 dereferenceable(73) getelementptr inbounds ([73 x i8], [73 x i8]* @.str.17, i64 0, i64 0), i64 73, i1 false)
%81 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%82 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %81
%83 = bitcast i8* %82 to i16*
store i16 10, i16* %83
%84 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%85 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %84
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(71) %85, i8* align 1 dereferenceable(71) getelementptr inbounds ([71 x i8], [71 x i8]* @.str.18, i64 0, i64 0), i64 71, i1 false)
%86 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%87 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %86
%88 = bitcast i8* %87 to i16*
store i16 10, i16* %88
%89 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%90 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %89
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(78) %90, i8* align 1 dereferenceable(78) getelementptr inbounds ([78 x i8], [78 x i8]* @.str.19, i64 0, i64 0), i64 78, i1 false)
%91 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%92 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %91
%93 = bitcast i8* %92 to i16*
store i16 10, i16* %93
%94 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%95 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %94
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(79) %95, i8* align 1 dereferenceable(79) getelementptr inbounds ([79 x i8], [79 x i8]* @.str.20, i64 0, i64 0), i64 79, i1 false)
%96 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%97 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %96
%98 = bitcast i8* %97 to i16*
store i16 10, i16* %98
%99 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%100 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %99
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(77) %100, i8* align 1 dereferenceable(77) getelementptr inbounds ([77 x i8], [77 x i8]* @.str.21, i64 0, i64 0), i64 77, i1 false)
%101 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%102 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %101
%103 = bitcast i8* %102 to i16*
store i16 10, i16* %103
%104 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%105 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %104
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(76) %105, i8* align 1 dereferenceable(76) getelementptr inbounds ([76 x i8], [76 x i8]* @.str.22, i64 0, i64 0), i64 76, i1 false)
%106 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%107 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %106
%108 = bitcast i8* %107 to i16*
store i16 10, i16* %108
%109 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%110 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %109
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(78) %110, i8* align 1 dereferenceable(78) getelementptr inbounds ([78 x i8], [78 x i8]* @.str.23, i64 0, i64 0), i64 78, i1 false)
%111 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%112 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %111
%113 = bitcast i8* %112 to i16*
store i16 10, i16* %113
%114 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%115 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %114
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(73) %115, i8* align 1 dereferenceable(73) getelementptr inbounds ([73 x i8], [73 x i8]* @.str.24, i64 0, i64 0), i64 73, i1 false)
%116 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%117 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %116
%118 = bitcast i8* %117 to i16*
store i16 10, i16* %118
%119 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%120 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %119
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(32) %120, i8* align 1 dereferenceable(32) getelementptr inbounds ([32 x i8], [32 x i8]* @.str.25, i64 0, i64 0), i64 32, i1 false)
%121 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%122 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %121
%123 = bitcast i8* %122 to i16*
store i16 10, i16* %123
%124 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%125 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %124
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(56) %125, i8* align 1 dereferenceable(56) getelementptr inbounds ([56 x i8], [56 x i8]* @.str.6, i64 0, i64 0), i64 56, i1 false)
br label %1071
126: ; preds = %1
%127 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%128 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %127
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(36) %128, i8* align 1 dereferenceable(36) getelementptr inbounds ([36 x i8], [36 x i8]* @.str.26, i64 0, i64 0), i64 36, i1 false)
%129 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%130 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %129
%131 = bitcast i8* %130 to i16*
store i16 10, i16* %131
%132 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%133 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %132
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(67) %133, i8* align 1 dereferenceable(67) getelementptr inbounds ([67 x i8], [67 x i8]* @.str.27, i64 0, i64 0), i64 67, i1 false)
%134 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%135 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %134
%136 = bitcast i8* %135 to i16*
store i16 10, i16* %136
%137 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%138 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %137
%139 = bitcast i8* %138 to i16*
store i16 10, i16* %139
%140 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%141 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %140
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(70) %141, i8* align 1 dereferenceable(70) getelementptr inbounds ([70 x i8], [70 x i8]* @.str.28, i64 0, i64 0), i64 70, i1 false)
%142 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%143 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %142
%144 = bitcast i8* %143 to i16*
store i16 10, i16* %144
%145 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%146 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %145
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(69) %146, i8* align 1 dereferenceable(69) getelementptr inbounds ([69 x i8], [69 x i8]* @.str.29, i64 0, i64 0), i64 69, i1 false)
%147 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%148 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %147
%149 = bitcast i8* %148 to i16*
store i16 10, i16* %149
%150 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%151 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %150
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(71) %151, i8* align 1 dereferenceable(71) getelementptr inbounds ([71 x i8], [71 x i8]* @.str.30, i64 0, i64 0), i64 71, i1 false)
%152 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%153 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %152
%154 = bitcast i8* %153 to i16*
store i16 10, i16* %154
%155 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%156 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %155
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(68) %156, i8* align 1 dereferenceable(68) getelementptr inbounds ([68 x i8], [68 x i8]* @.str.31, i64 0, i64 0), i64 68, i1 false)
%157 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%158 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %157
%159 = bitcast i8* %158 to i16*
store i16 10, i16* %159
%160 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%161 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %160
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(69) %161, i8* align 1 dereferenceable(69) getelementptr inbounds ([69 x i8], [69 x i8]* @.str.32, i64 0, i64 0), i64 69, i1 false)
%162 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%163 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %162
%164 = bitcast i8* %163 to i16*
store i16 10, i16* %164
%165 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%166 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %165
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(66) %166, i8* align 1 dereferenceable(66) getelementptr inbounds ([66 x i8], [66 x i8]* @.str.33, i64 0, i64 0), i64 66, i1 false)
%167 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%168 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %167
%169 = bitcast i8* %168 to i16*
store i16 10, i16* %169
%170 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%171 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %170
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(69) %171, i8* align 1 dereferenceable(69) getelementptr inbounds ([69 x i8], [69 x i8]* @.str.34, i64 0, i64 0), i64 69, i1 false)
%172 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%173 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %172
%174 = bitcast i8* %173 to i16*
store i16 10, i16* %174
%175 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%176 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %175
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(71) %176, i8* align 1 dereferenceable(71) getelementptr inbounds ([71 x i8], [71 x i8]* @.str.35, i64 0, i64 0), i64 71, i1 false)
%177 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%178 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %177
%179 = bitcast i8* %178 to i16*
store i16 10, i16* %179
%180 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%181 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %180
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(60) %181, i8* align 1 dereferenceable(60) getelementptr inbounds ([60 x i8], [60 x i8]* @.str.36, i64 0, i64 0), i64 60, i1 false)
%182 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%183 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %182
%184 = bitcast i8* %183 to i16*
store i16 10, i16* %184
%185 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%186 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %185
%187 = bitcast i8* %186 to i16*
store i16 10, i16* %187
%188 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%189 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %188
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(69) %189, i8* align 1 dereferenceable(69) getelementptr inbounds ([69 x i8], [69 x i8]* @.str.37, i64 0, i64 0), i64 69, i1 false)
%190 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%191 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %190
%192 = bitcast i8* %191 to i16*
store i16 10, i16* %192
%193 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%194 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %193
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(65) %194, i8* align 1 dereferenceable(65) getelementptr inbounds ([65 x i8], [65 x i8]* @.str.38, i64 0, i64 0), i64 65, i1 false)
%195 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%196 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %195
%197 = bitcast i8* %196 to i16*
store i16 10, i16* %197
%198 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%199 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %198
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(71) %199, i8* align 1 dereferenceable(71) getelementptr inbounds ([71 x i8], [71 x i8]* @.str.39, i64 0, i64 0), i64 71, i1 false)
%200 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%201 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %200
%202 = bitcast i8* %201 to i16*
store i16 10, i16* %202
%203 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%204 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %203
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(63) %204, i8* align 1 dereferenceable(63) getelementptr inbounds ([63 x i8], [63 x i8]* @.str.40, i64 0, i64 0), i64 63, i1 false)
%205 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%206 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %205
%207 = bitcast i8* %206 to i16*
store i16 10, i16* %207
%208 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%209 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %208
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(66) %209, i8* align 1 dereferenceable(66) getelementptr inbounds ([66 x i8], [66 x i8]* @.str.41, i64 0, i64 0), i64 66, i1 false)
%210 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%211 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %210
%212 = bitcast i8* %211 to i16*
store i16 10, i16* %212
%213 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%214 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %213
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(55) %214, i8* align 1 dereferenceable(55) getelementptr inbounds ([55 x i8], [55 x i8]* @.str.42, i64 0, i64 0), i64 55, i1 false)
%215 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%216 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %215
%217 = bitcast i8* %216 to i16*
store i16 10, i16* %217
%218 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%219 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %218
%220 = bitcast i8* %219 to i16*
store i16 10, i16* %220
%221 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%222 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %221
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(66) %222, i8* align 1 dereferenceable(66) getelementptr inbounds ([66 x i8], [66 x i8]* @.str.43, i64 0, i64 0), i64 66, i1 false)
%223 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%224 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %223
%225 = bitcast i8* %224 to i16*
store i16 10, i16* %225
%226 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%227 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %226
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(64) %227, i8* align 1 dereferenceable(64) getelementptr inbounds ([64 x i8], [64 x i8]* @.str.44, i64 0, i64 0), i64 64, i1 false)
%228 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%229 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %228
%230 = bitcast i8* %229 to i16*
store i16 10, i16* %230
%231 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%232 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %231
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(68) %232, i8* align 1 dereferenceable(68) getelementptr inbounds ([68 x i8], [68 x i8]* @.str.45, i64 0, i64 0), i64 68, i1 false)
%233 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%234 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %233
%235 = bitcast i8* %234 to i16*
store i16 10, i16* %235
%236 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%237 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %236
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(65) %237, i8* align 1 dereferenceable(65) getelementptr inbounds ([65 x i8], [65 x i8]* @.str.46, i64 0, i64 0), i64 65, i1 false)
%238 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%239 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %238
%240 = bitcast i8* %239 to i16*
store i16 10, i16* %240
%241 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%242 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %241
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(71) %242, i8* align 1 dereferenceable(71) getelementptr inbounds ([71 x i8], [71 x i8]* @.str.47, i64 0, i64 0), i64 71, i1 false)
%243 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%244 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %243
%245 = bitcast i8* %244 to i16*
store i16 10, i16* %245
%246 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%247 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %246
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(68) %247, i8* align 1 dereferenceable(68) getelementptr inbounds ([68 x i8], [68 x i8]* @.str.48, i64 0, i64 0), i64 68, i1 false)
%248 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%249 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %248
%250 = bitcast i8* %249 to i16*
store i16 10, i16* %250
%251 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%252 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %251
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(24) %252, i8* align 1 dereferenceable(24) getelementptr inbounds ([24 x i8], [24 x i8]* @.str.49, i64 0, i64 0), i64 24, i1 false)
%253 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%254 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %253
%255 = bitcast i8* %254 to i16*
store i16 10, i16* %255
%256 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%257 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %256
%258 = bitcast i8* %257 to i16*
store i16 10, i16* %258
%259 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%260 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %259
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(70) %260, i8* align 1 dereferenceable(70) getelementptr inbounds ([70 x i8], [70 x i8]* @.str.50, i64 0, i64 0), i64 70, i1 false)
%261 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%262 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %261
%263 = bitcast i8* %262 to i16*
store i16 10, i16* %263
%264 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%265 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %264
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(72) %265, i8* align 1 dereferenceable(72) getelementptr inbounds ([72 x i8], [72 x i8]* @.str.51, i64 0, i64 0), i64 72, i1 false)
%266 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%267 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %266
%268 = bitcast i8* %267 to i16*
store i16 10, i16* %268
%269 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%270 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %269
%271 = bitcast i8* %270 to i16*
store i16 10, i16* %271
%272 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%273 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %272
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(70) %273, i8* align 1 dereferenceable(70) getelementptr inbounds ([70 x i8], [70 x i8]* @.str.52, i64 0, i64 0), i64 70, i1 false)
%274 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%275 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %274
%276 = bitcast i8* %275 to i16*
store i16 10, i16* %276
%277 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%278 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %277
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(62) %278, i8* align 1 dereferenceable(62) getelementptr inbounds ([62 x i8], [62 x i8]* @.str.53, i64 0, i64 0), i64 62, i1 false)
%279 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%280 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %279
%281 = bitcast i8* %280 to i16*
store i16 10, i16* %281
%282 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%283 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %282
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(67) %283, i8* align 1 dereferenceable(67) getelementptr inbounds ([67 x i8], [67 x i8]* @.str.54, i64 0, i64 0), i64 67, i1 false)
%284 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%285 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %284
%286 = bitcast i8* %285 to i16*
store i16 10, i16* %286
%287 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%288 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %287
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(60) %288, i8* align 1 dereferenceable(60) getelementptr inbounds ([60 x i8], [60 x i8]* @.str.55, i64 0, i64 0), i64 60, i1 false)
%289 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%290 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %289
%291 = bitcast i8* %290 to i16*
store i16 10, i16* %291
%292 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%293 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %292
%294 = bitcast i8* %293 to i16*
store i16 10, i16* %294
%295 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%296 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %295
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(68) %296, i8* align 1 dereferenceable(68) getelementptr inbounds ([68 x i8], [68 x i8]* @.str.56, i64 0, i64 0), i64 68, i1 false)
%297 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%298 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %297
%299 = bitcast i8* %298 to i16*
store i16 10, i16* %299
%300 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%301 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %300
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(67) %301, i8* align 1 dereferenceable(67) getelementptr inbounds ([67 x i8], [67 x i8]* @.str.57, i64 0, i64 0), i64 67, i1 false)
%302 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%303 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %302
%304 = bitcast i8* %303 to i16*
store i16 10, i16* %304
%305 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%306 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %305
%307 = bitcast i8* %306 to i16*
store i16 10, i16* %307
%308 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%309 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %308
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(71) %309, i8* align 1 dereferenceable(71) getelementptr inbounds ([71 x i8], [71 x i8]* @.str.58, i64 0, i64 0), i64 71, i1 false)
%310 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%311 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %310
%312 = bitcast i8* %311 to i16*
store i16 10, i16* %312
%313 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%314 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %313
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(68) %314, i8* align 1 dereferenceable(68) getelementptr inbounds ([68 x i8], [68 x i8]* @.str.59, i64 0, i64 0), i64 68, i1 false)
%315 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%316 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %315
%317 = bitcast i8* %316 to i16*
store i16 10, i16* %317
%318 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%319 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %318
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(70) %319, i8* align 1 dereferenceable(70) getelementptr inbounds ([70 x i8], [70 x i8]* @.str.60, i64 0, i64 0), i64 70, i1 false)
%320 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%321 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %320
%322 = bitcast i8* %321 to i16*
store i16 10, i16* %322
%323 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%324 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %323
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(45) %324, i8* align 1 dereferenceable(45) getelementptr inbounds ([45 x i8], [45 x i8]* @.str.61, i64 0, i64 0), i64 45, i1 false)
%325 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%326 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %325
%327 = bitcast i8* %326 to i16*
store i16 10, i16* %327
%328 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%329 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %328
%330 = bitcast i8* %329 to i16*
store i16 10, i16* %330
%331 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%332 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %331
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(69) %332, i8* align 1 dereferenceable(69) getelementptr inbounds ([69 x i8], [69 x i8]* @.str.62, i64 0, i64 0), i64 69, i1 false)
%333 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%334 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %333
%335 = bitcast i8* %334 to i16*
store i16 10, i16* %335
%336 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%337 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %336
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(63) %337, i8* align 1 dereferenceable(63) getelementptr inbounds ([63 x i8], [63 x i8]* @.str.63, i64 0, i64 0), i64 63, i1 false)
%338 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%339 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %338
%340 = bitcast i8* %339 to i16*
store i16 10, i16* %340
%341 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%342 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %341
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(69) %342, i8* align 1 dereferenceable(69) getelementptr inbounds ([69 x i8], [69 x i8]* @.str.64, i64 0, i64 0), i64 69, i1 false)
%343 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%344 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %343
%345 = bitcast i8* %344 to i16*
store i16 10, i16* %345
%346 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%347 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %346
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(65) %347, i8* align 1 dereferenceable(65) getelementptr inbounds ([65 x i8], [65 x i8]* @.str.65, i64 0, i64 0), i64 65, i1 false)
%348 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%349 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %348
%350 = bitcast i8* %349 to i16*
store i16 10, i16* %350
%351 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%352 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %351
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(71) %352, i8* align 1 dereferenceable(71) getelementptr inbounds ([71 x i8], [71 x i8]* @.str.66, i64 0, i64 0), i64 71, i1 false)
%353 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%354 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %353
%355 = bitcast i8* %354 to i16*
store i16 10, i16* %355
%356 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%357 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %356
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(66) %357, i8* align 1 dereferenceable(66) getelementptr inbounds ([66 x i8], [66 x i8]* @.str.67, i64 0, i64 0), i64 66, i1 false)
%358 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%359 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %358
%360 = bitcast i8* %359 to i16*
store i16 10, i16* %360
%361 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%362 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %361
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(70) %362, i8* align 1 dereferenceable(70) getelementptr inbounds ([70 x i8], [70 x i8]* @.str.68, i64 0, i64 0), i64 70, i1 false)
%363 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%364 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %363
%365 = bitcast i8* %364 to i16*
store i16 10, i16* %365
%366 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%367 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %366
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(67) %367, i8* align 1 dereferenceable(67) getelementptr inbounds ([67 x i8], [67 x i8]* @.str.69, i64 0, i64 0), i64 67, i1 false)
%368 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%369 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %368
%370 = bitcast i8* %369 to i16*
store i16 10, i16* %370
%371 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%372 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %371
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(69) %372, i8* align 1 dereferenceable(69) getelementptr inbounds ([69 x i8], [69 x i8]* @.str.70, i64 0, i64 0), i64 69, i1 false)
%373 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%374 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %373
%375 = bitcast i8* %374 to i16*
store i16 10, i16* %375
%376 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%377 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %376
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(59) %377, i8* align 1 dereferenceable(59) getelementptr inbounds ([59 x i8], [59 x i8]* @.str.71, i64 0, i64 0), i64 59, i1 false)
%378 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%379 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %378
%380 = bitcast i8* %379 to i16*
store i16 10, i16* %380
%381 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%382 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %381
%383 = bitcast i8* %382 to i16*
store i16 10, i16* %383
%384 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%385 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %384
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(62) %385, i8* align 1 dereferenceable(62) getelementptr inbounds ([62 x i8], [62 x i8]* @.str.72, i64 0, i64 0), i64 62, i1 false)
%386 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%387 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %386
%388 = bitcast i8* %387 to i16*
store i16 10, i16* %388
%389 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%390 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %389
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(69) %390, i8* align 1 dereferenceable(69) getelementptr inbounds ([69 x i8], [69 x i8]* @.str.73, i64 0, i64 0), i64 69, i1 false)
%391 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%392 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %391
%393 = bitcast i8* %392 to i16*
store i16 10, i16* %393
%394 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%395 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %394
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(67) %395, i8* align 1 dereferenceable(67) getelementptr inbounds ([67 x i8], [67 x i8]* @.str.74, i64 0, i64 0), i64 67, i1 false)
%396 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%397 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %396
%398 = bitcast i8* %397 to i16*
store i16 10, i16* %398
%399 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%400 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %399
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(68) %400, i8* align 1 dereferenceable(68) getelementptr inbounds ([68 x i8], [68 x i8]* @.str.75, i64 0, i64 0), i64 68, i1 false)
%401 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%402 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %401
%403 = bitcast i8* %402 to i16*
store i16 10, i16* %403
%404 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%405 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %404
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(67) %405, i8* align 1 dereferenceable(67) getelementptr inbounds ([67 x i8], [67 x i8]* @.str.76, i64 0, i64 0), i64 67, i1 false)
%406 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%407 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %406
%408 = bitcast i8* %407 to i16*
store i16 10, i16* %408
%409 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%410 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %409
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(70) %410, i8* align 1 dereferenceable(70) getelementptr inbounds ([70 x i8], [70 x i8]* @.str.77, i64 0, i64 0), i64 70, i1 false)
%411 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%412 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %411
%413 = bitcast i8* %412 to i16*
store i16 10, i16* %413
%414 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%415 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %414
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(70) %415, i8* align 1 dereferenceable(70) getelementptr inbounds ([70 x i8], [70 x i8]* @.str.78, i64 0, i64 0), i64 70, i1 false)
%416 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%417 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %416
%418 = bitcast i8* %417 to i16*
store i16 10, i16* %418
%419 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%420 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %419
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(66) %420, i8* align 1 dereferenceable(66) getelementptr inbounds ([66 x i8], [66 x i8]* @.str.79, i64 0, i64 0), i64 66, i1 false)
%421 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%422 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %421
%423 = bitcast i8* %422 to i16*
store i16 10, i16* %423
%424 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%425 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %424
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(74) %425, i8* align 1 dereferenceable(74) getelementptr inbounds ([74 x i8], [74 x i8]* @.str.80, i64 0, i64 0), i64 74, i1 false)
%426 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%427 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %426
%428 = bitcast i8* %427 to i16*
store i16 10, i16* %428
%429 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%430 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %429
%431 = bitcast i8* %430 to i16*
store i16 10, i16* %431
%432 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%433 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %432
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(70) %433, i8* align 1 dereferenceable(70) getelementptr inbounds ([70 x i8], [70 x i8]* @.str.81, i64 0, i64 0), i64 70, i1 false)
%434 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%435 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %434
%436 = bitcast i8* %435 to i16*
store i16 10, i16* %436
%437 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%438 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %437
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(70) %438, i8* align 1 dereferenceable(70) getelementptr inbounds ([70 x i8], [70 x i8]* @.str.82, i64 0, i64 0), i64 70, i1 false)
%439 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%440 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %439
%441 = bitcast i8* %440 to i16*
store i16 10, i16* %441
%442 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%443 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %442
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(64) %443, i8* align 1 dereferenceable(64) getelementptr inbounds ([64 x i8], [64 x i8]* @.str.83, i64 0, i64 0), i64 64, i1 false)
%444 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%445 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %444
%446 = bitcast i8* %445 to i16*
store i16 10, i16* %446
%447 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%448 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %447
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(39) %448, i8* align 1 dereferenceable(39) getelementptr inbounds ([39 x i8], [39 x i8]* @.str.84, i64 0, i64 0), i64 39, i1 false)
%449 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%450 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %449
%451 = bitcast i8* %450 to i16*
store i16 10, i16* %451
%452 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%453 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %452
%454 = bitcast i8* %453 to i16*
store i16 10, i16* %454
%455 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%456 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %455
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(71) %456, i8* align 1 dereferenceable(71) getelementptr inbounds ([71 x i8], [71 x i8]* @.str.85, i64 0, i64 0), i64 71, i1 false)
%457 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%458 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %457
%459 = bitcast i8* %458 to i16*
store i16 10, i16* %459
%460 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%461 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %460
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(70) %461, i8* align 1 dereferenceable(70) getelementptr inbounds ([70 x i8], [70 x i8]* @.str.86, i64 0, i64 0), i64 70, i1 false)
%462 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%463 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %462
%464 = bitcast i8* %463 to i16*
store i16 10, i16* %464
%465 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%466 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %465
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(69) %466, i8* align 1 dereferenceable(69) getelementptr inbounds ([69 x i8], [69 x i8]* @.str.87, i64 0, i64 0), i64 69, i1 false)
%467 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%468 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %467
%469 = bitcast i8* %468 to i16*
store i16 10, i16* %469
%470 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%471 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %470
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(27) %471, i8* align 1 dereferenceable(27) getelementptr inbounds ([27 x i8], [27 x i8]* @.str.88, i64 0, i64 0), i64 27, i1 false)
%472 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%473 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %472
%474 = bitcast i8* %473 to i16*
store i16 10, i16* %474
%475 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%476 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %475
%477 = bitcast i8* %476 to i16*
store i16 10, i16* %477
%478 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%479 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %478
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(69) %479, i8* align 1 dereferenceable(69) getelementptr inbounds ([69 x i8], [69 x i8]* @.str.89, i64 0, i64 0), i64 69, i1 false)
%480 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%481 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %480
%482 = bitcast i8* %481 to i16*
store i16 10, i16* %482
%483 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%484 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %483
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(70) %484, i8* align 1 dereferenceable(70) getelementptr inbounds ([70 x i8], [70 x i8]* @.str.90, i64 0, i64 0), i64 70, i1 false)
%485 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%486 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %485
%487 = bitcast i8* %486 to i16*
store i16 10, i16* %487
%488 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%489 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %488
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(71) %489, i8* align 1 dereferenceable(71) getelementptr inbounds ([71 x i8], [71 x i8]* @.str.91, i64 0, i64 0), i64 71, i1 false)
%490 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%491 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %490
%492 = bitcast i8* %491 to i16*
store i16 10, i16* %492
%493 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%494 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %493
%495 = bitcast i8* %494 to i16*
store i16 10, i16* %495
%496 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%497 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %496
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(69) %497, i8* align 1 dereferenceable(69) getelementptr inbounds ([69 x i8], [69 x i8]* @.str.92, i64 0, i64 0), i64 69, i1 false)
%498 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%499 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %498
%500 = bitcast i8* %499 to i16*
store i16 10, i16* %500
%501 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%502 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %501
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(71) %502, i8* align 1 dereferenceable(71) getelementptr inbounds ([71 x i8], [71 x i8]* @.str.93, i64 0, i64 0), i64 71, i1 false)
%503 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%504 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %503
%505 = bitcast i8* %504 to i16*
store i16 10, i16* %505
%506 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%507 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %506
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(77) %507, i8* align 1 dereferenceable(77) getelementptr inbounds ([77 x i8], [77 x i8]* @.str.94, i64 0, i64 0), i64 77, i1 false)
%508 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%509 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %508
%510 = bitcast i8* %509 to i16*
store i16 10, i16* %510
%511 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%512 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %511
%513 = bitcast i8* %512 to i16*
store i16 10, i16* %513
%514 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%515 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %514
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(67) %515, i8* align 1 dereferenceable(67) getelementptr inbounds ([67 x i8], [67 x i8]* @.str.95, i64 0, i64 0), i64 67, i1 false)
%516 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%517 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %516
%518 = bitcast i8* %517 to i16*
store i16 10, i16* %518
%519 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%520 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %519
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(67) %520, i8* align 1 dereferenceable(67) getelementptr inbounds ([67 x i8], [67 x i8]* @.str.96, i64 0, i64 0), i64 67, i1 false)
%521 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%522 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %521
%523 = bitcast i8* %522 to i16*
store i16 10, i16* %523
%524 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%525 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %524
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(66) %525, i8* align 1 dereferenceable(66) getelementptr inbounds ([66 x i8], [66 x i8]* @.str.97, i64 0, i64 0), i64 66, i1 false)
%526 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%527 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %526
%528 = bitcast i8* %527 to i16*
store i16 10, i16* %528
%529 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%530 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %529
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(66) %530, i8* align 1 dereferenceable(66) getelementptr inbounds ([66 x i8], [66 x i8]* @.str.98, i64 0, i64 0), i64 66, i1 false)
%531 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%532 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %531
%533 = bitcast i8* %532 to i16*
store i16 10, i16* %533
%534 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%535 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %534
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(70) %535, i8* align 1 dereferenceable(70) getelementptr inbounds ([70 x i8], [70 x i8]* @.str.99, i64 0, i64 0), i64 70, i1 false)
%536 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%537 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %536
%538 = bitcast i8* %537 to i16*
store i16 10, i16* %538
%539 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%540 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %539
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(51) %540, i8* align 1 dereferenceable(51) getelementptr inbounds ([51 x i8], [51 x i8]* @.str.100, i64 0, i64 0), i64 51, i1 false)
%541 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%542 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %541
%543 = bitcast i8* %542 to i16*
store i16 10, i16* %543
%544 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%545 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %544
%546 = bitcast i8* %545 to i16*
store i16 10, i16* %546
%547 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%548 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %547
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(70) %548, i8* align 1 dereferenceable(70) getelementptr inbounds ([70 x i8], [70 x i8]* @.str.101, i64 0, i64 0), i64 70, i1 false)
%549 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%550 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %549
%551 = bitcast i8* %550 to i16*
store i16 10, i16* %551
%552 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%553 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %552
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(67) %553, i8* align 1 dereferenceable(67) getelementptr inbounds ([67 x i8], [67 x i8]* @.str.102, i64 0, i64 0), i64 67, i1 false)
%554 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%555 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %554
%556 = bitcast i8* %555 to i16*
store i16 10, i16* %556
%557 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%558 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %557
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(64) %558, i8* align 1 dereferenceable(64) getelementptr inbounds ([64 x i8], [64 x i8]* @.str.103, i64 0, i64 0), i64 64, i1 false)
%559 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%560 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %559
%561 = bitcast i8* %560 to i16*
store i16 10, i16* %561
%562 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%563 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %562
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(69) %563, i8* align 1 dereferenceable(69) getelementptr inbounds ([69 x i8], [69 x i8]* @.str.104, i64 0, i64 0), i64 69, i1 false)
%564 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%565 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %564
%566 = bitcast i8* %565 to i16*
store i16 10, i16* %566
%567 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%568 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %567
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(50) %568, i8* align 1 dereferenceable(50) getelementptr inbounds ([50 x i8], [50 x i8]* @.str.105, i64 0, i64 0), i64 50, i1 false)
%569 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%570 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %569
%571 = bitcast i8* %570 to i16*
store i16 10, i16* %571
%572 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%573 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %572
%574 = bitcast i8* %573 to i16*
store i16 10, i16* %574
%575 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%576 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %575
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(68) %576, i8* align 1 dereferenceable(68) getelementptr inbounds ([68 x i8], [68 x i8]* @.str.106, i64 0, i64 0), i64 68, i1 false)
%577 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%578 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %577
%579 = bitcast i8* %578 to i16*
store i16 10, i16* %579
%580 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%581 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %580
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(69) %581, i8* align 1 dereferenceable(69) getelementptr inbounds ([69 x i8], [69 x i8]* @.str.107, i64 0, i64 0), i64 69, i1 false)
%582 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%583 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %582
%584 = bitcast i8* %583 to i16*
store i16 10, i16* %584
%585 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%586 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %585
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(69) %586, i8* align 1 dereferenceable(69) getelementptr inbounds ([69 x i8], [69 x i8]* @.str.108, i64 0, i64 0), i64 69, i1 false)
%587 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%588 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %587
%589 = bitcast i8* %588 to i16*
store i16 10, i16* %589
%590 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%591 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %590
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(64) %591, i8* align 1 dereferenceable(64) getelementptr inbounds ([64 x i8], [64 x i8]* @.str.109, i64 0, i64 0), i64 64, i1 false)
%592 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%593 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %592
%594 = bitcast i8* %593 to i16*
store i16 10, i16* %594
%595 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%596 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %595
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(71) %596, i8* align 1 dereferenceable(71) getelementptr inbounds ([71 x i8], [71 x i8]* @.str.110, i64 0, i64 0), i64 71, i1 false)
%597 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%598 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %597
%599 = bitcast i8* %598 to i16*
store i16 10, i16* %599
%600 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%601 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %600
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(64) %601, i8* align 1 dereferenceable(64) getelementptr inbounds ([64 x i8], [64 x i8]* @.str.111, i64 0, i64 0), i64 64, i1 false)
%602 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%603 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %602
%604 = bitcast i8* %603 to i16*
store i16 10, i16* %604
%605 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%606 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %605
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(66) %606, i8* align 1 dereferenceable(66) getelementptr inbounds ([66 x i8], [66 x i8]* @.str.112, i64 0, i64 0), i64 66, i1 false)
%607 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%608 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %607
%609 = bitcast i8* %608 to i16*
store i16 10, i16* %609
%610 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%611 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %610
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(69) %611, i8* align 1 dereferenceable(69) getelementptr inbounds ([69 x i8], [69 x i8]* @.str.113, i64 0, i64 0), i64 69, i1 false)
%612 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%613 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %612
%614 = bitcast i8* %613 to i16*
store i16 10, i16* %614
%615 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%616 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %615
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(69) %616, i8* align 1 dereferenceable(69) getelementptr inbounds ([69 x i8], [69 x i8]* @.str.114, i64 0, i64 0), i64 69, i1 false)
%617 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%618 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %617
%619 = bitcast i8* %618 to i16*
store i16 10, i16* %619
%620 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%621 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %620
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(35) %621, i8* align 1 dereferenceable(35) getelementptr inbounds ([35 x i8], [35 x i8]* @.str.115, i64 0, i64 0), i64 35, i1 false)
%622 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%623 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %622
%624 = bitcast i8* %623 to i16*
store i16 10, i16* %624
%625 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%626 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %625
%627 = bitcast i8* %626 to i16*
store i16 10, i16* %627
%628 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%629 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %628
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(65) %629, i8* align 1 dereferenceable(65) getelementptr inbounds ([65 x i8], [65 x i8]* @.str.116, i64 0, i64 0), i64 65, i1 false)
%630 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%631 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %630
%632 = bitcast i8* %631 to i16*
store i16 10, i16* %632
%633 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%634 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %633
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(65) %634, i8* align 1 dereferenceable(65) getelementptr inbounds ([65 x i8], [65 x i8]* @.str.117, i64 0, i64 0), i64 65, i1 false)
%635 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%636 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %635
%637 = bitcast i8* %636 to i16*
store i16 10, i16* %637
%638 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%639 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %638
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(61) %639, i8* align 1 dereferenceable(61) getelementptr inbounds ([61 x i8], [61 x i8]* @.str.118, i64 0, i64 0), i64 61, i1 false)
%640 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%641 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %640
%642 = bitcast i8* %641 to i16*
store i16 10, i16* %642
%643 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%644 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %643
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(67) %644, i8* align 1 dereferenceable(67) getelementptr inbounds ([67 x i8], [67 x i8]* @.str.119, i64 0, i64 0), i64 67, i1 false)
%645 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%646 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %645
%647 = bitcast i8* %646 to i16*
store i16 10, i16* %647
%648 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%649 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %648
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(57) %649, i8* align 1 dereferenceable(57) getelementptr inbounds ([57 x i8], [57 x i8]* @.str.120, i64 0, i64 0), i64 57, i1 false)
%650 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%651 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %650
%652 = bitcast i8* %651 to i16*
store i16 10, i16* %652
%653 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%654 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %653
%655 = bitcast i8* %654 to i16*
store i16 10, i16* %655
%656 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%657 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %656
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(69) %657, i8* align 1 dereferenceable(69) getelementptr inbounds ([69 x i8], [69 x i8]* @.str.121, i64 0, i64 0), i64 69, i1 false)
%658 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%659 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %658
%660 = bitcast i8* %659 to i16*
store i16 10, i16* %660
%661 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%662 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %661
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(62) %662, i8* align 1 dereferenceable(62) getelementptr inbounds ([62 x i8], [62 x i8]* @.str.122, i64 0, i64 0), i64 62, i1 false)
%663 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%664 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %663
%665 = bitcast i8* %664 to i16*
store i16 10, i16* %665
%666 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%667 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %666
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(67) %667, i8* align 1 dereferenceable(67) getelementptr inbounds ([67 x i8], [67 x i8]* @.str.123, i64 0, i64 0), i64 67, i1 false)
%668 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%669 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %668
%670 = bitcast i8* %669 to i16*
store i16 10, i16* %670
%671 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%672 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %671
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(71) %672, i8* align 1 dereferenceable(71) getelementptr inbounds ([71 x i8], [71 x i8]* @.str.124, i64 0, i64 0), i64 71, i1 false)
%673 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%674 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %673
%675 = bitcast i8* %674 to i16*
store i16 10, i16* %675
%676 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%677 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %676
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(69) %677, i8* align 1 dereferenceable(69) getelementptr inbounds ([69 x i8], [69 x i8]* @.str.125, i64 0, i64 0), i64 69, i1 false)
%678 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%679 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %678
%680 = bitcast i8* %679 to i16*
store i16 10, i16* %680
%681 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%682 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %681
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(69) %682, i8* align 1 dereferenceable(69) getelementptr inbounds ([69 x i8], [69 x i8]* @.str.126, i64 0, i64 0), i64 69, i1 false)
%683 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%684 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %683
%685 = bitcast i8* %684 to i16*
store i16 10, i16* %685
%686 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%687 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %686
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(35) %687, i8* align 1 dereferenceable(35) getelementptr inbounds ([35 x i8], [35 x i8]* @.str.127, i64 0, i64 0), i64 35, i1 false)
%688 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%689 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %688
%690 = bitcast i8* %689 to i16*
store i16 10, i16* %690
%691 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%692 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %691
%693 = bitcast i8* %692 to i16*
store i16 10, i16* %693
%694 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%695 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %694
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(69) %695, i8* align 1 dereferenceable(69) getelementptr inbounds ([69 x i8], [69 x i8]* @.str.128, i64 0, i64 0), i64 69, i1 false)
%696 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%697 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %696
%698 = bitcast i8* %697 to i16*
store i16 10, i16* %698
%699 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%700 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %699
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(69) %700, i8* align 1 dereferenceable(69) getelementptr inbounds ([69 x i8], [69 x i8]* @.str.129, i64 0, i64 0), i64 69, i1 false)
%701 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%702 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %701
%703 = bitcast i8* %702 to i16*
store i16 10, i16* %703
%704 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%705 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %704
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(67) %705, i8* align 1 dereferenceable(67) getelementptr inbounds ([67 x i8], [67 x i8]* @.str.130, i64 0, i64 0), i64 67, i1 false)
%706 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%707 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %706
%708 = bitcast i8* %707 to i16*
store i16 10, i16* %708
%709 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%710 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %709
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(68) %710, i8* align 1 dereferenceable(68) getelementptr inbounds ([68 x i8], [68 x i8]* @.str.131, i64 0, i64 0), i64 68, i1 false)
%711 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%712 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %711
%713 = bitcast i8* %712 to i16*
store i16 10, i16* %713
%714 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%715 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %714
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(64) %715, i8* align 1 dereferenceable(64) getelementptr inbounds ([64 x i8], [64 x i8]* @.str.132, i64 0, i64 0), i64 64, i1 false)
%716 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%717 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %716
%718 = bitcast i8* %717 to i16*
store i16 10, i16* %718
%719 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%720 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %719
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(69) %720, i8* align 1 dereferenceable(69) getelementptr inbounds ([69 x i8], [69 x i8]* @.str.133, i64 0, i64 0), i64 69, i1 false)
%721 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%722 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %721
%723 = bitcast i8* %722 to i16*
store i16 10, i16* %723
%724 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%725 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %724
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(68) %725, i8* align 1 dereferenceable(68) getelementptr inbounds ([68 x i8], [68 x i8]* @.str.134, i64 0, i64 0), i64 68, i1 false)
%726 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%727 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %726
%728 = bitcast i8* %727 to i16*
store i16 10, i16* %728
%729 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%730 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %729
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(34) %730, i8* align 1 dereferenceable(34) getelementptr inbounds ([34 x i8], [34 x i8]* @.str.135, i64 0, i64 0), i64 34, i1 false)
%731 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%732 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %731
%733 = bitcast i8* %732 to i16*
store i16 10, i16* %733
%734 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%735 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %734
%736 = bitcast i8* %735 to i16*
store i16 10, i16* %736
%737 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%738 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %737
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(70) %738, i8* align 1 dereferenceable(70) getelementptr inbounds ([70 x i8], [70 x i8]* @.str.136, i64 0, i64 0), i64 70, i1 false)
%739 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%740 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %739
%741 = bitcast i8* %740 to i16*
store i16 10, i16* %741
%742 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%743 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %742
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(66) %743, i8* align 1 dereferenceable(66) getelementptr inbounds ([66 x i8], [66 x i8]* @.str.137, i64 0, i64 0), i64 66, i1 false)
%744 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%745 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %744
%746 = bitcast i8* %745 to i16*
store i16 10, i16* %746
%747 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%748 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %747
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(71) %748, i8* align 1 dereferenceable(71) getelementptr inbounds ([71 x i8], [71 x i8]* @.str.138, i64 0, i64 0), i64 71, i1 false)
%749 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%750 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %749
%751 = bitcast i8* %750 to i16*
store i16 10, i16* %751
%752 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%753 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %752
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(60) %753, i8* align 1 dereferenceable(60) getelementptr inbounds ([60 x i8], [60 x i8]* @.str.139, i64 0, i64 0), i64 60, i1 false)
%754 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%755 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %754
%756 = bitcast i8* %755 to i16*
store i16 10, i16* %756
%757 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%758 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %757
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(71) %758, i8* align 1 dereferenceable(71) getelementptr inbounds ([71 x i8], [71 x i8]* @.str.140, i64 0, i64 0), i64 71, i1 false)
%759 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%760 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %759
%761 = bitcast i8* %760 to i16*
store i16 10, i16* %761
%762 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%763 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %762
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(69) %763, i8* align 1 dereferenceable(69) getelementptr inbounds ([69 x i8], [69 x i8]* @.str.141, i64 0, i64 0), i64 69, i1 false)
%764 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%765 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %764
%766 = bitcast i8* %765 to i16*
store i16 10, i16* %766
%767 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%768 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %767
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(14) %768, i8* align 1 dereferenceable(14) getelementptr inbounds ([14 x i8], [14 x i8]* @.str.142, i64 0, i64 0), i64 14, i1 false)
%769 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%770 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %769
%771 = bitcast i8* %770 to i16*
store i16 10, i16* %771
%772 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%773 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %772
%774 = bitcast i8* %773 to i16*
store i16 10, i16* %774
%775 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%776 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %775
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(70) %776, i8* align 1 dereferenceable(70) getelementptr inbounds ([70 x i8], [70 x i8]* @.str.143, i64 0, i64 0), i64 70, i1 false)
%777 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%778 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %777
%779 = bitcast i8* %778 to i16*
store i16 10, i16* %779
%780 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%781 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %780
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(69) %781, i8* align 1 dereferenceable(69) getelementptr inbounds ([69 x i8], [69 x i8]* @.str.144, i64 0, i64 0), i64 69, i1 false)
%782 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%783 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %782
%784 = bitcast i8* %783 to i16*
store i16 10, i16* %784
%785 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%786 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %785
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(68) %786, i8* align 1 dereferenceable(68) getelementptr inbounds ([68 x i8], [68 x i8]* @.str.145, i64 0, i64 0), i64 68, i1 false)
%787 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%788 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %787
%789 = bitcast i8* %788 to i16*
store i16 10, i16* %789
%790 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%791 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %790
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(71) %791, i8* align 1 dereferenceable(71) getelementptr inbounds ([71 x i8], [71 x i8]* @.str.146, i64 0, i64 0), i64 71, i1 false)
%792 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%793 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %792
%794 = bitcast i8* %793 to i16*
store i16 10, i16* %794
%795 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%796 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %795
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(63) %796, i8* align 1 dereferenceable(63) getelementptr inbounds ([63 x i8], [63 x i8]* @.str.147, i64 0, i64 0), i64 63, i1 false)
%797 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%798 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %797
%799 = bitcast i8* %798 to i16*
store i16 10, i16* %799
%800 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%801 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %800
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(71) %801, i8* align 1 dereferenceable(71) getelementptr inbounds ([71 x i8], [71 x i8]* @.str.148, i64 0, i64 0), i64 71, i1 false)
%802 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%803 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %802
%804 = bitcast i8* %803 to i16*
store i16 10, i16* %804
%805 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%806 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %805
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(71) %806, i8* align 1 dereferenceable(71) getelementptr inbounds ([71 x i8], [71 x i8]* @.str.149, i64 0, i64 0), i64 71, i1 false)
%807 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%808 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %807
%809 = bitcast i8* %808 to i16*
store i16 10, i16* %809
%810 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%811 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %810
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(65) %811, i8* align 1 dereferenceable(65) getelementptr inbounds ([65 x i8], [65 x i8]* @.str.150, i64 0, i64 0), i64 65, i1 false)
%812 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%813 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %812
%814 = bitcast i8* %813 to i16*
store i16 10, i16* %814
%815 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%816 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %815
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(71) %816, i8* align 1 dereferenceable(71) getelementptr inbounds ([71 x i8], [71 x i8]* @.str.151, i64 0, i64 0), i64 71, i1 false)
%817 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%818 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %817
%819 = bitcast i8* %818 to i16*
store i16 10, i16* %819
%820 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%821 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %820
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(70) %821, i8* align 1 dereferenceable(70) getelementptr inbounds ([70 x i8], [70 x i8]* @.str.152, i64 0, i64 0), i64 70, i1 false)
%822 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%823 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %822
%824 = bitcast i8* %823 to i16*
store i16 10, i16* %824
%825 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%826 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %825
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(68) %826, i8* align 1 dereferenceable(68) getelementptr inbounds ([68 x i8], [68 x i8]* @.str.153, i64 0, i64 0), i64 68, i1 false)
%827 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%828 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %827
%829 = bitcast i8* %828 to i16*
store i16 10, i16* %829
%830 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%831 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %830
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(51) %831, i8* align 1 dereferenceable(51) getelementptr inbounds ([51 x i8], [51 x i8]* @.str.154, i64 0, i64 0), i64 51, i1 false)
%832 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%833 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %832
%834 = bitcast i8* %833 to i16*
store i16 10, i16* %834
%835 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%836 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %835
%837 = bitcast i8* %836 to i16*
store i16 10, i16* %837
%838 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%839 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %838
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(70) %839, i8* align 1 dereferenceable(70) getelementptr inbounds ([70 x i8], [70 x i8]* @.str.155, i64 0, i64 0), i64 70, i1 false)
%840 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%841 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %840
%842 = bitcast i8* %841 to i16*
store i16 10, i16* %842
%843 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%844 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %843
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(71) %844, i8* align 1 dereferenceable(71) getelementptr inbounds ([71 x i8], [71 x i8]* @.str.156, i64 0, i64 0), i64 71, i1 false)
%845 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%846 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %845
%847 = bitcast i8* %846 to i16*
store i16 10, i16* %847
%848 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%849 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %848
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(63) %849, i8* align 1 dereferenceable(63) getelementptr inbounds ([63 x i8], [63 x i8]* @.str.157, i64 0, i64 0), i64 63, i1 false)
%850 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%851 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %850
%852 = bitcast i8* %851 to i16*
store i16 10, i16* %852
%853 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%854 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %853
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(15) %854, i8* align 1 dereferenceable(15) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.158, i64 0, i64 0), i64 15, i1 false)
%855 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%856 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %855
%857 = bitcast i8* %856 to i16*
store i16 10, i16* %857
%858 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%859 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %858
%860 = bitcast i8* %859 to i16*
store i16 10, i16* %860
%861 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%862 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %861
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(68) %862, i8* align 1 dereferenceable(68) getelementptr inbounds ([68 x i8], [68 x i8]* @.str.159, i64 0, i64 0), i64 68, i1 false)
%863 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%864 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %863
%865 = bitcast i8* %864 to i16*
store i16 10, i16* %865
%866 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%867 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %866
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(69) %867, i8* align 1 dereferenceable(69) getelementptr inbounds ([69 x i8], [69 x i8]* @.str.160, i64 0, i64 0), i64 69, i1 false)
%868 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%869 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %868
%870 = bitcast i8* %869 to i16*
store i16 10, i16* %870
%871 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%872 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %871
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(65) %872, i8* align 1 dereferenceable(65) getelementptr inbounds ([65 x i8], [65 x i8]* @.str.161, i64 0, i64 0), i64 65, i1 false)
%873 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%874 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %873
%875 = bitcast i8* %874 to i16*
store i16 10, i16* %875
%876 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%877 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %876
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(61) %877, i8* align 1 dereferenceable(61) getelementptr inbounds ([61 x i8], [61 x i8]* @.str.162, i64 0, i64 0), i64 61, i1 false)
%878 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%879 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %878
%880 = bitcast i8* %879 to i16*
store i16 10, i16* %880
%881 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%882 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %881
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(64) %882, i8* align 1 dereferenceable(64) getelementptr inbounds ([64 x i8], [64 x i8]* @.str.163, i64 0, i64 0), i64 64, i1 false)
%883 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%884 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %883
%885 = bitcast i8* %884 to i16*
store i16 10, i16* %885
%886 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%887 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %886
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(65) %887, i8* align 1 dereferenceable(65) getelementptr inbounds ([65 x i8], [65 x i8]* @.str.164, i64 0, i64 0), i64 65, i1 false)
%888 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%889 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %888
%890 = bitcast i8* %889 to i16*
store i16 10, i16* %890
%891 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%892 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %891
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(66) %892, i8* align 1 dereferenceable(66) getelementptr inbounds ([66 x i8], [66 x i8]* @.str.165, i64 0, i64 0), i64 66, i1 false)
%893 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%894 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %893
%895 = bitcast i8* %894 to i16*
store i16 10, i16* %895
%896 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%897 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %896
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(71) %897, i8* align 1 dereferenceable(71) getelementptr inbounds ([71 x i8], [71 x i8]* @.str.166, i64 0, i64 0), i64 71, i1 false)
%898 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%899 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %898
%900 = bitcast i8* %899 to i16*
store i16 10, i16* %900
%901 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%902 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %901
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(70) %902, i8* align 1 dereferenceable(70) getelementptr inbounds ([70 x i8], [70 x i8]* @.str.167, i64 0, i64 0), i64 70, i1 false)
%903 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%904 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %903
%905 = bitcast i8* %904 to i16*
store i16 10, i16* %905
%906 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%907 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %906
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(20) %907, i8* align 1 dereferenceable(20) getelementptr inbounds ([20 x i8], [20 x i8]* @.str.168, i64 0, i64 0), i64 20, i1 false)
%908 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%909 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %908
%910 = bitcast i8* %909 to i16*
store i16 10, i16* %910
%911 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%912 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %911
%913 = bitcast i8* %912 to i16*
store i16 10, i16* %913
%914 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%915 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %914
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(70) %915, i8* align 1 dereferenceable(70) getelementptr inbounds ([70 x i8], [70 x i8]* @.str.169, i64 0, i64 0), i64 70, i1 false)
%916 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%917 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %916
%918 = bitcast i8* %917 to i16*
store i16 10, i16* %918
%919 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%920 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %919
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(46) %920, i8* align 1 dereferenceable(46) getelementptr inbounds ([46 x i8], [46 x i8]* @.str.170, i64 0, i64 0), i64 46, i1 false)
%921 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%922 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %921
%923 = bitcast i8* %922 to i16*
store i16 10, i16* %923
%924 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%925 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %924
%926 = bitcast i8* %925 to i16*
store i16 10, i16* %926
%927 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%928 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %927
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(68) %928, i8* align 1 dereferenceable(68) getelementptr inbounds ([68 x i8], [68 x i8]* @.str.171, i64 0, i64 0), i64 68, i1 false)
%929 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%930 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %929
%931 = bitcast i8* %930 to i16*
store i16 10, i16* %931
%932 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%933 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %932
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(70) %933, i8* align 1 dereferenceable(70) getelementptr inbounds ([70 x i8], [70 x i8]* @.str.172, i64 0, i64 0), i64 70, i1 false)
%934 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%935 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %934
%936 = bitcast i8* %935 to i16*
store i16 10, i16* %936
%937 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%938 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %937
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(68) %938, i8* align 1 dereferenceable(68) getelementptr inbounds ([68 x i8], [68 x i8]* @.str.173, i64 0, i64 0), i64 68, i1 false)
%939 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%940 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %939
%941 = bitcast i8* %940 to i16*
store i16 10, i16* %941
%942 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%943 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %942
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(67) %943, i8* align 1 dereferenceable(67) getelementptr inbounds ([67 x i8], [67 x i8]* @.str.174, i64 0, i64 0), i64 67, i1 false)
%944 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%945 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %944
%946 = bitcast i8* %945 to i16*
store i16 10, i16* %946
%947 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%948 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %947
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(68) %948, i8* align 1 dereferenceable(68) getelementptr inbounds ([68 x i8], [68 x i8]* @.str.175, i64 0, i64 0), i64 68, i1 false)
%949 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%950 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %949
%951 = bitcast i8* %950 to i16*
store i16 10, i16* %951
%952 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%953 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %952
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(70) %953, i8* align 1 dereferenceable(70) getelementptr inbounds ([70 x i8], [70 x i8]* @.str.176, i64 0, i64 0), i64 70, i1 false)
%954 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%955 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %954
%956 = bitcast i8* %955 to i16*
store i16 10, i16* %956
%957 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%958 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %957
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(58) %958, i8* align 1 dereferenceable(58) getelementptr inbounds ([58 x i8], [58 x i8]* @.str.177, i64 0, i64 0), i64 58, i1 false)
%959 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%960 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %959
%961 = bitcast i8* %960 to i16*
store i16 10, i16* %961
%962 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%963 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %962
%964 = bitcast i8* %963 to i16*
store i16 10, i16* %964
%965 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%966 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %965
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(74) %966, i8* align 1 dereferenceable(74) getelementptr inbounds ([74 x i8], [74 x i8]* @.str.178, i64 0, i64 0), i64 74, i1 false)
%967 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%968 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %967
%969 = bitcast i8* %968 to i16*
store i16 10, i16* %969
%970 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%971 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %970
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(73) %971, i8* align 1 dereferenceable(73) getelementptr inbounds ([73 x i8], [73 x i8]* @.str.179, i64 0, i64 0), i64 73, i1 false)
%972 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%973 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %972
%974 = bitcast i8* %973 to i16*
store i16 10, i16* %974
%975 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%976 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %975
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(73) %976, i8* align 1 dereferenceable(73) getelementptr inbounds ([73 x i8], [73 x i8]* @.str.180, i64 0, i64 0), i64 73, i1 false)
%977 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%978 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %977
%979 = bitcast i8* %978 to i16*
store i16 10, i16* %979
%980 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%981 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %980
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(34) %981, i8* align 1 dereferenceable(34) getelementptr inbounds ([34 x i8], [34 x i8]* @.str.181, i64 0, i64 0), i64 34, i1 false)
%982 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%983 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %982
%984 = bitcast i8* %983 to i16*
store i16 10, i16* %984
%985 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%986 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %985
%987 = bitcast i8* %986 to i16*
store i16 10, i16* %987
%988 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%989 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %988
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(71) %989, i8* align 1 dereferenceable(71) getelementptr inbounds ([71 x i8], [71 x i8]* @.str.182, i64 0, i64 0), i64 71, i1 false)
%990 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%991 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %990
%992 = bitcast i8* %991 to i16*
store i16 10, i16* %992
%993 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%994 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %993
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(71) %994, i8* align 1 dereferenceable(71) getelementptr inbounds ([71 x i8], [71 x i8]* @.str.183, i64 0, i64 0), i64 71, i1 false)
%995 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%996 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %995
%997 = bitcast i8* %996 to i16*
store i16 10, i16* %997
%998 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%999 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %998
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(73) %999, i8* align 1 dereferenceable(73) getelementptr inbounds ([73 x i8], [73 x i8]* @.str.184, i64 0, i64 0), i64 73, i1 false)
%1000 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%1001 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %1000
%1002 = bitcast i8* %1001 to i16*
store i16 10, i16* %1002
%1003 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%1004 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %1003
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(69) %1004, i8* align 1 dereferenceable(69) getelementptr inbounds ([69 x i8], [69 x i8]* @.str.185, i64 0, i64 0), i64 69, i1 false)
%1005 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%1006 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %1005
%1007 = bitcast i8* %1006 to i16*
store i16 10, i16* %1007
%1008 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%1009 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %1008
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(74) %1009, i8* align 1 dereferenceable(74) getelementptr inbounds ([74 x i8], [74 x i8]* @.str.186, i64 0, i64 0), i64 74, i1 false)
%1010 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%1011 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %1010
%1012 = bitcast i8* %1011 to i16*
store i16 10, i16* %1012
%1013 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%1014 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %1013
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(77) %1014, i8* align 1 dereferenceable(77) getelementptr inbounds ([77 x i8], [77 x i8]* @.str.187, i64 0, i64 0), i64 77, i1 false)
%1015 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%1016 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %1015
%1017 = bitcast i8* %1016 to i16*
store i16 10, i16* %1017
%1018 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%1019 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %1018
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(12) %1019, i8* align 1 dereferenceable(12) getelementptr inbounds ([12 x i8], [12 x i8]* @.str.188, i64 0, i64 0), i64 12, i1 false)
%1020 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%1021 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %1020
%1022 = bitcast i8* %1021 to i16*
store i16 10, i16* %1022
%1023 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%1024 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %1023
%1025 = bitcast i8* %1024 to i16*
store i16 10, i16* %1025
%1026 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%1027 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %1026
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(70) %1027, i8* align 1 dereferenceable(70) getelementptr inbounds ([70 x i8], [70 x i8]* @.str.189, i64 0, i64 0), i64 70, i1 false)
%1028 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%1029 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %1028
%1030 = bitcast i8* %1029 to i16*
store i16 10, i16* %1030
%1031 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%1032 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %1031
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(74) %1032, i8* align 1 dereferenceable(74) getelementptr inbounds ([74 x i8], [74 x i8]* @.str.190, i64 0, i64 0), i64 74, i1 false)
%1033 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%1034 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %1033
%1035 = bitcast i8* %1034 to i16*
store i16 10, i16* %1035
%1036 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%1037 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %1036
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(70) %1037, i8* align 1 dereferenceable(70) getelementptr inbounds ([70 x i8], [70 x i8]* @.str.191, i64 0, i64 0), i64 70, i1 false)
%1038 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%1039 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %1038
%1040 = bitcast i8* %1039 to i16*
store i16 10, i16* %1040
%1041 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%1042 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %1041
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(73) %1042, i8* align 1 dereferenceable(73) getelementptr inbounds ([73 x i8], [73 x i8]* @.str.192, i64 0, i64 0), i64 73, i1 false)
%1043 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%1044 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %1043
%1045 = bitcast i8* %1044 to i16*
store i16 10, i16* %1045
%1046 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%1047 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %1046
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(72) %1047, i8* align 1 dereferenceable(72) getelementptr inbounds ([72 x i8], [72 x i8]* @.str.193, i64 0, i64 0), i64 72, i1 false)
%1048 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%1049 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %1048
%1050 = bitcast i8* %1049 to i16*
store i16 10, i16* %1050
%1051 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%1052 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %1051
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(74) %1052, i8* align 1 dereferenceable(74) getelementptr inbounds ([74 x i8], [74 x i8]* @.str.194, i64 0, i64 0), i64 74, i1 false)
%1053 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%1054 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %1053
%1055 = bitcast i8* %1054 to i16*
store i16 10, i16* %1055
%1056 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%1057 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %1056
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(58) %1057, i8* align 1 dereferenceable(58) getelementptr inbounds ([58 x i8], [58 x i8]* @.str.195, i64 0, i64 0), i64 58, i1 false)
%1058 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%1059 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %1058
%1060 = bitcast i8* %1059 to i16*
store i16 10, i16* %1060
%1061 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%1062 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %1061
%1063 = bitcast i8* %1062 to i16*
store i16 10, i16* %1063
%1064 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%1065 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %1064
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(35) %1065, i8* align 1 dereferenceable(35) getelementptr inbounds ([35 x i8], [35 x i8]* @.str.196, i64 0, i64 0), i64 35, i1 false)
%1066 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%1067 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %1066
%1068 = bitcast i8* %1067 to i16*
store i16 10, i16* %1068
%1069 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%1070 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %1069
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(50) %1070, i8* align 1 dereferenceable(50) getelementptr inbounds ([50 x i8], [50 x i8]* @.str.197, i64 0, i64 0), i64 50, i1 false)
br label %1071
1071: ; preds = %126, %2, %20
%1072 = tail call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
%1073 = getelementptr [20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 %1072
%1074 = bitcast i8* %1073 to i16*
store i16 10, i16* %1074
br label %1075
1075: ; preds = %1071, %1
%1076 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([20000 x i8], [20000 x i8]* @Copyright.information, i64 0, i64 0))
ret void
}