From 042a1a155ba67dba3e88dda9aeb70626649001bb Mon Sep 17 00:00:00 2001 From: Ben Boyter Date: Wed, 19 Jun 2024 10:12:42 +1000 Subject: [PATCH] tweaks --- LICENSE | 662 +++++++++++++++++- NOTES.md | 42 ++ go.mod | 3 +- go.sum | 4 + pkg/common.go | 96 +++ pkg/constants.go | 5 + pkg/detector.go | 112 +++ pkg/detector_test.go | 171 +++++ pkg/levenshtein/levenshtein.go | 257 +++++++ pkg/levenshtein/levenshtein_test.go | 296 ++++++++ pkg/license_test.go | 64 ++ .../github.com/boyter/gocodewalker/README.md | 39 +- vendor/github.com/boyter/gocodewalker/file.go | 108 ++- .../gocodewalker/go-gitignore/gitignore.go | 22 +- .../github.com/boyter/gocodewalker/hidden.go | 2 +- vendor/golang.org/x/sync/LICENSE | 27 + vendor/golang.org/x/sync/PATENTS | 22 + vendor/golang.org/x/sync/errgroup/errgroup.go | 135 ++++ vendor/golang.org/x/sync/errgroup/go120.go | 13 + .../golang.org/x/sync/errgroup/pre_go120.go | 14 + vendor/modules.txt | 5 +- 21 files changed, 2068 insertions(+), 31 deletions(-) create mode 100644 NOTES.md create mode 100644 pkg/common.go create mode 100644 pkg/constants.go create mode 100644 pkg/detector.go create mode 100644 pkg/detector_test.go create mode 100755 pkg/levenshtein/levenshtein.go create mode 100755 pkg/levenshtein/levenshtein_test.go create mode 100644 pkg/license_test.go create mode 100644 vendor/golang.org/x/sync/LICENSE create mode 100644 vendor/golang.org/x/sync/PATENTS create mode 100644 vendor/golang.org/x/sync/errgroup/errgroup.go create mode 100644 vendor/golang.org/x/sync/errgroup/go120.go create mode 100644 vendor/golang.org/x/sync/errgroup/pre_go120.go diff --git a/LICENSE b/LICENSE index f3374c9..bae94e1 100644 --- a/LICENSE +++ b/LICENSE @@ -1,7 +1,661 @@ -MIT License Copyright (c) 2021 Ben Boyter + GNU AFFERO GENERAL PUBLIC LICENSE + Version 3, 19 November 2007 -Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. -The above copyright notice and this permission notice (including the next paragraph) shall be included in all copies or substantial portions of the Software. + Preamble -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. \ No newline at end of file + The GNU Affero General Public License is a free, copyleft license for +software and other kinds of works, specifically designed to ensure +cooperation with the community in the case of network server software. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +our General Public Licenses are intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + Developers that use our General Public Licenses protect your rights +with two steps: (1) assert copyright on the software, and (2) offer +you this License which gives you legal permission to copy, distribute +and/or modify the software. + + A secondary benefit of defending all users' freedom is that +improvements made in alternate versions of the program, if they +receive widespread use, become available for other developers to +incorporate. Many developers of free software are heartened and +encouraged by the resulting cooperation. However, in the case of +software used on network servers, this result may fail to come about. +The GNU General Public License permits making a modified version and +letting the public access it on a server without ever releasing its +source code to the public. + + The GNU Affero General Public License is designed specifically to +ensure that, in such cases, the modified source code becomes available +to the community. It requires the operator of a network server to +provide the source code of the modified version running there to the +users of that server. Therefore, public use of a modified version, on +a publicly accessible server, gives the public access to the source +code of the modified version. + + An older license, called the Affero General Public License and +published by Affero, was designed to accomplish similar goals. This is +a different license, not a version of the Affero GPL, but Affero has +released a new version of the Affero GPL which permits relicensing under +this license. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU Affero General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Remote Network Interaction; Use with the GNU General Public License. + + Notwithstanding any other provision of this License, if you modify the +Program, your modified version must prominently offer all users +interacting with it remotely through a computer network (if your version +supports such interaction) an opportunity to receive the Corresponding +Source of your version by providing access to the Corresponding Source +from a network server at no charge, through some standard or customary +means of facilitating copying of software. This Corresponding Source +shall include the Corresponding Source for any work covered by version 3 +of the GNU General Public License that is incorporated pursuant to the +following paragraph. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the work with which it is combined will remain governed by version +3 of the GNU General Public License. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU Affero General Public License from time to time. Such new versions +will be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU Affero General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU Affero General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU Affero General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If your software can interact with users remotely through a computer +network, you should also make sure that it provides a way for users to +get its source. For example, if your program is a web application, its +interface could display a "Source" link that leads users to an archive +of the code. There are many ways you could offer source, and different +solutions will be better for different programs; see section 13 for the +specific requirements. + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU AGPL, see +. \ No newline at end of file diff --git a/NOTES.md b/NOTES.md new file mode 100644 index 0000000..6c52930 --- /dev/null +++ b/NOTES.md @@ -0,0 +1,42 @@ +Detection Rules +--------------- + +Check the filename + + "li[cs]en[cs]e(s?)", + "legal", + "copy(left|right|ing)", + "unlicense", + "l?gpl([-_ v]?)(\\d\\.?\\d)?", + "bsd", + "mit", + "apache", + +If it falls into one of the above, its highly likely it is a licence, +and should be tested. Note that the name itself highly indicates the +licence itself, with unlicense for example indicating it is the unlicnse. + +Something like licence, legal, or copy(left|right|ing) needs to be checked +because while it is highly likely to have a licence we cannot be sure +as to which licence it actually is. Its also possible that these examples +could have multiple licenses in them. Example github.com/valkey/valkey/COPYING + + "", + ".md", + ".rst", + ".html", + ".txt", + +Where the file matchs the above patterns, where it has has no extention or +one of the others we should inspect it to see if it has a license. Its possible +a licence exists here, but we cannot be sure. Note that its possible there are multiple +licences in the file which needs to be dealt with. + + // SPDX-License-Identifier: MIT OR Unlicense + +For all other files, there are a few possibilities. +The first is that it contains a SPDX header such as the above which indicates +which license the file is under. Its also possible that the header will contain +a full copy of another licence such as MIT, GPL or otherwise. Possibly inside a comment +or a long string declaration in the case of code. Its possible it has multiple. + diff --git a/go.mod b/go.mod index 0ea72c8..6bdade9 100644 --- a/go.mod +++ b/go.mod @@ -4,7 +4,7 @@ go 1.20 require ( github.com/BobuSumisu/aho-corasick v1.0.3 - github.com/boyter/gocodewalker v1.1.0 + github.com/boyter/gocodewalker v1.3.3 github.com/spf13/cobra v1.0.0 github.com/tealeg/xlsx v1.0.3 github.com/texttheater/golang-levenshtein v0.0.0-20180516184445-d188e65d659e @@ -14,4 +14,5 @@ require ( github.com/danwakefield/fnmatch v0.0.0-20160403171240-cbb64ac3d964 // indirect github.com/inconshreveable/mousetrap v1.0.0 // indirect github.com/spf13/pflag v1.0.5 // indirect + golang.org/x/sync v0.7.0 // indirect ) diff --git a/go.sum b/go.sum index 407250e..7cddf7b 100644 --- a/go.sum +++ b/go.sum @@ -12,6 +12,8 @@ github.com/boyter/gocodewalker v1.0.1-0.20230321052529-86e91fcf4a3a h1:/r8uPJqza github.com/boyter/gocodewalker v1.0.1-0.20230321052529-86e91fcf4a3a/go.mod h1:CppTdM9RtednxKPcit+Zn36FXqwYaDIGufs/tenbswo= github.com/boyter/gocodewalker v1.1.0 h1:R/BOXRB5WcE5x/Q6Ln95GUQOQE4PAk86nq6WccZqZmM= github.com/boyter/gocodewalker v1.1.0/go.mod h1:CppTdM9RtednxKPcit+Zn36FXqwYaDIGufs/tenbswo= +github.com/boyter/gocodewalker v1.3.3 h1:yPSbWT1wGmPSC73jASY0GaJu4EDN3FROfwYUDQjTmuE= +github.com/boyter/gocodewalker v1.3.3/go.mod h1:hXG8xzR1uURS+99P5/3xh3uWHjaV2XfoMMmvPyhrCDg= github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc= github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw= github.com/coreos/bbolt v1.3.2/go.mod h1:iRUV2dpdMOn7Bo10OQBFzIJO9kkE559Wcmn+qkEiiKk= @@ -118,6 +120,8 @@ golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAG golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M= +golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20181107165924-66b7b1311ac8/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= diff --git a/pkg/common.go b/pkg/common.go new file mode 100644 index 0000000..53f110c --- /dev/null +++ b/pkg/common.go @@ -0,0 +1,96 @@ +// SPDX-License-Identifier: AGPL-3.0 + +package pkg + +import ( + "fmt" + "regexp" + "strings" +) + +var commonLicences = []string{"MIT", "Apache-2.0", "GPL-3.0", "AGPL-3.0", "BSD-3-Clause", "GPL-2.0", "BSD-2-Clause", "CC0-1.0", "LGPL-3.0", "LGPL-2.1", "ISC", "0BSD", "LGPL-2.0", "Unlicense", "BSD-3-Clause-No-Nuclear-License-2014", "MPL-2.0", "EPL-1.0", "MPL-2.0-no-copyleft-exception", "AGPL-1.0", "CC-BY-4.0", "IPL-1.0", "CPL-1.0", "CC-BY-3.0", "CC-BY-SA-4.0", "WTFPL", "Zlib", "CC-BY-SA-3.0", "Cube", "JSON", "BitTorrent-1.0"} + +// Lifted from https://github.com/go-enry/go-license-detector/blob/580c5627556917dee649cdb2b179cb42d6c56a60/licensedb/internal/investigation.go#L29 +// SPDX-License-Identifier: Apache-2.0 +var ( + // Base names of guessable license files + licenseFileNames = []string{ + "li[cs]en[cs]e(s?)", + "legal", + "copy(left|right|ing)", + "unlicense", + "l?gpl([-_ v]?)(\\d\\.?\\d)?", + "bsd", + "mit", + "apache", + } + + // License file extensions. Combined with the fileNames slice + // to create a set of files we can reasonably assume contain + // licensing information. + fileExtensions = []string{ + "", + ".md", + ".rst", + ".html", + ".txt", + } + + licenseFileRe = regexp.MustCompile( + fmt.Sprintf("^(|.*[-_. ])(%s)(|[-_. ].*)$", + strings.Join(licenseFileNames, "|"))) + + readmeFileRe = regexp.MustCompile(fmt.Sprintf("^(readme|guidelines)(%s)$", + strings.Replace(strings.Join(fileExtensions, "|"), ".", "\\.", -1))) +) + +func IsLicenceFile(filename string) bool { + // attempt to filter out false positives that come from java due to filenames + if strings.Count(filename, ".") > 2 { + return false + } + + return licenseFileRe.Match([]byte(strings.ToLower(filename))) +} + +func IsReadmeFile(filename string) bool { + return readmeFileRe.Match([]byte(strings.ToLower(filename))) +} + +func compareOptimize(input string) string { + tokens := strings.Fields(input) + var sb strings.Builder + skipTokens := map[string]struct{}{} + for i := 0; i < len(tokens); i++ { + tok := tokens[i] + foundLonger := false + + // if we have already looked at this token, skip it, important for performance + _, ok := skipTokens[tok] + if ok { + continue + } + skipTokens[tok] = struct{}{} + + for j := i; j < len(tokens); j++ { + tok2 := tokens[j] + if tok == tok2 { + continue + } + + if len(tok2) <= len(tok) { + continue + } + + if strings.Contains(tok2, tok) { + foundLonger = true + } + } + + if !foundLonger { + sb.WriteString(tok) + } + } + + return sb.String() +} diff --git a/pkg/constants.go b/pkg/constants.go new file mode 100644 index 0000000..b8b3be6 --- /dev/null +++ b/pkg/constants.go @@ -0,0 +1,5 @@ +package pkg + +const ( + database_keywords = `[{"licenseTexts":["Copyright (C) 2006 by Rob Landley \u003crob@landley.net\u003e\n\nPermission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE."],"licenseIds":["0BSD"],"keywords":["2006 by rob","by rob landley","rob landley rob","landley rob landley","rob landley net","landley net permission","net permission to","hereby granted the","granted the software","author disclaims all","c 2006 by rob","2006 by rob landley","by rob landley rob","rob landley rob landley","landley rob landley net","rob landley net permission","landley net permission to","net permission to use","is hereby granted the","hereby granted the software","granted the software is","is and the author","and the author disclaims","the author disclaims all","author disclaims all warranties","copyright c 2006 by rob","c 2006 by rob landley","2006 by rob landley rob","by rob landley rob landley","rob landley rob landley net","landley rob landley net permission","rob landley net permission to","landley net permission to use","net permission to use copy","fee is hereby granted the","is hereby granted the software","hereby granted the software is","granted the software is provided","provided as is and the","as is and the author","is and the author disclaims","and the author disclaims all","the author disclaims all warranties","author disclaims all warranties with"]},{"licenseTexts":["Attribution Assurance License Copyright (c) 2002 by AUTHOR PROFESSIONAL IDENTIFICATION * URL \"PROMOTIONAL SLOGAN FOR AUTHOR'S PROFESSIONAL PRACTICE\"\n\nAll Rights Reserved ATTRIBUTION ASSURANCE LICENSE (adapted from the original BSD license)\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the conditions below are met. These conditions require a modest attribution to \u003cAUTHOR\u003e (the \"Author\"), who hopes that its promotional value may help justify the thousands of dollars in otherwise billable time invested in writing this and other freely available, open-source software.\n\n   1. Redistributions of source code, in whole or part and with or without modification (the \"Code\"), must prominently display this GPG-signed text in verifiable form.\n\n   2. Redistributions of the Code in binary form must be accompanied by this GPG-signed text in any documentation and, each time the resulting executable program or a program dependent thereon is launched, a prominent display (e.g., splash screen or banner text) of the Author's attribution information, which includes:\n\n      (a) Name (\"AUTHOR\"),\n\n      (b) Professional identification (\"PROFESSIONAL IDENTIFICATION\"), and\n\n      (c) URL (\"URL\").\n\n   3. Neither the name nor any trademark of the Author may be used to endorse or promote products derived from this software without specific prior written permission.\n\n   4. Users are entirely responsible, to the exclusion of the Author and any other persons, for compliance with (1) regulations set by owners or administrators of employed equipment, (2) licensing terms of any other software, and (3) local regulations regarding use, including those regarding import, export, and use of encryption software.\n\nTHIS FREE SOFTWARE IS PROVIDED BY THE AUTHOR \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR ANY CONTRIBUTOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, EFFECTS OF UNAUTHORIZED OR MALICIOUS NETWORK ACCESS; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."],"licenseIds":["AAL"],"keywords":["assurance license copyright","c 2002 by","2002 by author","by author professional","author professional identification","professional identification url","identification url promotional","url promotional slogan","promotional slogan for","slogan for author","for author s","author s professional","s professional practice","professional practice all","practice all rights","rights reserved attribution","reserved attribution assurance","assurance license adapted","license adapted from","adapted from the","the original bsd","original bsd license","bsd license redistribution","conditions below are","below are met","are met these","met these conditions","these conditions require","conditions require a","require a modest","attribution to author","to author the","author the author","the author who","author who hopes","who hopes that","hopes that its","justify the thousands","the thousands of","thousands of dollars","of dollars in","dollars in otherwise","in otherwise billable","otherwise billable time","billable time invested","time invested in","in writing this","writing this and","this and other","and other freely","other freely available","freely available open","available open source","source software 1","software 1 redistributions","or part and","part and with","modification the code","the code must","code must prominently","must prominently display","prominently display this","display this gpg","text in verifiable","in verifiable form","verifiable form 2","form 2 redistributions","the code in","code in binary","accompanied by this","by this gpg","text in any","documentation and each","and each time","time the resulting","resulting executable program","is launched a","launched a prominent","prominent display e","display e g","e g splash","g splash screen","splash screen or","screen or banner","or banner text","banner text of","author s attribution","attribution information which","information which includes","includes a name","a name author","name author b","author b professional","b professional identification","professional identification professional","identification professional identification","professional identification and","identification and c","and c url","c url url","url url 3","url 3 neither","the name nor","name nor any","nor any trademark","author may be","permission 4 users","4 users are","users are entirely","are entirely responsible","entirely responsible to","responsible to the","to the exclusion","exclusion of the","author and any","any other persons","persons for compliance","compliance with 1","with 1 regulations","1 regulations set","regulations set by","set by owners","by owners or","owners or administrators","or administrators of","administrators of employed","of employed equipment","employed equipment 2","equipment 2 licensing","2 licensing terms","licensing terms of","other software and","software and 3","and 3 local","3 local regulations","local regulations regarding","regulations regarding use","regarding use including","use including those","including those regarding","those regarding import","regarding import export","import export and","export and use","use of encryption","of encryption software","encryption software this","software this free","free software is","author or any","limited to effects","to effects of","effects of unauthorized","of unauthorized or","unauthorized or malicious","or malicious network","malicious network access","network access procurement","access procurement of","attribution assurance license copyright","assurance license copyright c","copyright c 2002 by","c 2002 by author","2002 by author professional","by author professional identification","author professional identification url","professional identification url promotional","identification url promotional slogan","url promotional slogan for","promotional slogan for author","slogan for author s","for author s professional","author s professional practice","s professional practice all","professional practice all rights","practice all rights reserved","all rights reserved attribution","rights reserved attribution assurance","reserved attribution assurance license","attribution assurance license adapted","assurance license adapted from","license adapted from the","adapted from the original","from the original bsd","the original bsd license","original bsd license redistribution","bsd license redistribution and","provided that the conditions","the conditions below are","conditions below are met","below are met these","are met these conditions","met these conditions require","these conditions require a","conditions require a modest","require a modest attribution","modest attribution to author","attribution to author the","to author the author","author the author who"]},{"licenseTexts":["This software code is made available \"AS IS\" without warranties of any kind. You may copy, display, modify and redistribute the software code either by itself or as incorporated into your code; provided that you do not remove any proprietary notices. Your use of this software code is at your own risk and you waive any claim against Amazon Digital Services, Inc. or its affiliates with respect to your use of this software code. (c) 2006 Amazon Digital Services, Inc. or its affiliates."],"licenseIds":["ADSL"],"keywords":["is without warranties","any kind you","kind you may","may copy display","copy display modify","display modify and","the software code","software code either","code either by","or as incorporated","incorporated into your","into your code","your code provided","do not remove","remove any proprietary","any proprietary notices","proprietary notices your","notices your use","code is at","risk and you","any claim against","claim against amazon","against amazon digital","its affiliates with","affiliates with respect","respect to your","software code c","code c 2006","c 2006 amazon","2006 amazon digital","software code is made","code is made available","available as is without","as is without warranties","is without warranties of","of any kind you","any kind you may","kind you may copy","you may copy display","may copy display modify","copy display modify and","display modify and redistribute","redistribute the software code","the software code either","software code either by","code either by itself","itself or as incorporated","or as incorporated into","as incorporated into your","incorporated into your code","into your code provided","your code provided that","you do not remove","do not remove any","not remove any proprietary","remove any proprietary notices","any proprietary notices your","proprietary notices your use","notices your use of","software code is at","code is at your","is at your own","your own risk and","own risk and you","risk and you waive","waive any claim against","any claim against amazon","claim against amazon digital","against amazon digital services","or its affiliates with","its affiliates with respect","affiliates with respect to","with respect to your","respect to your use","this software code c","software code c 2006","code c 2006 amazon","c 2006 amazon digital","2006 amazon digital services","this software code is made","software code is made available","code is made available as","made available as is without","available as is without warranties","as is without warranties of","is without warranties of any","warranties of any kind you","of any kind you may","any kind you may copy","kind you may copy display","you may copy display modify","may copy display modify and","copy display modify and redistribute","display modify and redistribute the","and redistribute the software code","redistribute the software code either","the software code either by","software code either by itself","code either by itself or","by itself or as incorporated","itself or as incorporated into","or as incorporated into your","as incorporated into your code","incorporated into your code provided","into your code provided that","your code provided that you","code provided that you do","that you do not remove","you do not remove any","do not remove any proprietary","not remove any proprietary notices","remove any proprietary notices your","any proprietary notices your use","proprietary notices your use of","notices your use of this","of this software code is","this software code is at","software code is at your","code is at your own","is at your own risk","at your own risk and","your own risk and you","own risk and you waive","risk and you waive any","you waive any claim against","waive any claim against amazon","any claim against amazon digital","claim against amazon digital services","against amazon digital services inc","inc or its affiliates with","or its affiliates with respect","its affiliates with respect to","affiliates with respect to your","with respect to your use","respect to your use of","to your use of this","of this software code c","this software code c 2006","software code c 2006 amazon","code c 2006 amazon digital","c 2006 amazon digital services","2006 amazon digital services inc"]},{"licenseTexts":["Academic Free License\n\nVersion 1.1 The Academic Free License applies to any original work of authorship (the \"Original Work\") whose owner (the \"Licensor\") has placed the following notice immediately following the copyright notice for the Original Work:\n\n\"Licensed under the Academic Free License version 1.1.\"\n\nGrant of License. Licensor hereby grants to any person obtaining a copy of the Original Work (\"You\") a world-wide, royalty-free, non-exclusive, perpetual, non-sublicenseable license\n\n   (1) to use, copy, modify, merge, publish, perform, distribute and/or sell copies of the Original Work and derivative works thereof, and\n\n   (2) under patent claims owned or controlled by the Licensor that are embodied in the Original Work as furnished by the Licensor, to make, use, sell and offer for sale the Original Work and derivative works thereof, subject to the following conditions.\n\nRight of Attribution. Redistributions of the Original Work must reproduce all copyright notices in the Original Work as furnished by the Licensor, both in the Original Work itself and in any documentation and/or other materials provided with the distribution of the Original Work in executable form.\n\nExclusions from License Grant. Neither the names of Licensor, nor the names of any contributors to the Original Work, nor any of their trademarks or service marks, may be used to endorse or promote products derived from this Original Work without express prior written permission of the Licensor.\n\nWARRANTY AND DISCLAIMERS. LICENSOR WARRANTS THAT THE COPYRIGHT IN AND TO THE ORIGINAL WORK IS OWNED BY THE LICENSOR OR THAT THE ORIGINAL WORK IS DISTRIBUTED BY LICENSOR UNDER A VALID CURRENT LICENSE FROM THE COPYRIGHT OWNER. EXCEPT AS EXPRESSLY STATED IN THE IMMEDIATELY PRECEEDING SENTENCE, THE ORIGINAL WORK IS PROVIDED UNDER THIS LICENSE ON AN \"AS IS\" BASIS, WITHOUT WARRANTY, EITHER EXPRESS OR IMPLIED, INCLUDING, WITHOUT LIMITATION, THE WARRANTY OF NON-INFRINGEMENT AND WARRANTIES THAT THE ORIGINAL WORK IS MERCHANTABLE OR FIT FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY OF THE ORIGINAL WORK IS WITH YOU. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. NO LICENSE TO ORIGINAL WORK IS GRANTED HEREUNDER EXCEPT UNDER THIS DISCLAIMER.\n\nLIMITATION OF LIABILITY. UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER TORT (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL THE LICENSOR BE LIABLE TO ANY PERSON FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER ARISING AS A RESULT OF THIS LICENSE OR THE USE OF THE ORIGINAL WORK INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, COMPUTER FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER COMMERCIAL DAMAGES OR LOSSES, EVEN IF SUCH PERSON SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF LIABILITY SHALL NOT APPLY TO LIABILITY FOR DEATH OR PERSONAL INJURY RESULTING FROM SUCH PARTY'S NEGLIGENCE TO THE EXTENT APPLICABLE LAW PROHIBITS SUCH LIMITATION. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OR LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THIS EXCLUSION AND LIMITATION MAY NOT APPLY TO YOU.\n\nLicense to Source Code. The term \"Source Code\" means the preferred form of the Original Work for making modifications to it and all available documentation describing how to access and modify the Original Work. Licensor hereby agrees to provide a machine-readable copy of the Source Code of the Original Work along with each copy of the Original Work that Licensor distributes. Licensor reserves the right to satisfy this obligation by placing a machine-readable copy of the Source Code in an information repository reasonably calculated to permit inexpensive and convenient access by You for as long as Licensor continues to distribute the Original Work, and by publishing the address of that information repository in a notice immediately following the copyright notice that applies to the Original Work.\n\nMutual Termination for Patent Action. This License shall terminate automatically and You may no longer exercise any of the rights granted to You by this License if You file a lawsuit in any court alleging that any OSI Certified open source software that is licensed under any license containing this \"Mutual Termination for Patent Action\" clause infringes any patent claims that are essential to use that software.\n\nThis license is Copyright (C) 2002 Lawrence E. Rosen. All rights reserved.\n\nPermission is hereby granted to copy and distribute this license without modification. This license may not be modified without the express written permission of its copyright owner."],"licenseIds":["AFL-1.1"],"keywords":["1 the academic","following conditions right","conditions right of","right of attribution","of attribution redistributions","attribution redistributions of","work must reproduce","must reproduce all","reproduce all copyright","the licensor both","licensor both in","original work itself","work itself and","itself and in","work in executable","executable form exclusions","form exclusions from","warranty and disclaimers","and disclaimers licensor","disclaimers licensor warrants","that software this","1 1 the academic","1 the academic free","version 1 1 grant","the following conditions right","following conditions right of","conditions right of attribution","right of attribution redistributions","of attribution redistributions of","attribution redistributions of the","redistributions of the original","original work must reproduce","work must reproduce all","must reproduce all copyright","reproduce all copyright notices","all copyright notices in","by the licensor both","the licensor both in","licensor both in the","both in the original","the original work itself","original work itself and","work itself and in","itself and in any","and in any documentation","any documentation and or","with the distribution of","original work in executable","work in executable form","in executable form exclusions","executable form exclusions from","form exclusions from license","licensor warranty and disclaimers","warranty and disclaimers licensor","and disclaimers licensor warrants","disclaimers licensor warrants that","use that software this","that software this license","software this license is","version 1 1 the academic","1 1 the academic free","1 the academic free license","the academic free license applies","license version 1 1 grant","version 1 1 grant of","1 1 grant of license","1 grant of license licensor","to the following conditions right","the following conditions right of","following conditions right of attribution","conditions right of attribution redistributions","right of attribution redistributions of","of attribution redistributions of the","attribution redistributions of the original","redistributions of the original work","the original work must reproduce","original work must reproduce all","work must reproduce all copyright","must reproduce all copyright notices","reproduce all copyright notices in","all copyright notices in the","copyright notices in the original","notices in the original work","furnished by the licensor both","by the licensor both in","the licensor both in the","licensor both in the original","both in the original work","in the original work itself","the original work itself and","original work itself and in","work itself and in any","itself and in any documentation","and in any documentation and","in any documentation and or","any documentation and or other","provided with the distribution of","with the distribution of the","of the original work in","the original work in executable","original work in executable form","work in executable form exclusions","in executable form exclusions from","executable form exclusions from license","form exclusions from license grant","the licensor warranty and disclaimers","licensor warranty and disclaimers licensor","warranty and disclaimers licensor warrants","and disclaimers licensor warrants that","disclaimers licensor warrants that the","to use that software this","use that software this license","that software this license is","software this license is copyright"]},{"licenseTexts":["Academic Free License\n\nVersion 1.2 This Academic Free License applies to any original work of authorship (the \"Original Work\") whose owner (the \"Licensor\") has placed the following notice immediately following the copyright notice for the Original Work:\n\nLicensed under the Academic Free License version 1.2\n\nGrant of License. Licensor hereby grants to any person obtaining a copy of the Original Work (\"You\") a world-wide, royalty-free, non-exclusive, perpetual, non-sublicenseable license (1) to use, copy, modify, merge, publish, perform, distribute and/or sell copies of the Original Work and derivative works thereof, and (2) under patent claims owned or controlled by the Licensor that are embodied in the Original Work as furnished by the Licensor, to make, use, sell and offer for sale the Original Work and derivative works thereof, subject to the following conditions.\n\nAttribution Rights. You must retain, in the Source Code of any Derivative Works that You create, all copyright, patent or trademark notices from the Source Code of the Original Work, as well as any notices of licensing and any descriptive text identified therein as an \"Attribution Notice.\" You must cause the Source Code for any Derivative Works that You create to carry a prominent Attribution Notice reasonably calculated to inform recipients that You have modified the Original Work.\n\nExclusions from License Grant. Neither the names of Licensor, nor the names of any contributors to the Original Work, nor any of their trademarks or service marks, may be used to endorse or promote products derived from this Original Work without express prior written permission of the Licensor.\n\nWarranty and Disclaimer of Warranty. Licensor warrants that the copyright in and to the Original Work is owned by the Licensor or that the Original Work is distributed by Licensor under a valid current license from the copyright owner. Except as expressly stated in the immediately proceeding sentence, the Original Work is provided under this License on an \"AS IS\" BASIS and WITHOUT WARRANTY, either express or implied, including, without limitation, the warranties of NON-INFRINGEMENT, MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY OF THE ORIGINAL WORK IS WITH YOU. This DISCLAIMER OF WARRANTY constitutes an essential part of this License. No license to Original Work is granted hereunder except under this disclaimer.\n\nLimitation of Liability. Under no circumstances and under no legal theory, whether in tort (including negligence), contract, or otherwise, shall the Licensor be liable to any person for any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or the use of the Original Work including, without limitation, damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses. This limitation of liability shall not apply to liability for death or personal injury resulting from Licensor's negligence to the extent applicable law prohibits such limitation. Some jurisdictions do not allow the exclusion or limitation of incidental or consequential damages, so this exclusion and limitation may not apply to You.\n\nLicense to Source Code. The term \"Source Code\" means the preferred form of the Original Work for making modifications to it and all available documentation describing how to modify the Original Work. Licensor hereby agrees to provide a machine-readable copy of the Source Code of the Original Work along with each copy of the Original Work that Licensor distributes. Licensor reserves the right to satisfy this obligation by placing a machine-readable copy of the Source Code in an information repository reasonably calculated to permit inexpensive and convenient access by You for as long as Licensor continues to distribute the Original Work, and by publishing the address of that information repository in a notice immediately following the copyright notice that applies to the Original Work.\n\nMutual Termination for Patent Action. This License shall terminate automatically and You may no longer exercise any of the rights granted to You by this License if You file a lawsuit in any court alleging that any OSI Certified open source software that is licensed under any license containing this \"Mutual Termination for Patent Action\" clause infringes any patent claims that are essential to use that software.\n\nRight to Use. You may use the Original Work in all ways not otherwise restricted or conditioned by this License or by law, and Licensor promises not to interfere with or be responsible for such uses by You.\n\nThis license is Copyright (C) 2002 Lawrence E. Rosen. All rights reserved.\n\nPermission is hereby granted to copy and distribute this license without modification. This license may not be modified without the express written permission of its copyright owner."],"licenseIds":["AFL-1.2"],"keywords":["1 2 this","2 this academic","1 2 grant","following conditions attribution","conditions attribution rights","original work exclusions","work exclusions from","that software right","software right to","version 1 2 this","1 2 this academic","2 this academic free","version 1 2 grant","1 2 grant of","the following conditions attribution","following conditions attribution rights","conditions attribution rights you","the original work exclusions","original work exclusions from","work exclusions from license","licensor warranty and disclaimer","use that software right","that software right to","software right to use","license version 1 2 this","version 1 2 this academic","1 2 this academic free","2 this academic free license","this academic free license applies","license version 1 2 grant","version 1 2 grant of","1 2 grant of license","2 grant of license licensor","to the following conditions attribution","the following conditions attribution rights","following conditions attribution rights you","conditions attribution rights you must","modified the original work exclusions","the original work exclusions from","original work exclusions from license","work exclusions from license grant","the licensor warranty and disclaimer","licensor warranty and disclaimer of","to use that software right","use that software right to","that software right to use","software right to use you"]},{"licenseTexts":["The Academic Free License\n\nv. 2.0 This Academic Free License (the \"License\") applies to any original work of authorship (the \"Original Work\") whose owner (the \"Licensor\") has placed the following notice immediately following the copyright notice for the Original Work:\n\nLicensed under the Academic Free License version 2.0\n\n   1) Grant of Copyright License. Licensor hereby grants You a world-wide, royalty-free, non-exclusive, perpetual, sublicenseable license to do the following:\n\n      a) to reproduce the Original Work in copies;\n\n      b) to prepare derivative works (\"Derivative Works\") based upon the Original Work;\n\n      c) to distribute copies of the Original Work and Derivative Works to the public;\n\n      d) to perform the Original Work publicly; and\n\n      e) to display the Original Work publicly.\n\n   2) Grant of Patent License. Licensor hereby grants You a world-wide, royalty-free, non-exclusive, perpetual, sublicenseable license, under patent claims owned or controlled by the Licensor that are embodied in the Original Work as furnished by the Licensor, to make, use, sell and offer for sale the Original Work and Derivative Works.\n\n   3) Grant of Source Code License. The term \"Source Code\" means the preferred form of the Original Work for making modifications to it and all available documentation describing how to modify the Original Work. Licensor hereby agrees to provide a machine-readable copy of the Source Code of the Original Work along with each copy of the Original Work that Licensor distributes. Licensor reserves the right to satisfy this obligation by placing a machine-readable copy of the Source Code in an information repository reasonably calculated to permit inexpensive and convenient access by You for as long as Licensor continues to distribute the Original Work, and by publishing the address of that information repository in a notice immediately following the copyright notice that applies to the Original Work.\n\n   4) Exclusions From License Grant. Neither the names of Licensor, nor the names of any contributors to the Original Work, nor any of their trademarks or service marks, may be used to endorse or promote products derived from this Original Work without express prior written permission of the Licensor. Nothing in this License shall be deemed to grant any rights to trademarks, copyrights, patents, trade secrets or any other intellectual property of Licensor except as expressly stated herein. No patent license is granted to make, use, sell or offer to sell embodiments of any patent claims other than the licensed claims defined in Section 2. No right is granted to the trademarks of Licensor even if such marks are included in the Original Work. Nothing in this License shall be interpreted to prohibit Licensor from licensing under different terms from this License any Original Work that Licensor otherwise would have a right to license.\n\n   5) This section intentionally omitted.\n\n   6) Attribution Rights. You must retain, in the Source Code of any Derivative Works that You create, all copyright, patent or trademark notices from the Source Code of the Original Work, as well as any notices of licensing and any descriptive text identified therein as an \"Attribution Notice.\" You must cause the Source Code for any Derivative Works that You create to carry a prominent Attribution Notice reasonably calculated to inform recipients that You have modified the Original Work.\n\n   7) Warranty of Provenance and Disclaimer of Warranty. Licensor warrants that the copyright in and to the Original Work and the patent rights granted herein by Licensor are owned by the Licensor or are sublicensed to You under the terms of this License with the permission of the contributor(s) of those copyrights and patent rights. Except as expressly stated in the immediately proceeding sentence, the Original Work is provided under this License on an \"AS IS\" BASIS and WITHOUT WARRANTY, either express or implied, including, without limitation, the warranties of NON-INFRINGEMENT, MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY OF THE ORIGINAL WORK IS WITH YOU. This DISCLAIMER OF WARRANTY constitutes an essential part of this License. No license to Original Work is granted hereunder except under this disclaimer.\n\n   8) Limitation of Liability. Under no circumstances and under no legal theory, whether in tort (including negligence), contract, or otherwise, shall the Licensor be liable to any person for any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or the use of the Original Work including, without limitation, damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses. This limitation of liability shall not apply to liability for death or personal injury resulting from Licensor's negligence to the extent applicable law prohibits such limitation. Some jurisdictions do not allow the exclusion or limitation of incidental or consequential damages, so this exclusion and limitation may not apply to You.\n\n   9) Acceptance and Termination. If You distribute copies of the Original Work or a Derivative Work, You must make a reasonable effort under the circumstances to obtain the express assent of recipients to the terms of this License. Nothing else but this License (or another written agreement between Licensor and You) grants You permission to create Derivative Works based upon the Original Work or to exercise any of the rights granted in Section 1 herein, and any attempt to do so except under the terms of this License (or another written agreement between Licensor and You) is expressly prohibited by U.S. copyright law, the equivalent laws of other countries, and by international treaty. Therefore, by exercising any of the rights granted to You in Section 1 herein, You indicate Your acceptance of this License and all of its terms and conditions.\n\n   10) Termination for Patent Action. This License shall terminate automatically and You may no longer exercise any of the rights granted to You by this License as of the date You commence an action, including a cross-claim or counterclaim, for patent infringement (i) against Licensor with respect to a patent applicable to software or (ii) against any entity with respect to a patent applicable to the Original Work (but excluding combinations of the Original Work with other software or hardware).\n\n   11) Jurisdiction, Venue and Governing Law. Any action or suit relating to this License may be brought only in the courts of a jurisdiction wherein the Licensor resides or in which Licensor conducts its primary business, and under the laws of that jurisdiction excluding its conflict-of-law provisions. The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded. Any use of the Original Work outside the scope of this License or after its termination shall be subject to the requirements and penalties of the U.S. Copyright Act, 17 U.S.C. ¤ 101 et seq., the equivalent laws of other countries, and international treaty. This section shall survive the termination of this License.\n\n   12) Attorneys Fees. In any action to enforce the terms of this License or seeking damages relating thereto, the prevailing party shall be entitled to recover its costs and expenses, including, without limitation, reasonable attorneys' fees and costs incurred in connection with such action, including any appeal of such action. This section shall survive the termination of this License.\n\n   13) Miscellaneous. This License represents the complete agreement concerning the subject matter hereof. If any provision of this License is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable.\n\n   14) Definition of \"You\" in This License. \"You\" throughout this License, whether in upper or lower case, means an individual or a legal entity exercising rights under, and complying with all of the terms of, this License. For legal entities, \"You\" includes any entity that controls, is controlled by, or is under common control with you. For purposes of this definition, \"control\" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.\n\n   15) Right to Use. You may use the Original Work in all ways not otherwise restricted or conditioned by this License or by law, and Licensor promises not to interfere with or be responsible for such uses by You.\n\nThis license is Copyright (C) 2003 Lawrence E. Rosen. All rights reserved.\n\nPermission is hereby granted to copy and distribute this license without modification. This license may not be modified without the express written permission of its copyright owner."],"licenseIds":["AFL-2.0"],"keywords":["2 0 this academic","free license v 2 0","v 2 0 this academic","2 0 this academic free","free license version 2 0"]},{"licenseTexts":["The Academic Free License\n\nv.2.1 This Academic Free License (the \"License\") applies to any original work of authorship (the \"Original Work\") whose owner (the \"Licensor\") has placed the following notice immediately following the copyright notice for the Original Work:\n\nLicensed under the Academic Free License version 2.1\n\n   1) Grant of Copyright License. Licensor hereby grants You a world-wide, royalty-free, non-exclusive, perpetual, sublicenseable license to do the following:\n\n      a) to reproduce the Original Work in copies;\n\n      b) to prepare derivative works (\"Derivative Works\") based upon the Original Work;\n\n      c) to distribute copies of the Original Work and Derivative Works to the public;\n\n      d) to perform the Original Work publicly; and\n\n      e) to display the Original Work publicly.\n\n   2) Grant of Patent License. Licensor hereby grants You a world-wide, royalty-free, non-exclusive, perpetual, sublicenseable license, under patent claims owned or controlled by the Licensor that are embodied in the Original Work as furnished by the Licensor, to make, use, sell and offer for sale the Original Work and Derivative Works.\n\n   3) Grant of Source Code License. The term \"Source Code\" means the preferred form of the Original Work for making modifications to it and all available documentation describing how to modify the Original Work. Licensor hereby agrees to provide a machine-readable copy of the Source Code of the Original Work along with each copy of the Original Work that Licensor distributes. Licensor reserves the right to satisfy this obligation by placing a machine-readable copy of the Source Code in an information repository reasonably calculated to permit inexpensive and convenient access by You for as long as Licensor continues to distribute the Original Work, and by publishing the address of that information repository in a notice immediately following the copyright notice that applies to the Original Work.\n\n   4) Exclusions From License Grant. Neither the names of Licensor, nor the names of any contributors to the Original Work, nor any of their trademarks or service marks, may be used to endorse or promote products derived from this Original Work without express prior written permission of the Licensor. Nothing in this License shall be deemed to grant any rights to trademarks, copyrights, patents, trade secrets or any other intellectual property of Licensor except as expressly stated herein. No patent license is granted to make, use, sell or offer to sell embodiments of any patent claims other than the licensed claims defined in Section 2. No right is granted to the trademarks of Licensor even if such marks are included in the Original Work. Nothing in this License shall be interpreted to prohibit Licensor from licensing under different terms from this License any Original Work that Licensor otherwise would have a right to license.\n\n   5) This section intentionally omitted.\n\n   6) Attribution Rights. You must retain, in the Source Code of any Derivative Works that You create, all copyright, patent or trademark notices from the Source Code of the Original Work, as well as any notices of licensing and any descriptive text identified therein as an \"Attribution Notice.\" You must cause the Source Code for any Derivative Works that You create to carry a prominent Attribution Notice reasonably calculated to inform recipients that You have modified the Original Work.\n\n   7) Warranty of Provenance and Disclaimer of Warranty. Licensor warrants that the copyright in and to the Original Work and the patent rights granted herein by Licensor are owned by the Licensor or are sublicensed to You under the terms of this License with the permission of the contributor(s) of those copyrights and patent rights. Except as expressly stated in the immediately proceeding sentence, the Original Work is provided under this License on an \"AS IS\" BASIS and WITHOUT WARRANTY, either express or implied, including, without limitation, the warranties of NON-INFRINGEMENT, MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY OF THE ORIGINAL WORK IS WITH YOU. This DISCLAIMER OF WARRANTY constitutes an essential part of this License. No license to Original Work is granted hereunder except under this disclaimer.\n\n   8) Limitation of Liability. Under no circumstances and under no legal theory, whether in tort (including negligence), contract, or otherwise, shall the Licensor be liable to any person for any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or the use of the Original Work including, without limitation, damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses. This limitation of liability shall not apply to liability for death or personal injury resulting from Licensor's negligence to the extent applicable law prohibits such limitation. Some jurisdictions do not allow the exclusion or limitation of incidental or consequential damages, so this exclusion and limitation may not apply to You.\n\n   9) Acceptance and Termination. If You distribute copies of the Original Work or a Derivative Work, You must make a reasonable effort under the circumstances to obtain the express assent of recipients to the terms of this License. Nothing else but this License (or another written agreement between Licensor and You) grants You permission to create Derivative Works based upon the Original Work or to exercise any of the rights granted in Section 1 herein, and any attempt to do so except under the terms of this License (or another written agreement between Licensor and You) is expressly prohibited by U.S. copyright law, the equivalent laws of other countries, and by international treaty. Therefore, by exercising any of the rights granted to You in Section 1 herein, You indicate Your acceptance of this License and all of its terms and conditions.\n\n   10) Termination for Patent Action. This License shall terminate automatically and You may no longer exercise any of the rights granted to You by this License as of the date You commence an action, including a cross-claim or counterclaim, against Licensor or any licensee alleging that the Original Work infringes a patent. This termination provision shall not apply for an action alleging patent infringement by combinations of the Original Work with other software or hardware.\n\n   11) Jurisdiction, Venue and Governing Law. Any action or suit relating to this License may be brought only in the courts of a jurisdiction wherein the Licensor resides or in which Licensor conducts its primary business, and under the laws of that jurisdiction excluding its conflict-of-law provisions. The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded. Any use of the Original Work outside the scope of this License or after its termination shall be subject to the requirements and penalties of the U.S. Copyright Act, 17 U.S.C. § 101 et seq., the equivalent laws of other countries, and international treaty. This section shall survive the termination of this License.\n\n   12) Attorneys Fees. In any action to enforce the terms of this License or seeking damages relating thereto, the prevailing party shall be entitled to recover its costs and expenses, including, without limitation, reasonable attorneys' fees and costs incurred in connection with such action, including any appeal of such action. This section shall survive the termination of this License.\n\n   13) Miscellaneous. This License represents the complete agreement concerning the subject matter hereof. If any provision of this License is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable.\n\n   14) Definition of \"You\" in This License. \"You\" throughout this License, whether in upper or lower case, means an individual or a legal entity exercising rights under, and complying with all of the terms of, this License. For legal entities, \"You\" includes any entity that controls, is controlled by, or is under common control with you. For purposes of this definition, \"control\" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.\n\n   15) Right to Use. You may use the Original Work in all ways not otherwise restricted or conditioned by this License or by law, and Licensor promises not to interfere with or be responsible for such uses by You.\n\nThis license is Copyright (C) 2003-2004 Lawrence E. Rosen. All rights reserved.\n\nPermission is hereby granted to copy and distribute this license without modification. This license may not be modified without the express written permission of its copyright owner."],"licenseIds":["AFL-2.1"],"keywords":["1 this academic","v 2 1 this","2 1 this academic","1 this academic free","free license v 2 1","license v 2 1 this","v 2 1 this academic","2 1 this academic free","1 this academic free license","free license version 2 1"]},{"licenseTexts":["Academic Free License (\"AFL\") v. 3.0 This Academic Free License (the \"License\") applies to any original work of authorship (the \"Original Work\") whose owner (the \"Licensor\") has placed the following licensing notice adjacent to the copyright notice for the Original Work:\n\nLicensed under the Academic Free License version 3.0\n\n   1) Grant of Copyright License. Licensor grants You a worldwide, royalty-free, non-exclusive, sublicensable license, for the duration of the copyright, to do the following:\n\n      a) to reproduce the Original Work in copies, either alone or as part of a collective work;\n\n      b) to translate, adapt, alter, transform, modify, or arrange the Original Work, thereby creating derivative works (\"Derivative Works\") based upon the Original Work;\n\n      c) to distribute or communicate copies of the Original Work and Derivative Works to the public, under any license of your choice that does not contradict the terms and conditions, including Licensor's reserved rights and remedies, in this Academic Free License;\n\n      d) to perform the Original Work publicly; and\n\n      e) to display the Original Work publicly.\n\n   2) Grant of Patent License. Licensor grants You a worldwide, royalty-free, non-exclusive, sublicensable license, under patent claims owned or controlled by the Licensor that are embodied in the Original Work as furnished by the Licensor, for the duration of the patents, to make, use, sell, offer for sale, have made, and import the Original Work and Derivative Works.\n\n   3) Grant of Source Code License. The term \"Source Code\" means the preferred form of the Original Work for making modifications to it and all available documentation describing how to modify the Original Work. Licensor agrees to provide a machine-readable copy of the Source Code of the Original Work along with each copy of the Original Work that Licensor distributes. Licensor reserves the right to satisfy this obligation by placing a machine-readable copy of the Source Code in an information repository reasonably calculated to permit inexpensive and convenient access by You for as long as Licensor continues to distribute the Original Work.\n\n   4) Exclusions From License Grant. Neither the names of Licensor, nor the names of any contributors to the Original Work, nor any of their trademarks or service marks, may be used to endorse or promote products derived from this Original Work without express prior permission of the Licensor. Except as expressly stated herein, nothing in this License grants any license to Licensor's trademarks, copyrights, patents, trade secrets or any other intellectual property. No patent license is granted to make, use, sell, offer for sale, have made, or import embodiments of any patent claims other than the licensed claims defined in Section 2. No license is granted to the trademarks of Licensor even if such marks are included in the Original Work. Nothing in this License shall be interpreted to prohibit Licensor from licensing under terms different from this License any Original Work that Licensor otherwise would have a right to license.\n\n   5) External Deployment. The term \"External Deployment\" means the use, distribution, or communication of the Original Work or Derivative Works in any way such that the Original Work or Derivative Works may be used by anyone other than You, whether those works are distributed or communicated to those persons or made available as an application intended for use over a network. As an express condition for the grants of license hereunder, You must treat any External Deployment by You of the Original Work or a Derivative Work as a distribution under section 1(c).\n\n   6) Attribution Rights. You must retain, in the Source Code of any Derivative Works that You create, all copyright, patent, or trademark notices from the Source Code of the Original Work, as well as any notices of licensing and any descriptive text identified therein as an \"Attribution Notice.\" You must cause the Source Code for any Derivative Works that You create to carry a prominent Attribution Notice reasonably calculated to inform recipients that You have modified the Original Work.\n\n   7) Warranty of Provenance and Disclaimer of Warranty. Licensor warrants that the copyright in and to the Original Work and the patent rights granted herein by Licensor are owned by the Licensor or are sublicensed to You under the terms of this License with the permission of the contributor(s) of those copyrights and patent rights. Except as expressly stated in the immediately preceding sentence, the Original Work is provided under this License on an \"AS IS\" BASIS and WITHOUT WARRANTY, either express or implied, including, without limitation, the warranties of non-infringement, merchantability or fitness for a particular purpose. THE ENTIRE RISK AS TO THE QUALITY OF THE ORIGINAL WORK IS WITH YOU. This DISCLAIMER OF WARRANTY constitutes an essential part of this License. No license to the Original Work is granted by this License except under this disclaimer.\n\n   8) Limitation of Liability. Under no circumstances and under no legal theory, whether in tort (including negligence), contract, or otherwise, shall the Licensor be liable to anyone for any indirect, special, incidental, or consequential damages of any character arising as a result of this License or the use of the Original Work including, without limitation, damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses. This limitation of liability shall not apply to the extent applicable law prohibits such limitation.\n\n   9) Acceptance and Termination. If, at any time, You expressly assented to this License, that assent indicates your clear and irrevocable acceptance of this License and all of its terms and conditions. If You distribute or communicate copies of the Original Work or a Derivative Work, You must make a reasonable effort under the circumstances to obtain the express assent of recipients to the terms of this License. This License conditions your rights to undertake the activities listed in Section 1, including your right to create Derivative Works based upon the Original Work, and doing so without honoring these terms and conditions is prohibited by copyright law and international treaty. Nothing in this License is intended to affect copyright exceptions and limitations (including \"fair use\" or \"fair dealing\"). This License shall terminate immediately and You may no longer exercise any of the rights granted to You by this License upon your failure to honor the conditions in Section 1(c).\n\n   10) Termination for Patent Action. This License shall terminate automatically and You may no longer exercise any of the rights granted to You by this License as of the date You commence an action, including a cross-claim or counterclaim, against Licensor or any licensee alleging that the Original Work infringes a patent. This termination provision shall not apply for an action alleging patent infringement by combinations of the Original Work with other software or hardware.\n\n   11) Jurisdiction, Venue and Governing Law. Any action or suit relating to this License may be brought only in the courts of a jurisdiction wherein the Licensor resides or in which Licensor conducts its primary business, and under the laws of that jurisdiction excluding its conflict-of-law provisions. The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded. Any use of the Original Work outside the scope of this License or after its termination shall be subject to the requirements and penalties of copyright or patent law in the appropriate jurisdiction. This section shall survive the termination of this License.\n\n   12) Attorneys' Fees. In any action to enforce the terms of this License or seeking damages relating thereto, the prevailing party shall be entitled to recover its costs and expenses, including, without limitation, reasonable attorneys' fees and costs incurred in connection with such action, including any appeal of such action. This section shall survive the termination of this License.\n\n   13) Miscellaneous. If any provision of this License is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable.\n\n   14) Definition of \"You\" in This License. \"You\" throughout this License, whether in upper or lower case, means an individual or a legal entity exercising rights under, and complying with all of the terms of, this License. For legal entities, \"You\" includes any entity that controls, is controlled by, or is under common control with you. For purposes of this definition, \"control\" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.\n\n   15) Right to Use. You may use the Original Work in all ways not otherwise restricted or conditioned by this License or by law, and Licensor promises not to interfere with or be responsible for such uses by You.\n\n   16) Modification of This License. This License is Copyright © 2005 Lawrence Rosen. Permission is granted to copy, distribute, or communicate this License without modification. Nothing in this License permits You to modify this License as applied to the Original Work or to Derivative Works. However, You may modify the text of this License and copy, distribute or communicate your modified version (the \"Modified License\") and apply it to other original works of authorship subject to the following conditions: (i) You may not indicate in any way that your Modified License is the \"Academic Free License\" or \"AFL\" and you may not use those names in the name of your Modified License; (ii) You must replace the notice specified in the first paragraph above with the notice \"Licensed under \u003cinsert your license name here\u003e\" or with a notice of your own that is not confusingly similar to the notice in this License; and (iii) You may not claim that your original works are open source software unless your Modified License has been approved by Open Source Initiative (OSI) and You comply with its license review and certification process."],"licenseIds":["AFL-3.0"],"keywords":["free license afl","license afl v","afl v 3","the public under","public under any","choice that does","does not contradict","not contradict the","contradict the terms","and conditions including","conditions including licensor","licensor s reserved","s reserved rights","reserved rights and","and remedies in","remedies in this","in this academic","free license d","is the academic","free license or","license or afl","or afl and","afl and you","academic free license afl","free license afl v","license afl v 3","afl v 3 0","v 3 0 this","3 0 this academic","free license version 3","to the public under","the public under any","public under any license","under any license of","any license of your","your choice that does","choice that does not","that does not contradict","does not contradict the","not contradict the terms","contradict the terms and","terms and conditions including","and conditions including licensor","conditions including licensor s","including licensor s reserved","licensor s reserved rights","s reserved rights and","reserved rights and remedies","rights and remedies in","and remedies in this","remedies in this academic","in this academic free","academic free license d","free license d to","license is the academic","is the academic free","academic free license or","free license or afl","license or afl and","or afl and you","afl and you may","academic free license afl v","free license afl v 3","license afl v 3 0","afl v 3 0 this","v 3 0 this academic","3 0 this academic free","academic free license version 3","free license version 3 0","works to the public under","to the public under any","the public under any license","public under any license of","under any license of your","any license of your choice","of your choice that does","your choice that does not","choice that does not contradict","that does not contradict the","does not contradict the terms","not contradict the terms and","contradict the terms and conditions","the terms and conditions including","terms and conditions including licensor","and conditions including licensor s","conditions including licensor s reserved","including licensor s reserved rights","licensor s reserved rights and","s reserved rights and remedies","reserved rights and remedies in","rights and remedies in this","and remedies in this academic","remedies in this academic free","in this academic free license","this academic free license d","academic free license d to","free license d to perform","modified license is the academic","license is the academic free","is the academic free license","the academic free license or","academic free license or afl","free license or afl and","license or afl and you","or afl and you may","afl and you may not"]},{"licenseTexts":["AFFERO GENERAL PUBLIC LICENSE\n\nVersion 1, March 2002\n\nCopyright © 2002 Affero Inc.\n\n510 Third Street - Suite 225, San Francisco, CA 94107, USA\n\nThis license is a modified version of the GNU General Public License copyright (C) 1989, 1991 Free Software Foundation, Inc. made with their permission. Section 2(d) has been added to cover use of software over a computer network.\n\nEveryone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.\n\nPreamble\n\nThe licenses for most software are designed to take away your freedom to share and change it. By contrast, the Affero General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This Public License applies to most of Affero's software and to any other program whose authors commit to using it. (Some other Affero software is covered by the GNU Library General Public License instead.) You can apply it to your programs, too.\n\nWhen we speak of free software, we are referring to freedom, not price. This General Public License is designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things.\n\nTo protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it.\n\nFor example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights.\n\nWe protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software.\n\nAlso, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations.\n\nFinally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all.\n\nThe precise terms and conditions for copying, distribution and modification follow.\n\nTERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION\n\n   0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this Affero General Public License. The \"Program\", below, refers to any such program or work, and a \"work based on the Program\" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term \"modification\".) Each licensee is addressed as \"you\".\n\n   Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does.\n\n   1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program.\n\n   You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee.\n\n   2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions:\n\n      a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change.\n\n      b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License.\n\n      c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.)\n\n      d) If the Program as you received it is intended to interact with users through a computer network and if, in the version you received, any user interacting with the Program was given the opportunity to request transmission to that user of the Program's complete source code, you must not remove that facility from your modified version of the Program or work based on the Program, and must offer an equivalent opportunity for all users interacting with your Program through a computer network to request immediate transmission by HTTP of the complete source code of your modified version or other derivative work.\n\n   These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it.\n\n   Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program.\n\n   In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License.\n\n   3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following:\n\n      a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or,\n\n      b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or,\n\n      c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.)\n\n   The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable.\n\n   If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code.\n\n   4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance.\n\n   5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it.\n\n   6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License.\n\n   7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program.\n\n   If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances.\n\n   It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice.\n\n   This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License.\n\n   8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License.\n\n   9. Affero Inc. may publish revised and/or new versions of the Affero General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.\n\n   Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and \"any later version\", you have the option of following the terms and conditions either of that version or of any later version published by Affero, Inc. If the Program does not specify a version number of this License, you may choose any version ever published by Affero, Inc.\n\n   You may also choose to redistribute modified versions of this program under any version of the Free Software Foundation's GNU General Public License version 3 or higher, so long as that version of the GNU GPL includes terms and conditions substantially equivalent to those of this license.\n\n   10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by Affero, Inc., write to us; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally.\n\n   NO WARRANTY\n\n   11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM \"AS IS\" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.\n\n   12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES."],"licenseIds":["AGPL-1.0-or-later","AGPL-1.0-only","AGPL-1.0"],"keywords":["version 1 march","1 march 2002","march 2002 copyright","copyright 2002 affero","2002 affero inc","affero inc 510","inc 510 third","510 third street","third street suite","street suite 225","suite 225 san","225 san francisco","san francisco ca","francisco ca 94107","ca 94107 usa","94107 usa this","usa this license","is a modified","foundation inc made","inc made with","made with their","with their permission","their permission section","permission section 2","section 2 d","2 d has","d has been","computer network everyone","network everyone is","contrast the affero","users this public","most of affero","of affero s","affero s software","some other affero","other affero software","affero software is","not price this","price this general","of this affero","this affero general","an announcement d","announcement d if","received it is","intended to interact","with users through","users through a","network and if","and if in","if in the","in the version","you received any","received any user","any user interacting","user interacting with","interacting with the","the program was","program was given","was given the","given the opportunity","opportunity to request","to request transmission","request transmission to","transmission to that","to that user","that user of","program s complete","must not remove","not remove that","remove that facility","that facility from","facility from your","or work based","program and must","and must offer","must offer an","offer an equivalent","an equivalent opportunity","equivalent opportunity for","opportunity for all","interacting with your","with your program","your program through","program through a","network to request","to request immediate","request immediate transmission","immediate transmission by","transmission by http","by http of","http of the","other derivative work","derivative work these","work these requirements","license 9 affero","9 affero inc","affero inc may","affero inc if","affero inc you","inc you may","choose to redistribute","to redistribute modified","redistribute modified versions","program under any","foundation s gnu","s gnu general","3 or higher","or higher so","higher so long","as that version","gnu gpl includes","gpl includes terms","includes terms and","and conditions substantially","conditions substantially equivalent","substantially equivalent to","equivalent to those","license 10 if","copyrighted by affero","affero inc write","inc write to","write to us","to us we","us we sometimes","license version 1 march","version 1 march 2002","1 march 2002 copyright","march 2002 copyright 2002","2002 copyright 2002 affero","copyright 2002 affero inc","2002 affero inc 510","affero inc 510 third","inc 510 third street","510 third street suite","third street suite 225","street suite 225 san","suite 225 san francisco","225 san francisco ca","san francisco ca 94107","francisco ca 94107 usa","ca 94107 usa this","94107 usa this license","usa this license is","license is a modified","is a modified version","public license copyright c","license copyright c 1989","software foundation inc made","foundation inc made with","inc made with their","made with their permission","with their permission section","their permission section 2","permission section 2 d","section 2 d has","2 d has been","d has been added","a computer network everyone","computer network everyone is","network everyone is permitted","by contrast the affero","contrast the affero general","its users this public","users this public license","to most of affero","most of affero s","of affero s software","affero s software and","it some other affero","some other affero software","other affero software is","affero software is covered","by the gnu library","freedom not price this","not price this general","price this general public","terms of this affero","of this affero general","this affero general public","print an announcement d","an announcement d if","announcement d if the","d if the program","you received it is","received it is intended","it is intended to","is intended to interact","intended to interact with","to interact with users","interact with users through","with users through a","users through a computer","computer network and if","network and if in","and if in the","if in the version","in the version you","version you received any","you received any user","received any user interacting"]},{"licenseTexts":["GNU AFFERO GENERAL PUBLIC LICENSE\n\nVersion 3, 19 November 2007\n\nCopyright (C) 2007 Free Software Foundation, Inc. \u003chttps://fsf.org/\u003e\n\nEveryone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.\n\nPreamble\n\nThe GNU Affero General Public License is a free, copyleft license for software and other kinds of works, specifically designed to ensure cooperation with the community in the case of network server software.\n\nThe licenses for most software and other practical works are designed to take away your freedom to share and change the works. By contrast, our General Public Licenses are intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users.\n\nWhen we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things.\n\nDevelopers that use our General Public Licenses protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License which gives you legal permission to copy, distribute and/or modify the software.\n\nA secondary benefit of defending all users' freedom is that improvements made in alternate versions of the program, if they receive widespread use, become available for other developers to incorporate. Many developers of free software are heartened and encouraged by the resulting cooperation. However, in the case of software used on network servers, this result may fail to come about. The GNU General Public License permits making a modified version and letting the public access it on a server without ever releasing its source code to the public.\n\nThe GNU Affero General Public License is designed specifically to ensure that, in such cases, the modified source code becomes available to the community. It requires the operator of a network server to provide the source code of the modified version running there to the users of that server. Therefore, public use of a modified version, on a publicly accessible server, gives the public access to the source code of the modified version.\n\nAn older license, called the Affero General Public License and published by Affero, was designed to accomplish similar goals. This is a different license, not a version of the Affero GPL, but Affero has released a new version of the Affero GPL which permits relicensing under this license.\n\nThe precise terms and conditions for copying, distribution and modification follow.\n\nTERMS AND CONDITIONS\n\n   0. Definitions.\n\n   \"This License\" refers to version 3 of the GNU Affero General Public License.\n\n   \"Copyright\" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks.\n\n   \"The Program\" refers to any copyrightable work licensed under this License. Each licensee is addressed as \"you\". \"Licensees\" and \"recipients\" may be individuals or organizations.\n\n   To \"modify\" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy. The resulting work is called a \"modified version\" of the earlier work or a work \"based on\" the earlier work.\n\n   A \"covered work\" means either the unmodified Program or a work based on the Program.\n\n   To \"propagate\" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy. Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well.\n\n   To \"convey\" a work means any kind of propagation that enables other parties to make or receive copies. Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying.\n\n   An interactive user interface displays \"Appropriate Legal Notices\" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License. If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion.\n\n   1. Source Code.\n\n   The \"source code\" for a work means the preferred form of the work for making modifications to it. \"Object code\" means any non-source form of a work.\n\n   A \"Standard Interface\" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language.\n\n   The \"System Libraries\" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form. A \"Major Component\", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it.\n\n   The \"Corresponding Source\" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities. However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work. For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those\n\n   subprograms and other parts of the work.\n\n   The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source.\n\n   The Corresponding Source for a work in source code form is that same work.\n\n   2. Basic Permissions.\n\n   All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met. This License explicitly affirms your unlimited permission to run the unmodified Program. The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work. This License acknowledges your rights of fair use or other equivalent, as provided by copyright law.\n\n   You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force. You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright. Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you.\n\n   Conveying under any other circumstances is permitted solely under the conditions stated below. Sublicensing is not allowed; section 10 makes it unnecessary.\n\n   3. Protecting Users' Legal Rights From Anti-Circumvention Law.\n\n   No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures.\n\n   When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures.\n\n   4. Conveying Verbatim Copies.\n\n   You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program.\n\n   You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee.\n\n   5. Conveying Modified Source Versions.\n\n   You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions:\n\n      a) The work must carry prominent notices stating that you modified it, and giving a relevant date.\n\n      b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7. This requirement modifies the requirement in section 4 to \"keep intact all notices\".\n\n      c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy. This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged. This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it.\n\n      d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so.\n\n   A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an \"aggregate\" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit. Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate.\n\n   6. Conveying Non-Source Forms.\n\n   You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways:\n\n      a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange.\n\n      b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge.\n\n      c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source. This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b.\n\n      d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge. You need not require recipients to copy the Corresponding Source along with the object code. If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source. Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements.\n\n      e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d.\n\n   A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work.\n\n   A \"User Product\" is either (1) a \"consumer product\", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling. In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage. For a particular product received by a particular user, \"normally used\" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product. A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product.\n\n   \"Installation Information\" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source. The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made.\n\n   If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information. But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM).\n\n   The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed. Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network.\n\n   Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying.\n\n   7. Additional Terms.\n\n   \"Additional permissions\" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law. If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions.\n\n   When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it. (Additional permissions may be written to require their own removal in certain cases when you modify the work.) You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission.\n\n   Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms:\n\n      a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or\n\n      b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or\n\n      c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or\n\n      d) Limiting the use for publicity purposes of names of licensors or authors of the material; or\n\n      e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or\n\n      f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors.\n\n   All other non-permissive additional terms are considered \"further restrictions\" within the meaning of section 10. If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term. If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying.\n\n   If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms.\n\n   Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way.\n\n   8. Termination.\n\n   You may not propagate or modify a covered work except as expressly provided under this License. Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11).\n\n   However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation.\n\n   Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice.\n\n   Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License. If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10.\n\n   9. Acceptance Not Required for Having Copies.\n\n   You are not required to accept this License in order to receive or run a copy of the Program. Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance. However, nothing other than this License grants you permission to propagate or modify any covered work. These actions infringe copyright if you do not accept this License. Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so.\n\n   10. Automatic Licensing of Downstream Recipients.\n\n   Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License. You are not responsible for enforcing compliance by third parties with this License.\n\n   An \"entity transaction\" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations. If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts.\n\n   You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License. For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it.\n\n   11. Patents.\n\n   A \"contributor\" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based. The work thus licensed is called the contributor's \"contributor version\".\n\n   A contributor's \"essential patent claims\" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version. For purposes of this definition, \"control\" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License.\n\n   Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version.\n\n   In the following three paragraphs, a \"patent license\" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to s ue for patent infringement). To \"grant\" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party.\n\n   If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent\n\n   license to downstream recipients. \"Knowingly relying\" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid.\n\n   If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it.\n\n   A patent license is \"discriminatory\" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License. You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007.\n\n   Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law.\n\n   12. No Surrender of Others' Freedom.\n\n   If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may\n\n   not convey it at all. For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program.\n\n   13. Remote Network Interaction; Use with the GNU General Public License.\n\n   Notwithstanding any other provision of this License, if you modify the Program, your modified version must prominently offer all users interacting with it remotely through a computer network (if your version supports such interaction) an opportunity to receive the Corresponding Source of your version by providing access to the Corresponding Source from a network server at no charge, through some standard or customary means of facilitating copying of software. This Corresponding Source shall include the Corresponding Source for any work covered by version 3 of the GNU General Public License that is incorporated pursuant to the following paragraph.\n\n   Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU General Public License into a single combined work, and to convey the resulting work. The terms of this License will continue to apply to the part which is the covered work, but the work with which it is combined will remain governed by version 3 of the GNU General Public License.\n\n   14. Revised Versions of this License.\n\n   The Free Software Foundation may publish revised and/or new versions of the GNU Affero General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.\n\n   Each version is given a distinguishing version number. If the Program specifies that a certain numbered version of the GNU Affero General Public License \"or any later version\" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of the GNU Affero General Public License, you may choose any version ever published by the Free Software Foundation.\n\n   If the Program specifies that a proxy can decide which future versions of the GNU Affero General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program.\n\n   Later license versions may give you additional or different permissions. However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version.\n\n   15. Disclaimer of Warranty.\n\n   THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM \"AS IS\" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.\n\n   16. Limitation of Liability.\n\n   IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\n   17. Interpretation of Sections 15 and 16.\n\n   If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee. END OF TERMS AND CONDITIONS\n\nHow to Apply These Terms to Your New Programs\n\nIf you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms.\n\nTo do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the \"copyright\" line and a pointer to where the full notice is found.\n\n\u003cone line to give the program's name and a brief idea of what it does.\u003e\n\nCopyright (C) \u003cyear\u003e \u003cname of author\u003e\n\nThis program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.\n\nThis program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.\n\nYou should have received a copy of the GNU Affero General Public License along with this program. If not, see \u003chttps://www.gnu.org/licenses/\u003e.\n\nAlso add information on how to contact you by electronic and paper mail.\n\nIf your software can interact with users remotely through a computer network, you should also make sure that it provides a way for users to get its source. For example, if your program is a web application, its interface could display a \"Source\" link that leads users to an archive of the code. There are many ways you could offer source, and different solutions will be better for different programs; see section 13 for the specific requirements.\n\nYou should also get your employer (if you work as a programmer) or school, if any, to sign a \"copyright disclaimer\" for the program, if necessary. For more information on this, and how to apply and follow the GNU AGPL, see \u003chttps://www.gnu.org/licenses/\u003e."],"licenseIds":["AGPL-3.0-or-later","AGPL-3.0-only","AGPL-3.0"],"keywords":["version 3 19","3 19 november","19 november 2007","november 2007 copyright","of works specifically","works specifically designed","designed to ensure","to ensure cooperation","ensure cooperation with","cooperation with the","with the community","the community in","community in the","case of network","of network server","network server software","server software the","software the licenses","its users when","users when we","these things developers","things developers that","that use our","use our general","public licenses protect","licenses protect your","software a secondary","a secondary benefit","secondary benefit of","benefit of defending","of defending all","defending all users","all users freedom","users freedom is","freedom is that","is that improvements","that improvements made","improvements made in","made in alternate","in alternate versions","alternate versions of","program if they","if they receive","they receive widespread","receive widespread use","widespread use become","use become available","become available for","available for other","for other developers","other developers to","developers to incorporate","to incorporate many","incorporate many developers","many developers of","developers of free","free software are","software are heartened","are heartened and","heartened and encouraged","and encouraged by","encouraged by the","by the resulting","the resulting cooperation","resulting cooperation however","cooperation however in","however in the","case of software","of software used","software used on","used on network","on network servers","network servers this","servers this result","this result may","result may fail","may fail to","fail to come","to come about","come about the","about the gnu","license permits making","permits making a","making a modified","version and letting","and letting the","letting the public","public access it","access it on","on a server","a server without","server without ever","without ever releasing","ever releasing its","releasing its source","public the gnu","is designed specifically","designed specifically to","specifically to ensure","that in such","such cases the","cases the modified","the modified source","source code becomes","code becomes available","becomes available to","community it requires","it requires the","requires the operator","operator of a","of a network","network server to","server to provide","modified version running","version running there","running there to","there to the","users of that","of that server","that server therefore","server therefore public","therefore public use","public use of","modified version on","version on a","publicly accessible server","accessible server gives","server gives the","gives the public","modified version an","version an older","an older license","older license called","license called the","called the affero","license and published","and published by","by affero was","affero was designed","was designed to","designed to accomplish","to accomplish similar","accomplish similar goals","similar goals this","goals this is","is a different","different license not","license not a","not a version","affero gpl but","gpl but affero","but affero has","affero has released","has released a","released a new","affero gpl which","gpl which permits","which permits relicensing","permits relicensing under","relicensing under this","license the precise","not to s","to s ue","s ue for","ue for patent","program 13 remote","13 remote network","remote network interaction","network interaction use","interaction use with","the program your","program your modified","version must prominently","must prominently offer","prominently offer all","offer all users","interacting with it","with it remotely","it remotely through","computer network if","network if your","if your version","your version supports","version supports such","supports such interaction","such interaction an","interaction an opportunity","an opportunity to","opportunity to receive","receive the corresponding","source of your","your version by","version by providing","by providing access","no charge through","charge through some","through some standard","means of facilitating","of facilitating copying","facilitating copying of"]},{"licenseTexts":["Copyright (c) 2006, 2007 Advanced Micro Devices, Inc.\n\nAll rights reserved.\n\nRedistribution and use in any form of this material and any product thereof including software in source or binary forms, along with any related documentation, with or without modification (\"this material\"), is permitted provided that the following conditions are met:\n\nRedistributions of source code of any software must retain the above copyright notice and all terms of this license as part of the code.\n\nRedistributions in binary form of any software must reproduce the above copyright notice and all terms of this license in any related documentation and/or other materials.\n\nNeither the names nor trademarks of Advanced Micro Devices, Inc. or any copyright holders or contributors may be used to endorse or promote products derived from this material without specific prior written permission.\n\nNotice about U.S. Government restricted rights: This material is provided with \"RESTRICTED RIGHTS.\" Use, duplication or disclosure by the U.S. Government is subject to the full extent of restrictions set forth in FAR52.227 and DFARS252.227 et seq., or any successor or applicable regulations. Use of this material by the U.S. Government constitutes acknowledgment of the proprietary rights of Advanced Micro Devices, Inc. and any copyright holders and contributors.\n\nANY BREACH OF ANY TERM OF THIS LICENSE SHALL RESULT IN THE IMMEDIATE REVOCATION OF ALL RIGHTS TO REDISTRIBUTE, ACCESS OR USE THIS MATERIAL.\n\nTHIS MATERIAL IS PROVIDED BY ADVANCED MICRO DEVICES, INC. AND ANY COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" IN ITS CURRENT CONDITION AND WITHOUT ANY REPRESENTATIONS, GUARANTEE, OR WARRANTY OF ANY KIND OR IN ANY WAY RELATED TO SUPPORT, INDEMNITY, ERROR FREE OR UNINTERRUPTED OPERATION, OR THAT IT IS FREE FROM DEFECTS OR VIRUSES. ALL OBLIGATIONS ARE HEREBY DISCLAIMED - WHETHER EXPRESS, IMPLIED, OR STATUTORY - INCLUDING, BUT NOT LIMITED TO, ANY IMPLIED WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, ACCURACY, COMPLETENESS, OPERABILITY, QUALITY OF SERVICE, OR NON-INFRINGEMENT. IN NO EVENT SHALL ADVANCED MICRO DEVICES, INC. OR ANY COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, PUNITIVE, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, REVENUE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED OR BASED ON ANY THEORY OF LIABILITY ARISING IN ANY WAY RELATED TO THIS MATERIAL, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. THE ENTIRE AND AGGREGATE LIABILITY OF ADVANCED MICRO DEVICES, INC. AND ANY COPYRIGHT HOLDERS AND CONTRIBUTORS SHALL NOT EXCEED TEN DOLLARS (US $10.00). ANYONE REDISTRIBUTING OR ACCESSING OR USING THIS MATERIAL ACCEPTS THIS ALLOCATION OF RISK AND AGREES TO RELEASE ADVANCED MICRO DEVICES, INC. AND ANY COPYRIGHT HOLDERS AND CONTRIBUTORS FROM ANY AND ALL LIABILITIES, OBLIGATIONS, CLAIMS, OR DEMANDS IN EXCESS OF TEN DOLLARS (US $10.00). THE FOREGOING ARE ESSENTIAL TERMS OF THIS LICENSE AND, IF ANY OF THESE TERMS ARE CONSTRUED AS UNENFORCEABLE, FAIL IN ESSENTIAL PURPOSE, OR BECOME VOID OR DETRIMENTAL TO ADVANCED MICRO DEVICES, INC. OR ANY COPYRIGHT HOLDERS OR CONTRIBUTORS FOR ANY REASON, THEN ALL RIGHTS TO REDISTRIBUTE, ACCESS OR USE THIS MATERIAL SHALL TERMINATE IMMEDIATELY. MOREOVER, THE FOREGOING SHALL SURVIVE ANY EXPIRATION OR TERMINATION OF THIS LICENSE OR ANY AGREEMENT OR ACCESS OR USE RELATED TO THIS MATERIAL.\n\nNOTICE IS HEREBY PROVIDED, AND BY REDISTRIBUTING OR ACCESSING OR USING THIS MATERIAL SUCH NOTICE IS ACKNOWLEDGED, THAT THIS MATERIAL MAY BE SUBJECT TO RESTRICTIONS UNDER THE LAWS AND REGULATIONS OF THE UNITED STATES OR OTHER COUNTRIES, WHICH INCLUDE BUT ARE NOT LIMITED TO, U.S. EXPORT CONTROL LAWS SUCH AS THE EXPORT ADMINISTRATION REGULATIONS AND NATIONAL SECURITY CONTROLS AS DEFINED THEREUNDER, AS WELL AS STATE DEPARTMENT CONTROLS UNDER THE U.S. MUNITIONS LIST. THIS MATERIAL MAY NOT BE USED, RELEASED, TRANSFERRED, IMPORTED, EXPORTED AND/OR RE- EXPORTED IN ANY MANNER PROHIBITED UNDER ANY APPLICABLE LAWS, INCLUDING U.S. EXPORT CONTROL LAWS REGARDING SPECIFICALLY DESIGNATED PERSONS, COUNTRIES AND NATIONALS OF COUNTRIES SUBJECT TO NATIONAL SECURITY CONTROLS. MOREOVER, THE FOREGOING SHALL SURVIVE ANY EXPIRATION OR TERMINATION OF ANY LICENSE OR AGREEMENT OR ACCESS OR USE RELATED TO THIS MATERIAL.\n\nThis license forms the entire agreement regarding the subject matter hereof and supersedes all proposals and prior discussions and writings between the parties with respect thereto. This license does not affect any ownership, rights, title, or interest in, or relating to, this material. No terms of this license can be modified or waived, and no breach of this license can be excused, unless done so in a writing signed by all affected parties. Each term of this license is separately enforceable. If any term of this license is determined to be or becomes unenforceable or illegal, such term shall be reformed to the minimum extent necessary in order for this license to remain in effect in accordance with its terms as modified by such reformation. This license shall be governed by and construed in accordance with the laws of the State of Texas without regard to rules on conflicts of law of any state or jurisdiction or the United Nations Convention on the International Sale of Goods. All disputes arising out of this license shall be subject to the jurisdiction of the federal and state courts in Austin, Texas, and all defenses are hereby waived concerning personal jurisdiction and venue of these courts."],"licenseIds":["AMDPLPA"],"keywords":["c 2006 2007","2006 2007 advanced","2007 advanced micro","devices inc all","this material and","and any product","any product thereof","product thereof including","thereof including software","including software in","binary forms along","forms along with","with any related","related documentation with","modification this material","material is permitted","software must retain","license as part","the code redistributions","code redistributions in","binary form of","software must reproduce","other materials neither","materials neither the","the names nor","names nor trademarks","nor trademarks of","trademarks of advanced","or contributors may","from this material","this material without","material without specific","written permission notice","permission notice about","notice about u","about u s","s government restricted","government restricted rights","restricted rights this","rights this material","restricted rights use","rights use duplication","full extent of","extent of restrictions","of restrictions set","forth in far52","in far52 227","far52 227 and","227 and dfars252","and dfars252 227","dfars252 227 et","227 et seq","et seq or","seq or any","or any successor","any successor or","successor or applicable","or applicable regulations","applicable regulations use","regulations use of","this material by","material by the","s government constitutes","government constitutes acknowledgment","constitutes acknowledgment of","acknowledgment of the","of the proprietary","the proprietary rights","proprietary rights of","rights of advanced","and contributors any","contributors any breach","license shall result","shall result in","result in the","in the immediate","the immediate revocation","immediate revocation of","revocation of all","material this material","provided by advanced","by advanced micro","as is in","is in its","its current condition","current condition and","condition and without","any representations guarantee","representations guarantee or","guarantee or warranty","kind or in","related to support","to support indemnity","support indemnity error","indemnity error free","free or uninterrupted","or uninterrupted operation","uninterrupted operation or","operation or that","or that it","free from defects","from defects or","defects or viruses","or viruses all","viruses all obligations","all obligations are","obligations are hereby","hereby disclaimed whether","disclaimed whether express","to any implied","particular purpose accuracy","purpose accuracy completeness","accuracy completeness operability","completeness operability quality","operability quality of","quality of service","service or non","event shall advanced","shall advanced micro","incidental special punitive","special punitive exemplary","of use revenue","use revenue data","revenue data or","however caused or","based on any","liability arising in","this material even","damage the entire","the entire and","entire and aggregate","and aggregate liability","aggregate liability of","liability of advanced","contributors shall not","not exceed ten","exceed ten dollars","10 00 anyone","00 anyone redistributing","anyone redistributing or","this material accepts","material accepts this","accepts this allocation","this allocation of","of risk and","risk and agrees","agrees to release","to release advanced","release advanced micro","and contributors from","contributors from any","from any and","and all liabilities","all liabilities obligations","liabilities obligations claims","obligations claims or","claims or demands","or demands in","demands in excess","excess of ten","10 00 the","00 the foregoing","the foregoing are","foregoing are essential","are essential terms","essential terms of","and if any","terms are construed","are construed as","construed as unenforceable","as unenforceable fail","unenforceable fail in","fail in essential","in essential purpose","essential purpose or","purpose or become","or become void","become void or","void or detrimental","or detrimental to","detrimental to advanced","to advanced micro","or contributors for","contributors for any","any reason then","reason then all","then all rights","this material shall","material shall terminate","terminate immediately moreover","immediately moreover the","or any agreement","any agreement or","this material notice","material notice is","notice is hereby","is hereby provided","hereby provided and","provided and by","and by redistributing"]},{"licenseTexts":["Copyright: Copyright (c) 2006 by Apple Computer, Inc., All Rights Reserved.\n\nIMPORTANT: This Apple software is supplied to you by Apple Computer, Inc. (\"Apple\") in consideration of your agreement to the following terms, and your use, installation, modification or redistribution of this Apple software constitutes acceptance of these terms. If you do not agree with these terms, please do not use, install, modify or redistribute this Apple software.\n\nIn consideration of your agreement to abide by the following terms, and subject to these terms, Apple grants you a personal, non-exclusive license, under Apple's copyrights in this original Apple software (the \"Apple Software\"), to use, reproduce, modify and redistribute the Apple Software, with or without modifications, in source and/or binary forms; provided that if you redistribute the Apple Software in its entirety and without modifications, you must retain this notice and the following text and disclaimers in all such redistributions of the Apple Software. Neither the name, trademarks, service marks or logos of Apple Computer, Inc. may be used to endorse or promote products derived from the Apple Software without specific prior written permission from Apple. Except as expressly stated in this notice, no other rights or licenses, express or implied, are granted by Apple herein, including but not limited to any patent rights that may be infringed by your derivative works or by other works in which the Apple Software may be incorporated.\n\nThe Apple Software is provided by Apple on an \"AS IS\" basis. APPLE MAKES NO WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND OPERATION ALONE OR IN COMBINATION WITH YOUR PRODUCTS.\n\nIN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."],"licenseIds":["AML"],"keywords":["copyright copyright c","2006 by apple","rights reserved important","reserved important this","important this apple","is supplied to","supplied to you","you by apple","inc apple in","apple in consideration","terms and your","and your use","your use installation","use installation modification","installation modification or","modification or redistribution","apple software constitutes","software constitutes acceptance","these terms if","terms if you","terms please do","not use install","use install modify","install modify or","or redistribute this","redistribute this apple","software in consideration","agreement to abide","terms and subject","these terms apple","terms apple grants","apple grants you","you a personal","a personal non","personal non exclusive","license under apple","under apple s","apple s copyrights","copyrights in this","in this original","this original apple","original apple software","apple software the","software the apple","apple software to","reproduce modify and","apple software with","binary forms provided","its entirety and","entirety and without","and without modifications","without modifications you","following text and","text and disclaimers","disclaimers in all","all such redistributions","such redistributions of","apple software neither","software neither the","the name trademarks","logos of apple","of apple computer","computer inc may","inc may be","from the apple","apple software without","permission from apple","from apple except","apple except as","this notice no","notice no other","or licenses express","licenses express or","apple herein including","herein including but","any patent rights","patent rights that","rights that may","may be infringed","by your derivative","works or by","by other works","which the apple","apple software may","may be incorporated","be incorporated the","incorporated the apple","by apple on","apple on an","is basis apple","basis apple makes","apple makes no","infringement merchantability and","particular purpose regarding","purpose regarding the","regarding the apple","apple software or","use and operation","and operation alone","operation alone or","combination with your","with your products","your products in","products in no","business interruption arising","interruption arising in","the use reproduction","modification and or","and or distribution","apple software however","software however caused","caused and whether","and whether under","whether under theory","under theory of","copyright copyright c 2006","c 2006 by apple","2006 by apple computer","all rights reserved important","rights reserved important this","reserved important this apple","important this apple software","this apple software is","apple software is supplied","software is supplied to","is supplied to you","supplied to you by","to you by apple","you by apple computer","computer inc apple in","inc apple in consideration","apple in consideration of","agreement to the following","following terms and your","terms and your use","and your use installation","your use installation modification","use installation modification or","installation modification or redistribution","modification or redistribution of","or redistribution of this","redistribution of this apple","of this apple software","this apple software constitutes","apple software constitutes acceptance","software constitutes acceptance of","constitutes acceptance of these","of these terms if","these terms if you","terms if you do","these terms please do","terms please do not","please do not use","do not use install","not use install modify","use install modify or","install modify or redistribute","modify or redistribute this","or redistribute this apple","redistribute this apple software","this apple software in","apple software in consideration","software in consideration of","your agreement to abide","agreement to abide by","abide by the following","following terms and subject","terms and subject to","and subject to these","to these terms apple","these terms apple grants","terms apple grants you","apple grants you a","grants you a personal","you a personal non","a personal non exclusive","personal non exclusive license","exclusive license under apple","license under apple s","under apple s copyrights","apple s copyrights in","s copyrights in this","copyrights in this original","in this original apple","this original apple software","original apple software the","apple software the apple","software the apple software","the apple software to","apple software to use","use reproduce modify and","reproduce modify and redistribute","and redistribute the apple","the apple software with","apple software with or","without modifications in source","modifications in source and","or binary forms provided","binary forms provided that","forms provided that if"]},{"licenseTexts":["Copyright (c) 2006 Academy of Motion Picture Arts and Sciences (\"A.M.P.A.S.\"). Portions contributed by others as indicated. All rights reserved.\n\nA world-wide, royalty-free, non-exclusive right to distribute, copy, modify, create derivatives, and use, in source and binary forms, is hereby granted, subject to acceptance of this license. Performance of any of the aforementioned acts indicates acceptance to be bound by the following terms and conditions:\n\n   * Redistributions of source code must retain the above copyright notice, this list of conditions and the Disclaimer of Warranty.\n\n   * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the Disclaimer of Warranty in the documentation and/or other materials provided with the distribution.\n\n   * Nothing in this license shall be deemed to grant any rights to trademarks, copyrights, patents, trade secrets or any other intellectual property of A.M.P.A.S. or any contributors, except as expressly stated herein, and neither the name of A.M.P.A.S. nor of any other contributors to this software, may be used to endorse or promote products derived from this software without specific prior written permission of A.M.P.A.S. or contributor, as appropriate.\n\nThis license shall be governed by the laws of the State of California, and subject to the jurisdiction of the courts therein.\n\nDisclaimer of Warranty: THIS SOFTWARE IS PROVIDED BY A.M.P.A.S. AND CONTRIBUTORS \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT ARE DISCLAIMED. IN NO EVENT SHALL A.M.P.A.S., ANY CONTRIBUTORS OR DISTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."],"licenseIds":["AMPAS"],"keywords":["c 2006 academy","2006 academy of","academy of motion","of motion picture","motion picture arts","picture arts and","arts and sciences","and sciences a","sciences a m","a s portions","s portions contributed","portions contributed by","contributed by others","by others as","others as indicated","as indicated all","indicated all rights","rights reserved a","reserved a world","non exclusive right","to distribute copy","distribute copy modify","copy modify create","create derivatives and","derivatives and use","forms is hereby","hereby granted subject","granted subject to","subject to acceptance","to acceptance of","this license performance","license performance of","the aforementioned acts","aforementioned acts indicates","acts indicates acceptance","indicates acceptance to","and conditions redistributions","of warranty redistributions","warranty redistributions in","of warranty in","warranty in the","the distribution nothing","distribution nothing in","property of a","any contributors except","contributors except as","herein and neither","and neither the","a s nor","s nor of","nor of any","any other contributors","other contributors to","contributors to this","permission of a","s or contributor","or contributor as","contributor as appropriate","appropriate this license","california and subject","the courts therein","courts therein disclaimer","therein disclaimer of","provided by a","by a m","a s and","s and contributors","event shall a","shall a m","a s any","s any contributors","any contributors or","contributors or distributors","copyright c 2006 academy","c 2006 academy of","2006 academy of motion","academy of motion picture","of motion picture arts","motion picture arts and","picture arts and sciences","arts and sciences a","and sciences a m","sciences a m p","p a s portions","a s portions contributed","s portions contributed by","portions contributed by others","contributed by others as","by others as indicated","others as indicated all","as indicated all rights","indicated all rights reserved","all rights reserved a","rights reserved a world","reserved a world wide","free non exclusive right","non exclusive right to","exclusive right to distribute","right to distribute copy","to distribute copy modify","distribute copy modify create","copy modify create derivatives","modify create derivatives and","create derivatives and use","derivatives and use in","binary forms is hereby","forms is hereby granted","is hereby granted subject","hereby granted subject to","granted subject to acceptance","subject to acceptance of","to acceptance of this","of this license performance","this license performance of","license performance of any","performance of any of","of the aforementioned acts","the aforementioned acts indicates","aforementioned acts indicates acceptance","acts indicates acceptance to","indicates acceptance to be","bound by the following","terms and conditions redistributions","and conditions redistributions of","disclaimer of warranty redistributions","of warranty redistributions in","warranty redistributions in binary","disclaimer of warranty in","of warranty in the","warranty in the documentation","with the distribution nothing","the distribution nothing in","distribution nothing in this","intellectual property of a","property of a m","a s or any","s or any contributors","or any contributors except","any contributors except as","contributors except as expressly","stated herein and neither","herein and neither the","and neither the name","name of a m","p a s nor","a s nor of","s nor of any","nor of any other","of any other contributors","any other contributors to","other contributors to this","contributors to this software","software may be used","written permission of a","permission of a m","a s or contributor","s or contributor as","or contributor as appropriate","contributor as appropriate this","as appropriate this license","appropriate this license shall","of california and subject","california and subject to","of the courts therein","the courts therein disclaimer","courts therein disclaimer of","therein disclaimer of warranty","is provided by a","provided by a m","by a m p","p a s and","a s and contributors","s and contributors as","no event shall a","event shall a m","shall a m p","p a s any","a s any contributors","s any contributors or","any contributors or distributors","contributors or distributors be","distributors be liable for","copyright c 2006 academy of","c 2006 academy of motion","2006 academy of motion picture","academy of motion picture arts","of motion picture arts and","motion picture arts and sciences","picture arts and sciences a","arts and sciences a m","and sciences a m p","sciences a m p a","m p a s portions","p a s portions contributed","a s portions contributed by","s portions contributed by others","portions contributed by others as","contributed by others as indicated","by others as indicated all","others as indicated all rights"]},{"licenseTexts":["ANTLR 2 License\n\nWe reserve no legal rights to the ANTLR--it is fully in the public domain. An individual or company may do whatever they wish with source code distributed with ANTLR or the code generated by ANTLR, including the incorporation of ANTLR, or its output, into commerical software.\n\nWe encourage users to develop software with ANTLR. However, we do ask that credit is given to us for developing ANTLR. By \"credit\", we mean that if you use ANTLR or incorporate any source code into one of your programs (commercial product, research project, or otherwise) that you acknowledge this fact somewhere in the documentation, research report, etc... If you like ANTLR and have developed a nice tool with the output, please mention that you developed it using ANTLR. In addition, we ask that the headers remain intact in our source code. As long as these guidelines are kept, we expect to continue enhancing this system and expect to make other tools available as they are completed."],"licenseIds":["ANTLR-PD"],"keywords":["antlr 2 license","2 license we","license we reserve","we reserve no","reserve no legal","no legal rights","to the antlr","the antlr it","antlr it is","it is fully","is fully in","fully in the","public domain an","domain an individual","individual or company","or company may","company may do","may do whatever","do whatever they","whatever they wish","they wish with","wish with source","code distributed with","distributed with antlr","with antlr or","antlr or the","or the code","the code generated","generated by antlr","by antlr including","antlr including the","including the incorporation","the incorporation of","incorporation of antlr","of antlr or","antlr or its","or its output","its output into","output into commerical","into commerical software","commerical software we","software we encourage","we encourage users","encourage users to","users to develop","to develop software","develop software with","software with antlr","with antlr however","antlr however we","however we do","we do ask","do ask that","ask that credit","that credit is","credit is given","given to us","to us for","us for developing","for developing antlr","developing antlr by","antlr by credit","by credit we","credit we mean","we mean that","mean that if","you use antlr","use antlr or","antlr or incorporate","or incorporate any","incorporate any source","source code into","code into one","into one of","of your programs","your programs commercial","programs commercial product","commercial product research","product research project","research project or","project or otherwise","that you acknowledge","you acknowledge this","acknowledge this fact","this fact somewhere","fact somewhere in","the documentation research","documentation research report","research report etc","report etc if","etc if you","you like antlr","like antlr and","antlr and have","and have developed","have developed a","developed a nice","a nice tool","nice tool with","tool with the","the output please","output please mention","please mention that","mention that you","that you developed","you developed it","developed it using","it using antlr","using antlr in","antlr in addition","addition we ask","we ask that","ask that the","that the headers","the headers remain","headers remain intact","intact in our","in our source","our source code","code as long","long as these","as these guidelines","these guidelines are","guidelines are kept","are kept we","kept we expect","we expect to","expect to continue","to continue enhancing","continue enhancing this","enhancing this system","this system and","system and expect","and expect to","expect to make","to make other","make other tools","other tools available","tools available as","available as they","they are completed","antlr 2 license we","2 license we reserve","license we reserve no","we reserve no legal","reserve no legal rights","no legal rights to","legal rights to the","rights to the antlr","to the antlr it","the antlr it is","antlr it is fully","it is fully in","is fully in the","fully in the public","the public domain an","public domain an individual","domain an individual or","an individual or company","individual or company may","or company may do","company may do whatever","may do whatever they","do whatever they wish","whatever they wish with","they wish with source","wish with source code","with source code distributed","source code distributed with","code distributed with antlr","distributed with antlr or","with antlr or the","antlr or the code","or the code generated","the code generated by","code generated by antlr","generated by antlr including","by antlr including the","antlr including the incorporation","including the incorporation of","the incorporation of antlr","incorporation of antlr or","of antlr or its","antlr or its output","or its output into","its output into commerical","output into commerical software","into commerical software we","commerical software we encourage","software we encourage users","we encourage users to","encourage users to develop","users to develop software","to develop software with","develop software with antlr","software with antlr however","with antlr however we","antlr however we do","however we do ask","we do ask that"]},{"licenseTexts":["Copyright (c) 1985, 1987, 1989, 1990, 1991, 1992, 1993, 1997 Adobe Systems Incorporated. All Rights Reserved.\n\nThis file and the 14 PostScript(R) AFM files it accompanies may be used, copied, and distributed for any purpose and without charge, with or without modification, provided that all copyright notices are retained; that the AFM files are not distributed without this file; that all modifications to this file or any of the AFM files are prominently noted in the modified file(s); and that this paragraph is not modified. Adobe Systems has no responsibility or obligation to support the use of the AFM files."],"licenseIds":["APAFML"],"keywords":["copyright c 1985","c 1985 1987","1985 1987 1989","1987 1989 1990","1989 1990 1991","1992 1993 1997","1993 1997 adobe","1997 adobe systems","and the 14","the 14 postscript","14 postscript r","postscript r afm","r afm files","afm files it","files it accompanies","it accompanies may","accompanies may be","be used copied","used copied and","and without charge","without charge with","charge with or","without modification provided","modification provided that","are retained that","retained that the","that the afm","are not distributed","not distributed without","distributed without this","without this file","this file that","file that all","file or any","files are prominently","are prominently noted","prominently noted in","modified file s","file s and","s and that","that this paragraph","paragraph is not","not modified adobe","modified adobe systems","adobe systems has","systems has no","has no responsibility","responsibility or obligation","or obligation to","obligation to support","support the use","copyright c 1985 1987","c 1985 1987 1989","1985 1987 1989 1990","1987 1989 1990 1991","1989 1990 1991 1992","1991 1992 1993 1997","1992 1993 1997 adobe","1993 1997 adobe systems","1997 adobe systems incorporated","reserved this file and","file and the 14","and the 14 postscript","the 14 postscript r","14 postscript r afm","postscript r afm files","r afm files it","afm files it accompanies","files it accompanies may","it accompanies may be","accompanies may be used","may be used copied","be used copied and","used copied and distributed","purpose and without charge","and without charge with","without charge with or","charge with or without","or without modification provided","without modification provided that","modification provided that all","that all copyright notices","notices are retained that","are retained that the","retained that the afm","that the afm files","afm files are not","files are not distributed","are not distributed without","not distributed without this","distributed without this file","without this file that","this file that all","file that all modifications","that all modifications to","all modifications to this","modifications to this file","to this file or","this file or any","file or any of","any of the afm","afm files are prominently","files are prominently noted","are prominently noted in","prominently noted in the","noted in the modified","the modified file s","modified file s and","file s and that","s and that this","and that this paragraph","that this paragraph is","this paragraph is not","paragraph is not modified","is not modified adobe","not modified adobe systems","modified adobe systems has","adobe systems has no","systems has no responsibility","has no responsibility or","no responsibility or obligation","responsibility or obligation to","or obligation to support","obligation to support the","to support the use","support the use of","use of the afm","copyright c 1985 1987 1989","c 1985 1987 1989 1990","1985 1987 1989 1990 1991","1987 1989 1990 1991 1992","1989 1990 1991 1992 1993","1990 1991 1992 1993 1997","1991 1992 1993 1997 adobe","1992 1993 1997 adobe systems","1993 1997 adobe systems incorporated","1997 adobe systems incorporated all","rights reserved this file and","reserved this file and the","this file and the 14","file and the 14 postscript","and the 14 postscript r","the 14 postscript r afm","14 postscript r afm files","postscript r afm files it","r afm files it accompanies","afm files it accompanies may","files it accompanies may be","it accompanies may be used","accompanies may be used copied","may be used copied and","be used copied and distributed","used copied and distributed for","distributed for any purpose and","any purpose and without charge","purpose and without charge with","and without charge with or","without charge with or without","charge with or without modification","with or without modification provided","or without modification provided that","without modification provided that all","modification provided that all copyright","provided that all copyright notices","that all copyright notices are","copyright notices are retained that","notices are retained that the","are retained that the afm","retained that the afm files","that the afm files are","the afm files are not","afm files are not distributed","files are not distributed without","are not distributed without this","not distributed without this file","distributed without this file that","without this file that all","this file that all modifications","file that all modifications to","that all modifications to this","all modifications to this file","modifications to this file or","to this file or any","this file or any of","file or any of the","or any of the afm","any of the afm files","of the afm files are","the afm files are prominently","afm files are prominently noted","files are prominently noted in","are prominently noted in the","prominently noted in the modified","noted in the modified file","in the modified file s","the modified file s and","modified file s and that","file s and that this","s and that this paragraph","and that this paragraph is"]},{"licenseTexts":["ADAPTIVE PUBLIC LICENSE\n\nVersion 1.0\n\nTHE LICENSED WORK IS PROVIDED UNDER THE TERMS OF THIS ADAPTIVE PUBLIC LICENSE (\"LICENSE\"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THE LICENSED WORK CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS LICENSE AND ITS TERMS, WHETHER OR NOT SUCH RECIPIENT READS THE TERMS OF THIS LICENSE. \"LICENSED WORK\" AND \"RECIPIENT\" ARE DEFINED BELOW.\n\nIMPORTANT NOTE: This License is \"adaptive\", and the generic version or another version of an Adaptive Public License should not be relied upon to determine your rights and obligations under this License. You must read the specific Adaptive Public License that you receive with the Licensed Work, as certain terms are defined at the outset by the Initial Contributor.\n\nSee Section 2.2 below, Exhibit A attached, and any Suppfile.txt accompanying this License to determine the specific adaptive features applicable to this License. For example, without limiting the foregoing, (a) for selected choice of law and jurisdiction see Part 3 of Exhibit A; (b) for the selected definition of Third Party see Part 4 of Exhibit A; and (c) for selected patent licensing terms (if any) see Section 2.2 below and Part 6 of Exhibit A.\n\n   1. DEFINITIONS.\n\n      1.1. \"CONTRIBUTION\" means:\n\n         (a) In the case of the Initial Contributor, the Initial Work distributed under this License by the Initial Contributor; and\n\n         (b) In the case of each Subsequent Contributor, the Subsequent Work originating from and distributed by such Subsequent Contributor.\n\n      1.2. \"DESIGNATED WEB SITE\" means the web site having the URL identified in Part 1 of Exhibit A, which URL may be changed by the Initial Contributor by posting on the current Designated Web Site the new URL for at least sixty (60) days.\n\n      1.3. \"DISTRIBUTOR\" means any Person that distributes the Licensed Work or any portion thereof to at least one Third Party.\n\n      1.4. \"ELECTRONIC DISTRIBUTION MECHANISM\" means any mechanism generally accepted in the software development community for the electronic transfer of data.\n\n      1.5. \"EXECUTABLE\" means the Licensed Work in any form other than Source Code.\n\n      1.6. \"GOVERNING JURISDICTION\" means the state, province or other legal jurisdiction identified in Part 3 of Exhibit A.\n\n      1.7. \"INDEPENDENT MODULE\" means a separate module of software and/or data that is not a derivative work of or copied from the Licensed Work or any portion thereof. In addition, a module does not qualify as an Independent Module but instead forms part of the Licensed Work if the module: (a) is embedded in the Licensed Work; (b) is included by reference in the Licensed Work other than by a function call or a class reference; or (c) must be included or contained, in whole or in part, within a file directory or subdirectory actually containing files making up the Licensed Work.\n\n      1.8. \"INITIAL CONTRIBUTOR\" means the Person or entity identified as the Initial Contributor in the notice required by Part 1 of Exhibit A.\n\n      1.9. \"INITIAL WORK\" means the initial Source Code, object code (if any) and documentation for the computer program identified in Part 2 of Exhibit A, as such Source Code, object code and documentation is distributed under this License by the Initial Contributor.\n\n      1.10. \"LARGER WORK\" means a work that combines the Licensed Work or portions thereof with code not governed by this License.\n\n      1.11. \"LICENSED WORK\" means the Initial Work and/or any Subsequent Work, in each case including portions thereof.\n\n      1.12. \"LICENSE NOTICE\" has the meaning assigned in Part 5 of Exhibit A.\n\n      1.13. \"MODIFICATION\" or \"MODIFICATIONS\" means any change to and/or addition to the Licensed Work.\n\n      1.14. \"PERSON\" means an individual or other legal entity, including a corporation, partnership or other body.\n\n      1.15. \"RECIPIENT\" means any Person who receives or obtains the Licensed Work under this License (by way of example, without limiting the foregoing, any Subsequent Contributor or Distributor).\n\n      1.16. \"SOURCE CODE\" means the source code for a computer program, including the source code for all modules and components of the computer program, plus any associated interface definition files, and scripts used to control compilation and installation of an executable.\n\n      1.17. \"SUBSEQUENT CONTRIBUTOR\" means any Person that makes or contributes to the making of any Subsequent Work and that distributes that Subsequent Work to at least one Third Party.\n\n      1.18. \"SUBSEQUENT WORK\" means a work that has resulted or arises from changes to and/or additions to:\n\n         (a) the Initial Work;\n\n         (b) any other Subsequent Work; or\n\n         (c) to any combination of the Initial Work and any such other Subsequent Work;\n\n         where such changes and/or additions originate from a Subsequent Contributor. A Subsequent Work will \"originate\" from a Subsequent Contributor if the Subsequent Work was a result of efforts by such Subsequent Contributor (or anyone acting on such Subsequent Contributor's behalf, such as, a contractor or other entity that is engaged by or under the direction of the Subsequent Contributor). For greater certainty, a Subsequent Work expressly excludes and shall not capture within its meaning any Independent Module.\n\n      1.19. \"SUPPLEMENT FILE\" means a file distributed with the Licensed Work having a file name \"suppfile.txt\".\n\n      1.20. \"THIRD PARTY\" has the meaning assigned in Part 4 of Exhibit A.\n\n   2. LICENSE.\n\n      2.1. COPYRIGHT LICENSE FROM INITIAL AND SUBSEQUENT CONTRIBUTORS.\n\n         (a) Subject to the terms of this License, the Initial Contributor hereby grants each Recipient a world-wide, royalty-free, non-exclusive copyright license to:\n\n            (i) reproduce, prepare derivative works of, publicly display, publicly perform, distribute and sublicense the Initial Work; and\n\n            (ii) reproduce, publicly display, publicly perform, distribute, and sublicense any derivative works (if any) prepared by Recipient;\n\n            in Source Code and Executable form, either with other Modifications, on an unmodified basis, or as part of a Larger Work.\n\n         (b) Subject to the terms of this License, each Subsequent Contributor hereby grants each Recipient a world-wide, royalty-free, non-exclusive copyright license to:\n\n            (i) reproduce, prepare derivative works of, publicly display, publicly perform, distribute and sublicense the Subsequent Work of such Subsequent Contributor; and\n\n            (ii) reproduce, publicly display, publicly perform, distribute, and sublicense any derivative works (if any) prepared by Recipient;\n\n            in Source Code and Executable form, either with other Modifications, on an unmodified basis, or as part of a Larger Work.\n\n      2.2. PATENT LICENSE FROM INITIAL AND SUBSEQUENT CONTRIBUTORS.\n\n         (a) This License does not include or grant any patent license whatsoever from the Initial Contributor, Subsequent Contributor, or any Distributor unless, at the time the Initial Work is first distributed or made available under this License (as the case may be), the Initial Contributor has selected pursuant to Part 6 of Exhibit A the patent terms in paragraphs A, B, C, D and E from Part 6 of Exhibit A. If this is not done then the Initial Work and any other Subsequent Work is made available under the License without any patent license (the \"PATENTS-EXCLUDED LICENSE\").\n\n         (b) However, the Initial Contributor may subsequently distribute or make available (as the case may be) future copies of: (1) the Initial Work; or (2) any Licensed Work distributed by the Initial Contributor which includes the Initial Work (or any portion thereof) and/or any Modification made by the Initial Contributor; available under a License which includes a patent license (the \"PATENTS-INCLUDED LICENSE\") by selecting pursuant to Part 6 of Exhibit A the patent terms in paragraphs A, B, C, D and E from Part 6 of Exhibit A, when the Initial Contributor distributes or makes available (as the case may be) such future copies under this License.\n\n         (c) If any Recipient receives or obtains one or more copies of the Initial Work or any other portion of the Licensed Work under the Patents-Included License, then all licensing of such copies under this License shall include the terms in paragraphs A, B, C, D and E from Part 6 of Exhibit A and that Recipient shall not be able to rely upon the Patents-Excluded License for any such copies. However, all Recipients that receive one or more copies of the Initial Work or any other portion of the Licensed Work under a copy of the License which includes the Patents-Excluded License shall have no patent license with respect to such copies received under the Patents-Excluded License and availability and distribution of such copies, including Modifications made by such Recipient to such copies, shall be under a copy of the License without any patent license.\n\n         (d) Where a Recipient uses in combination or combines any copy of the Licensed Work (or portion thereof) licensed under a copy of the License having a Patents-Excluded License with any copy of the Licensed Work (or portion thereof) licensed under a copy of the License having a Patents-Included License, the combination (and any portion thereof) shall, from the first time such Recipient uses, makes available or distributes the combination (as the case may be), be subject to only the terms of the License having the Patents-Included License which shall include the terms in paragraphs A, B, C, D and E from Part 6 of Exhibit A.\n\n      2.3. ACKNOWLEDGEMENT AND DISCLAIMER.\n\n      Recipient understands and agrees that although Initial Contributor and each Subsequent Contributor grants the licenses to its Contributions set forth herein, no representation, warranty, guarantee or assurance is provided by any Initial Contributor, Subsequent Contributor, or Distributor that the Licensed Work does not infringe the patent or other intellectual property rights of any other entity. Initial Contributor, Subsequent Contributor, and each Distributor disclaims any liability to Recipient for claims brought by any other entity based on infringement of intellectual property rights or otherwise, in relation to the Licensed Works. As a condition to exercising the rights and licenses granted hereunder, each Recipient hereby assumes sole responsibility to secure any other intellectual property rights needed, if any. For example, without limiting the foregoing disclaimers, if a third party patent license is required to allow Recipient to distribute the Licensed Work, it is Recipient's responsibility to acquire that license before distributing the Licensed Work.\n\n      2.4. RESERVATION.\n\n      Nothing in this License shall be deemed to grant any rights to trademarks, copyrights, patents, trade secrets or any other intellectual property of Initial Contributor, Subsequent Contributor, or Distributor except as expressly stated herein.\n\n   3. DISTRIBUTION OBLIGATIONS.\n\n      3.1. DISTRIBUTION GENERALLY.\n\n         (a) A Subsequent Contributor shall make that Subsequent Contributor's Subsequent Work(s) available to the public via an Electronic Distribution Mechanism for a period of at least twelve (12) months. The aforesaid twelve (12) month period shall begin within a reasonable time after the creation of the Subsequent Work and no later than sixty (60) days after first distribution of that Subsequent Contributor's Subsequent Work.\n\n         (b) All Distributors must distribute the Licensed Work in accordance with the terms of the License, and must include a copy of this License (including without limitation Exhibit A and the accompanying Supplement File) with each copy of the Licensed Work distributed. In particular, this License must be prominently distributed with the Licensed Work in a file called \"license.txt.\" In addition, the License Notice in Part 5 of Exhibit A must be included at the beginning of all Source Code files, and viewable to a user in any executable such that the License Notice is reasonably brought to the attention of any party using the Licensed Work.\n\n      3.2. EXECUTABLE DISTRIBUTIONS OF THE LICENSED WORK.\n\n      A Distributor may choose to distribute the Licensed Work, or any portion thereof, in Executable form (an \"EXECUTABLE DISTRIBUTION\") to any third party, under the terms of Section 2 of this License, provided the Executable Distribution is made available under and accompanied by a copy of this License, AND provided at least ONE of the following conditions is fulfilled:\n\n         (a) The Executable Distribution must be accompanied by the Source Code for the Licensed Work making up the Executable Distribution, and the Source Code must be distributed on the same media as the Executable Distribution or using an Electronic Distribution Mechanism; or\n\n         (b) The Executable Distribution must be accompanied with a written offer, valid for at least thirty six (36) months, to give any third party under the terms of this License, for a charge no more than the cost of physically performing source distribution, a complete machine-readable copy of the Source Code for the Licensed Work making up the Executable Distribution, to be available and distributed using an Electronic Distribution Mechanism, and such Executable Distribution must remain available in Source Code form to any third party via the Electronic Distribution Mechanism (or any replacement Electronic Distribution Mechanism the particular Distributor may reasonably need to turn to as a substitute) for said at least thirty six (36) months.\n\n      For greater certainty, the above-noted requirements apply to any Licensed Work or portion thereof distributed to any third party in Executable form, whether such distribution is made alone, in combination with a Larger Work or Independent Modules, or in some other combination.\n\n      3.3. SOURCE CODE DISTRIBUTIONS.\n\n      When a Distributor makes the Licensed Work, or any portion thereof, available to any Person in Source Code form, it must be made available under this License and a copy of this License must be included with each copy of the Source Code, situated so that the copy of the License is conspicuously brought to the attention of that Person. For greater clarification, this Section 3.3 applies to all distribution of the Licensed Work in any Source Code form. A Distributor may charge a fee for the physical act of transferring a copy, which charge shall be no more than the cost of physically performing source distribution.\n\n      3.4. REQUIRED NOTICES IN SOURCE CODE.\n\n      Each Subsequent Contributor must ensure that the notice set out in Part 5 of Exhibit A is included in each file of the Source Code for each Subsequent Work originating from that particular Subsequent Contributor, if such notice is not already included in each such file. If it is not possible to put such notice in a particular Source Code file due to its structure, then the Subsequent Contributor must include such notice in a location (such as a relevant directory in which the file is stored) where a user would be likely to look for such a notice.\n\n      3.5. NO DISTRIBUTION REQUIREMENTS FOR INTERNALLY USED MODIFICATIONS.\n\n      Notwithstanding Sections 3.2, 3.3 and 3.4, Recipient may, internally within its own corporation or organization use the Licensed Work, including the Initial Work and Subsequent Works, and make Modifications for internal use within Recipient's own corporation or organization (collectively, \"INTERNAL USE MODIFICATIONS\"). The Recipient shall have no obligation to distribute, in either Source Code or Executable form, any such Internal Use Modifications made by Recipient in the course of such internal use, except where required below in this Section 3.5. All Internal Use Modifications distributed to any Person, whether or not a Third Party, shall be distributed pursuant to and be accompanied by the terms of this License. If the Recipient chooses to distribute any such Internal Use Modifications to any Third Party, then the Recipient shall be deemed a Subsequent Contributor, and any such Internal Use Modifications distributed to any Third Party shall be deemed a Subsequent Work originating from that Subsequent Contributor, and shall from the first such instance become part of the Licensed Work that must thereafter be distributed and made available to third parties in accordance with the terms of Sections 3.1 to 3.4 inclusive.\n\n      3.6. INDEPENDENT MODULES.\n\n      This License shall not apply to Independent Modules of any Initial Contributor, Subsequent Contributor, Distributor or any Recipient, and such Independent Modules may be licensed or made available under one or more separate license agreements.\n\n      3.7. LARGER WORKS.\n\n      Any Distributor or Recipient may create or contribute to a Larger Work by combining any of the Licensed Work with other code not governed by the terms of this License, and may distribute the Larger Work as one or more products. However, in any such case, Distributor or Recipient (as the case may be) must make sure that the requirements of this License are fulfilled for the Licensed Work portion of the Larger Work.\n\n      3.8. DESCRIPTION OF DISTRIBUTED MODIFICATIONS.\n\n         (a) Each Subsequent Contributor (including the Initial Contributor where the Initial Contributor also qualifies as a Subsequent Contributor) must cause each Subsequent Work created or contributed to by that Subsequent Contributor to contain a file documenting the changes, in accordance with the requirements of Part 1 of the Supplement File, that such Subsequent Contributor made in the creation or contribution to that Subsequent Work. If no Supplement File exists or no requirements are set out in Part 1 of the Supplement File, then there are no requirements for Subsequent Contributors to document changes that they make resulting in Subsequent Works.\n\n         (b) The Initial Contributor may at any time introduce requirements or add to or change earlier requirements (in each case, the \"EARLIER DESCRIPTION REQUIREMENTS\") for documenting changes resulting in Subsequent Works by revising Part 1 of each copy of the Supplement File distributed by the Initial Contributor with future copies of the Licensed Work so that Part 1 then contains new requirements (the \"NEW DESCRIPTION REQUIREMENTS\") for documenting such changes.\n\n         (c) Any Recipient receiving at any time any copy of an Initial Work or any Subsequent Work under a copy of this License (in each case, an \"Earlier LICENSED COPY\") having the Earlier Description Requirements may choose, with respect to each such Earlier Licensed Copy, to comply with the Earlier Description Requirements or the New Description Requirements. Where a Recipient chooses to comply with the New Description Requirements, that Recipient will, when thereafter distributing any copies of any such Earlier Licensed Copy, include a Supplement File having a section entitled Part 1 that contains a copy of the New Description Requirements.\n\n         (d) For greater certainty, the intent of Part 1 of the Supplement File is to provide a mechanism (if any) by which Subsequent Contributors must document changes that they make to the Licensed Work resulting in Subsequent Works. Part 1 of any Supplement File shall not be used to increase or reduce the scope of the license granted in Article 2 of this License or in any other way increase or decrease the rights and obligations of any Recipient, and shall at no time serve as the basis for terminating the License. Further, a Recipient can be required to correct and change its documentation procedures to comply with Part 1 of the Supplement File, but cannot be penalised with damages. Part 1 of any Supplement File is only binding on each Recipient of any Licensed Work to the extent Part 1 sets out the requirements for documenting changes to the Initial Work or any Subsequent Work.\n\n         (e) An example of a set of requirements for documenting changes and contributions made by Subsequent Contributor is set out in Part 7 of Exhibit A of this License. Part 7 is a sample only and is not binding on Recipients, unless (subject to the earlier paragraphs of this Section 3.8) those are the requirements that the Initial Contributor includes in Part 1 of the Supplement File with the copies of the Initial Work distributed under this License.\n\n      3.9. USE OF DISTRIBUTOR NAME.\n\n      The name of a Distributor may not be used by any other Distributor to endorse or promote the Licensed Work or products derived from the Licensed Work, without prior written permission.\n\n      3.10. LIMITED RECOGNITION OF INITIAL CONTRIBUTOR.\n\n         (a) As a modest attribution to the Initial Contributor, in the hope that its promotional value may help justify the time, money and effort invested in writing the Initial Work, the Initial Contributor may include in Part 2 of the Supplement File a requirement that each time an executable program resulting from the Initial Work or any Subsequent Work, or a program dependent thereon, is launched or run, a prominent display of the Initial Contributor's attribution information must occur (the \"ATTRIBUTION INFORMATION\"). The Attribution Information must be included at the beginning of each Source Code file. For greater certainty, the Initial Contributor may specify in the Supplement File that the above attribution requirement only applies to an executable program resulting from the Initial Work or any Subsequent Work, but not a program dependent thereon. The intent is to provide for reasonably modest attribution, therefore the Initial Contributor may not require Recipients to display, at any time, more than the following Attribution Information: (a) a copyright notice including the name of the Initial Contributor; (b) a word or one phrase (not exceeding 10 words); (c) one digital image or graphic provided with the Initial Work; and (d) a URL (collectively, the \"ATTRIBUTION LIMITS\").\n\n         (b) If no Supplement File exists, or no Attribution Information is set out in Part 2 of the Supplement File, then there are no requirements for Recipients to display any Attribution Information of the Initial Contributor.\n\n         (c) Each Recipient acknowledges that all trademarks, service marks and/or trade names contained within Part 2 of the Supplement File distributed with the Licensed Work are the exclusive property of the Initial Contributor and may only be used with the permission of the Initial Contributor, or under circumstances otherwise permitted by law, or as expressly set out in this License.\n\n      3.11. For greater certainty, any description or attribution provisions contained within a Supplement File may only be used to specify the nature of the description or attribution requirements, as the case may be. Any provision in a Supplement File that otherwise purports to modify, vary, nullify or amend any right, obligation or representation contained herein shall be deemed void to that extent, and shall be of no force or effect.\n\n   4. COMMERCIAL USE AND INDEMNITY.\n\n      4.1. COMMERCIAL SERVICES.\n\n      A Recipient (\"COMMERCIAL RECIPIENT\") may choose to offer, and to charge a fee for, warranty, support, indemnity or liability obligations (collectively, \"SERVICES\") to one or more other Recipients or Distributors. However, such Commercial Recipient may do so only on that Commercial Recipient's own behalf, and not on behalf of any other Distributor or Recipient, and Commercial Recipient must make it clear than any such warranty, support, indemnity or liability obligation(s) is/are offered by Commercial Recipient alone. At no time may Commercial Recipient use any Services to deny any party the Licensed Work in Source Code or Executable form when so required under any of the other terms of this License. For greater certainty, this Section 4.1 does not diminish any of the other terms of this License, including without limitation the obligation of the Commercial Recipient as a Distributor, when distributing any of the Licensed Work in Source Code or Executable form, to make such distribution royalty-free (subject to the right to charge a fee of no more than the cost of physically performing Source Code or Executable distribution (as the case may be)).\n\n      4.2. INDEMNITY.\n\n      Commercial distributors of software may accept certain responsibilities with respect to end users, business partners and the like. While this License is intended to facilitate the commercial use of the Licensed Work, the Distributor who includes any of the Licensed Work in a commercial product offering should do so in a manner which does not create potential liability for other Distributors. Therefore, if a Distributor includes the Licensed Work in a commercial product offering or offers any Services, such Distributor (\"COMMERCIAL DISTRIBUTOR\") hereby agrees to defend and indemnify every other Distributor or Subsequent Contributor (in each case an \"INDEMNIFIED PARTY\") against any losses, damages and costs (collectively \"LOSSES\") arising from claims, lawsuits and other legal actions brought by a third party against the Indemnified Party to the extent caused by the acts or omissions of such Commercial Distributor in connection with its distribution of any of the Licensed Work in a commercial product offering or in connection with any Services. The obligations in this section do not apply to any claims or Losses relating to any actual or alleged intellectual property infringement. In order to qualify, an Indemnified Party must: (a) promptly notify the Commercial Distributor in writing of such claim; and (b) allow the Commercial Distributor to control, and co-operate with the Commercial Distributor in, the defense and any related settlement negotiations. The Indemnified Party may participate in any such claim at its own expense.\n\n   5. VERSIONS OF THE LICENSE.\n\n      5.1. NEW VERSIONS.\n\n      The Initial Contributor may publish revised and/or new versions of the License from time to time. Each version will be given a distinguishing version number.\n\n      5.2. EFFECT OF NEW VERSIONS.\n\n      Once the Licensed Work or any portion thereof has been published by Initial Contributor under a particular version of the License, Recipient may choose to continue to use it under the terms of that version. However, if a Recipient chooses to use the Licensed Work under the terms of any subsequent version of the License published by the Initial Contributor, then from the date of making this choice, the Recipient must comply with the terms of that subsequent version with respect to all further reproduction, preparation of derivative works, public display of, public performance of, distribution and sublicensing by the Recipient in connection with the Licensed Work. No one other than the Initial Contributor has the right to modify the terms applicable to the Licensed Work\n\n   6. DISCLAIMER OF WARRANTY.\n\n      6.1. GENERAL DISCLAIMER.\n\n      EXCEPT AS EXPRESSLY SET FORTH IN THIS LICENSE, THE LICENSED WORK IS PROVIDED UNDER THIS LICENSE ON AN \"AS IS\" BASIS, WITHOUT ANY REPRESENTATION, WARRANTY, GUARANTEE, ASSURANCE OR CONDITION OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE LICENSED WORK IS WITH RECIPIENT. SHOULD ANY LICENSED WORK PROVE DEFECTIVE IN ANY RESPECT, RECIPIENT (NOT THE INITIAL CONTRIBUTOR OR ANY SUBSEQUENT CONTRIBUTOR) ASSUMES THE COST OF ANY NECESSARY SERVICING, REPAIR OR CORRECTION. THIS CLAUSE CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. NO USE OF ANY LICENSED WORK IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS LICENSE INCLUDING WITHOUT LIMITATION THIS DISCLAIMER.\n\n      6.2. RESPONSIBILITY OF RECIPIENTS.\n\n      Each Recipient is solely responsible for determining the appropriateness of using and distributing the Licensed Work and assumes all risks associated with its exercise of rights under this License, including but not limited to the risks and costs of program errors, compliance with applicable laws, damage to or loss of data, programs or equipment, and unavailability or interruption of operations.\n\n   7. TERMINATION.\n\n      7.1. This License shall continue until terminated in accordance with the express terms herein.\n\n      7.2. Recipient may choose to terminate this License automatically at any time.\n\n      7.3. This License, including without limitation the rights granted hereunder to a particular Recipient, will terminate automatically if such Recipient is in material breach of any of the terms of this License and fails to cure such breach within sixty (60) days of becoming aware of the breach. Without limiting the foregoing, any material breach by such Recipient of any term of any other License under which such Recipient is granted any rights to the Licensed Work shall constitute a material breach of this License.\n\n      7.4. Upon termination of this License by or with respect to a particular Recipient for any reason, all rights granted hereunder and under any other License to that Recipient shall terminate. However, all sublicenses to the Licensed Work which were previously properly granted by such Recipient under a copy of this License (in each case, an \"Other License\" and in plural, \"Other Licenses\") shall survive any such termination of this License, including without limitation the rights and obligations under such Other Licenses as set out in their respective Sections 2, 3, 4, 5, 6, 7 and 8, mutatis mutandis, for so long as the respective sublicensees (i.e. other Recipients) remain in compliance with the terms of the copy of this License under which such sublicensees received rights to the Licensed Work. Any termination of such Other Licenses shall be pursuant to their respective Section 7, mutatis mutandis. Provisions which, by their nature, must remain in effect beyond the termination of this License shall survive.\n\n      7.5. Upon any termination of this License by or with respect to a particular Recipient, Sections 4.1, 4.2, 6.1, 6.2, 7.4, 7.5, 8.1, and 8.2, together with all provisions of this License necessary for the interpretation and enforcement of same, shall expressly survive such termination.\n\n   8. LIMITATION OF LIABILITY.\n\n      8.1. IN NO EVENT SHALL ANY OF INITIAL CONTRIBUTOR, ITS SUBSIDIARIES, OR AFFILIATES, OR ANY OF ITS OR THEIR RESPECTIVE OFFICERS, DIRECTORS, EMPLOYEES, AND/OR AGENTS (AS THE CASE MAY BE), HAVE ANY LIABILITY FOR ANY DIRECT DAMAGES, INDIRECT DAMAGES, PUNITIVE DAMAGES, INCIDENTAL DAMAGES, SPECIAL DAMAGES, EXEMPLARY DAMAGES, CONSEQUENTIAL DAMAGES OR ANY OTHER DAMAGES WHATSOEVER (INCLUDING WITHOUT LIMITATION LOSS OF USE, DATA OR PROFITS, OR ANY OTHER LOSS ARISING OUT OF OR IN ANY WAY RELATED TO THE USE, INABILITY TO USE, UNAUTHORIZED USE, PERFORMANCE, OR NON-PERFORMANCE OF THE LICENSED WORK OR ANY PART THEREOF OR THE PROVISION OF OR FAILURE TO PROVIDE SUPPORT SERVICES, OR THAT RESULT FROM ERRORS, DEFECTS, OMISSIONS, DELAYS IN OPERATION OR TRANSMISSION, OR ANY OTHER FAILURE OF PERFORMANCE), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) IN RELATION TO OR ARISING IN ANY WAY OUT OF THIS LICENSE OR THE USE OR DISTRIBUTION OF THE LICENSED WORK OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF LIABILITY SHALL NOT APPLY TO LIABILITY FOR DEATH OR PERSONAL INJURY RESULTING FROM SUCH PARTY'S NEGLIGENCE TO THE EXTENT APPLICABLE LAW PROHIBITS SUCH LIMITATION. THIS CLAUSE CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. NO USE OF ANY LICENSED WORK IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS LICENSE INCLUDING WITHOUT LIMITATION THE LIMITATIONS SET FORTH IN THIS SECTION 8.1.\n\n      8.2. EXCEPT AS EXPRESSLY SET FORTH IN THIS LICENSE, EACH RECIPIENT SHALL NOT HAVE ANY LIABILITY FOR ANY EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE LICENSED WORK OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF LIABILITY SHALL NOT APPLY TO LIABILITY FOR DEATH OR PERSONAL INJURY RESULTING FROM SUCH PARTY'S NEGLIGENCE TO THE EXTENT APPLICABLE LAW PROHIBITS SUCH LIMITATION.\n\n   9. GOVERNING LAW AND LEGAL ACTION.\n\n      9.1. This License shall be governed by and construed in accordance with the laws of the Governing Jurisdiction assigned in Part 3 of Exhibit A, without regard to its conflict of law provisions. No party may bring a legal action under this License more than one year after the cause of the action arose. Each party waives its rights (if any) to a jury trial in any litigation arising under this License. Note that if the Governing Jurisdiction is not assigned in Part 3 of Exhibit A, then the Governing Jurisdiction shall be the State of New York.\n\n      9.2. The courts of the Governing Jurisdiction shall have jurisdiction, but not exclusive jurisdiction, to entertain and determine all disputes and claims, whether for specific performance, injunction, damages or otherwise, both at law and in equity, arising out of or in any way relating to this License, including without limitation, the legality, validity, existence and enforceability of this License. Each party to this License hereby irrevocably attorns to and accepts the jurisdiction of the courts of the Governing Jurisdiction for such purposes.\n\n      9.3. Except as expressly set forth elsewhere herein, in the event of any action or proceeding brought by any party against another under this License the prevailing party shall be entitled to recover all costs and expenses including the fees of its attorneys in such action or proceeding in such amount as the court may adjudge reasonable.\n\n   10. MISCELLANEOUS.\n\n      10.1. The obligations imposed by this License are for the benefit of the Initial Contributor and any Recipient, and each Recipient acknowledges and agrees that the Initial Contributor and/or any other Recipient may enforce the terms and conditions of this License against any Recipient.\n\n      10.2. This License represents the complete agreement concerning subject matter hereof, and supersedes and cancels all previous oral and written communications, representations, agreements and understandings between the parties with respect to the subject matter hereof.\n\n      10.3. The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded.\n\n      10.4. The language in all parts of this License shall be in all cases construed simply according to its fair meaning, and not strictly for or against any of the parties hereto. Any law or regulation which provides that the language of a contract shall be construed against the drafter shall not apply to this License.\n\n      10.5. If any provision of this License is invalid or unenforceable under the laws of the Governing Jurisdiction, it shall not affect the validity or enforceability of the remainder of the terms of this License, and without further action by the parties hereto, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.\n\n      10.6. The paragraph headings of this License are for reference and convenience only and are not a part of this License, and they shall have no effect upon the construction or interpretation of any part hereof.\n\n      10.7. Each of the terms \"including\", \"include\" and \"includes\", when used in this License, is not limiting whether or not non-limiting language (such as \"without limitation\" or \"but not limited to\" or words of similar import) is used with reference thereto.\n\n      10.8. The parties hereto acknowledge they have expressly required that this License and notices relating thereto be drafted in the English language. //***THE LICENSE TERMS END HERE (OTHER THAN AS SET OUT IN EXHIBIT A).***//\n\nEXHIBIT A (to the Adaptive Public License)\n\n   PART 1: INITIAL CONTRIBUTOR AND DESIGNATED WEB SITE\n\n   The Initial Contributor is:\n\n   ________________________________________________\n\n   [Enter full name of Initial Contributor]\n\n   \n\n   Address of Initial Contributor:\n\n   ________________________________________________\n\n   ________________________________________________\n\n   ________________________________________________\n\n   [Enter address above]\n\n   \n\n   The Designated Web Site is:\n\n   ________________________________________________\n\n   [Enter URL for Designated Web Site of Initial Contributor]\n\n   \n\n   NOTE: The Initial Contributor is to complete this Part 1, along with Parts 2, 3, and 5, and, if applicable, Parts 4 and 6.\n\n   PART 2: INITIAL WORK\n\n   The Initial Work comprises the computer program(s) distributed by the Initial Contributor having the following title(s): _______________________________________________.\n\n   The date on which the Initial Work was first available under this License: _________________\n\n   PART 3: GOVERNING JURISDICTION\n\n   For the purposes of this License, the Governing Jurisdiction is _________________________________________________. [Initial Contributor to Enter Governing Jurisdiction here]\n\n   PART 4: THIRD PARTIES\n\n   For the purposes of this License, \"Third Party\" has the definition set forth below in the ONE paragraph selected by the Initial Contributor from paragraphs A, B, C, D and E when the Initial Work is distributed or otherwise made available by the Initial Contributor. To select one of the following paragraphs, the Initial Contributor must place an \"X\" or \"x\" in the selection box alongside the one respective paragraph selected.\n\n   SELECTION\n\n   BOX PARAGRAPH\n\n      \n\n      [ ] A. \"THIRD PARTY\" means any third party.\n\n      \n\n      [ ] B. \"THIRD PARTY\" means any third party except for any of the following: (a) a wholly owned subsidiary of the Subsequent Contributor in question; (b) a legal entity (the \"PARENT\") that wholly owns the Subsequent Contributor in question; or (c) a wholly owned subsidiary of the wholly owned subsidiary in (a) or of the Parent in (b).\n\n      \n\n      [ ] C. \"THIRD PARTY\" means any third party except for any of the following: (a) any Person directly or indirectly owning a majority of the voting interest in the Subsequent Contributor or (b) any Person in which the Subsequent Contributor directly or indirectly owns a majority voting interest.\n\n      \n\n      [ ] D. \"THIRD PARTY\" means any third party except for any Person directly or indirectly controlled by the Subsequent Contributor. For purposes of this definition, \"control\" shall mean the power to direct or cause the direction of, the management and policies of such Person whether through the ownership of voting interests, by contract, or otherwise.\n\n      \n\n      [ ] E. \"THIRD PARTY\" means any third party except for any Person directly or indirectly controlling, controlled by, or under common control with the Subsequent Contributor. For purposes of this definition, \"control\" shall mean the power to direct or cause the direction of, the management and policies of such Person whether through the ownership of voting interests, by contract, or otherwise.\n\n   The default definition of \"THIRD PARTY\" is the definition set forth in paragraph A, if NONE OR MORE THAN ONE of paragraphs A, B, C, D or E in this Part 4 are selected by the Initial Contributor.\n\n   PART 5: NOTICE\n\n   THE LICENSED WORK IS PROVIDED UNDER THE TERMS OF THE ADAPTIVE PUBLIC LICENSE (\"LICENSE\") AS FIRST COMPLETED BY: ______________________ [Insert the name of the Initial Contributor here]. ANY USE, PUBLIC DISPLAY, PUBLIC PERFORMANCE, REPRODUCTION OR DISTRIBUTION OF, OR PREPARATION OF DERIVATIVE WORKS BASED ON, THE LICENSED WORK CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS LICENSE AND ITS TERMS, WHETHER OR NOT SUCH RECIPIENT READS THE TERMS OF THE LICENSE. \"LICENSED WORK\" AND \"RECIPIENT\" ARE DEFINED IN THE LICENSE. A COPY OF THE LICENSE IS LOCATED IN THE TEXT FILE ENTITLED \"LICENSE.TXT\" ACCOMPANYING THE CONTENTS OF THIS FILE. IF A COPY OF THE LICENSE DOES NOT ACCOMPANY THIS FILE, A COPY OF THE LICENSE MAY ALSO BE OBTAINED AT THE FOLLOWING WEB SITE: ___________________________________________________[Insert Initial Contributor's Designated Web Site here]\n\n   Software distributed under the License is distributed on an \"AS IS\" basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the specific language governing rights and limitations under the License.\n\n   PART 6: PATENT LICENSING TERMS\n\n   For the purposes of this License, paragraphs A, B, C, D and E of this Part 6 of Exhibit A are only incorporated and form part of the terms of the License if the Initial Contributor places an \"X\" or \"x\" in the selection box alongside the YES answer to the question immediately below.\n\n   Is this a Patents-Included License pursuant to Section 2.2 of the License?\n\n      \n\n      YES [ ]\n\n      \n\n      NO [ ]\n\n   By default, if YES is not selected by the Initial Contributor, the answer is NO.\n\n      A. For the purposes of the paragraphs in this Part 6 of Exhibit A, \"LICENSABLE\" means having the right to grant, to the maximum extent possible, whether at the time of the initial grant or subsequently acquired, any and all of the rights granted herein.\n\n      B. The Initial Contributor hereby grants all Recipients a world-wide, royalty-free, non-exclusive license, subject to third party intellectual property claims, under patent claim(s) Licensable by the Initial Contributor that are or would be infringed by the making, using, selling, offering for sale, having made, importing, exporting, transfer or disposal of such Initial Work or any portion thereof. Notwithstanding the foregoing, no patent license is granted under this Paragraph B by the Initial Contributor: (1) for any code that the Initial Contributor deletes from the Initial Work (or any portion thereof) distributed by the Initial Contributor prior to such distribution; (2) for any Modifications made to the Initial Work (or any portion thereof) by any other Person; or (3) separate from the Initial Work (or portions thereof) distributed or made available by the Initial Contributor.\n\n      C. Effective upon distribution by a Subsequent Contributor to a Third Party of any Modifications made by that Subsequent Contributor, such Subsequent Contributor hereby grants all Recipients a world-wide, royalty-free, non-exclusive license, subject to third party intellectual property claims, under patent claim(s) Licensable by such Subsequent Contributor that are or would be infringed by the making, using, selling, offering for sale, having made, importing, exporting, transfer or disposal of any such Modifications made by that Subsequent Contributor alone and/or in combination with its Subsequent Work (or portions of such combination) to make, use, sell, offer for sale, have made, import, export, transfer and otherwise dispose of:\n\n         (1) Modifications made by that Subsequent Contributor (or portions thereof); and\n\n         (2) the combination of Modifications made by that Subsequent Contributor with its Subsequent Work (or portions of such combination);\n\n         (collectively and in each case, the \"SUBSEQUENT CONTRIBUTOR VERSION\").\n\n         Notwithstanding the foregoing, no patent license is granted under this Paragraph C by such Subsequent Contributor: (1) for any code that such Subsequent Contributor deletes from the Subsequent Contributor Version (or any portion thereof) distributed by the Subsequent Contributor prior to such distribution; (2) for any Modifications made to the Subsequent Contributor Version (or any portion thereof) by any other Person; or (3) separate from the Subsequent Contributor Version (or portions thereof) distributed or made available by the Subsequent Contributor.\n\n      D. Effective upon distribution of any Licensed Work by a Distributor to a Third Party, such Distributor hereby grants all Recipients a world-wide, royalty-free, non-exclusive license, subject to third party intellectual property claims, under patent claim(s) Licensable by such Distributor that are or would be infringed by the making, using, selling, offering for sale, having made, importing, exporting, transfer or disposal of any such Licensed Work distributed by such Distributor, to make, use, sell, offer for sale, have made, import, export, transfer and otherwise dispose of such Licensed Work or portions thereof (collectively and in each case, the \"DISTRIBUTOR VERSION\"). Notwithstanding the foregoing, no patent license is granted under this Paragraph D by such Distributor: (1) for any code that such Distributor deletes from the Distributor Version (or any portion thereof) distributed by the Distributor prior to such distribution; (2) for any Modifications made to the Distributor Version (or any portion thereof) by any other Person; or (3) separate from the Distributor Version (or portions thereof) distributed or made available by the Distributor.\n\n      E. If Recipient institutes patent litigation against another Recipient (a \"USER\") with respect to a patent applicable to a computer program or software (including a cross-claim or counterclaim in a lawsuit, and whether or not any of the patent claims are directed to a system, method, process, apparatus, device, product, article of manufacture or any other form of patent claim), then any patent or copyright license granted by that User to such Recipient under this License or any other copy of this License shall terminate. The termination shall be effective ninety (90) days after notice of termination from User to Recipient, unless the Recipient withdraws the patent litigation claim before the end of the ninety (90) day period. To be effective, any such notice of license termination must include a specific list of applicable patents and/or a copy of the copyrighted work of User that User alleges will be infringed by Recipient upon License termination. License termination is only effective with respect to patents and/or copyrights for which proper notice has been given.\n\n   PART 7: SAMPLE REQUIREMENTS FOR THE DESCRIPTION OF DISTRIBUTED MODIFICATIONS\n\n   Each Subsequent Contributor (including the Initial Contributor where the Initial Contributor qualifies as a Subsequent Contributor) is invited (but not required) to cause each Subsequent Work created or contributed to by that Subsequent Contributor to contain a file documenting the changes such Subsequent Contributor made to create that Subsequent Work and the date of any change.\n\n//***EXHIBIT A ENDS HERE.***//"],"licenseIds":["APL-1.0"],"keywords":["0 the licensed","of this adaptive","this adaptive public","are defined below","defined below important","below important note","important note this","license is adaptive","is adaptive and","adaptive and the","and the generic","the generic version","generic version or","version or another","or another version","another version of","version of an","of an adaptive","an adaptive public","public license should","not be relied","be relied upon","relied upon to","upon to determine","to determine your","determine your rights","you must read","must read the","read the specific","specific adaptive public","you receive with","receive with the","licensed work as","work as certain","as certain terms","certain terms are","defined at the","at the outset","the outset by","outset by the","initial contributor see","contributor see section","2 below exhibit","below exhibit a","exhibit a attached","a attached and","attached and any","and any suppfile","any suppfile txt","suppfile txt accompanying","txt accompanying this","license to determine","determine the specific","specific adaptive features","adaptive features applicable","features applicable to","the foregoing a","foregoing a for","a for selected","for selected choice","selected choice of","and jurisdiction see","jurisdiction see part","see part 3","exhibit a b","a b for","for the selected","the selected definition","selected definition of","third party see","party see part","see part 4","a and c","c for selected","for selected patent","selected patent licensing","licensing terms if","terms if any","if any see","any see section","2 below and","below and part","and part 6","a 1 definitions","contributor and b","subsequent contributor the","contributor the subsequent","originating from and","from and distributed","and distributed by","contributor 1 2","1 2 designated","2 designated web","web site means","site means the","means the web","web site having","site having the","having the url","the url identified","url identified in","a which url","which url may","url may be","be changed by","changed by the","initial contributor by","contributor by posting","by posting on","posting on the","on the current","the current designated","current designated web","site the new","the new url","new url for","url for at","at least sixty","least sixty 60","60 days 1","days 1 3","1 3 distributor","3 distributor means","distributor means any","distributes the licensed","thereof to at","party 1 4","mechanism means any","means any mechanism","any mechanism generally","means the licensed","1 6 governing","6 governing jurisdiction","governing jurisdiction means","jurisdiction means the","means the state","the state province","state province or","province or other","other legal jurisdiction","legal jurisdiction identified","jurisdiction identified in","1 7 independent","7 independent module","independent module means","means a separate","a separate module","separate module of","module of software","or data that","work of or","of or copied","or copied from","thereof in addition","addition a module","a module does","module does not","as an independent","independent module but","module but instead","but instead forms","instead forms part","forms part of","licensed work if","if the module","the module a","module a is","a is embedded","is embedded in","embedded in the","licensed work b","work b is","b is included","is included by","reference in the","licensed work other","other than by","than by a","by a function","a function call","function call or","call or a","or a class","a class reference","class reference or","reference or c","or c must","c must be","be included or","included or contained","contained in whole","in part within","part within a","within a file","a file directory","file directory or","directory or subdirectory","or subdirectory actually","subdirectory actually containing","actually containing files"]},{"licenseTexts":["APPLE PUBLIC SOURCE LICENSE\n\nVersion 1.0 - March 16, 1999 Please read this License carefully before downloading this software. By downloading and using this software, you are agreeing to be bound by the terms of this License. If you do not or cannot agree to the terms of this License, please do not download or use the software.\n\n   1. General; Definitions. This License applies to any program or other work which Apple Computer, Inc. (\"Apple\") publicly announces as subject to this Apple Public Source License and which contains a notice placed by Apple identifying such program or work as \"Original Code\" and stating that it is subject to the terms of this Apple Public Source License version 1.0 (or subsequent version thereof), as it may be revised from time to time by Apple (\"License\"). As used in this License:\n\n      1.1 \"Applicable Patents\" mean: (a) in the case where Apple is the grantor of rights, (i) patents or patent applications that are now or hereafter acquired, owned by or assigned to Apple and (ii) whose claims cover subject matter contained in the Original Code, but only to the extent necessary to use, reproduce and/or distribute the Original Code without infringement; and (b) in the case where You are the grantor of rights, (i) patents and patent applications that are now or hereafter acquired, owned by or assigned to You and (ii) whose claims cover subject matter in Your Modifications, taken alone or in combination with Original Code.\n\n      1.2 \"Covered Code\" means the Original Code, Modifications, the combination of Original Code and any Modifications, and/or any respective portions thereof.\n\n      1.3 \"Deploy\" means to use, sublicense or distribute Covered Code other than for Your internal research and development (R\u0026D), and includes without limitation, any and all internal use or distribution of Covered Code within Your business or organization except for R\u0026D use, as well as direct or indirect sublicensing or distribution of Covered Code by You to any third party in any form or manner.\n\n      1.4 \"Larger Work\" means a work which combines Covered Code or portions thereof with code not governed by the terms of this License.\n\n      1.5 \"Modifications\" mean any addition to, deletion from, and/or change to, the substance and/or structure of Covered Code. When code is released as a series of files, a Modification is: (a) any addition to or deletion from the contents of a file containing Covered Code; and/or (b) any new file or other representation of computer program statements that contains any part of Covered Code.\n\n      1.6 \"Original Code\" means the Source Code of a program or other work as originally made available by Apple under this License, including the Source Code of any updates or upgrades to such programs or works made available by Apple under this License, and that has been expressly identified by Apple as such in the header file(s) of such work.\n\n      1.7 \"Source Code\" means the human readable form of a program or other work that is suitable for making modifications to it, including all modules it contains, plus any associated interface definition files, scripts used to control compilation and installation of an executable (object code).\n\n      1.8 \"You\" or \"Your\" means an individual or a legal entity exercising rights under this License. For legal entities, \"You\" or \"Your\" includes any entity which controls, is controlled by, or is under common control with, You, where \"control\" means (a) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (b) ownership of fifty percent (50%) or more of the outstanding shares or beneficial ownership of such entity.\n\n   2. Permitted Uses; Conditions \u0026 Restrictions. Subject to the terms and conditions of this License, Apple hereby grants You, effective on the date You accept this License and download the Original Code, a world-wide, royalty-free, non-exclusive license, to the extent of Apple's Applicable Patents and copyrights covering the Original Code, to do the following:\n\n      2.1 You may use, copy, modify and distribute Original Code, with or without Modifications, solely for Your internal research and development, provided that You must in each instance:\n\n         (a) retain and reproduce in all copies of Original Code the copyright and other proprietary notices and disclaimers of Apple as they appear in the Original Code, and keep intact all notices in the Original Code that refer to this License;\n\n         (b) include a copy of this License with every copy of Source Code of Covered Code and documentation You distribute, and You may not offer or impose any terms on such Source Code that alter or restrict this License or the recipients' rights hereunder, except as permitted under Section 6; and\n\n         (c) completely and accurately document all Modifications that you have made and the date of each such Modification, designate the version of the Original Code you used, prominently include a file carrying such information with the Modifications, and duplicate the notice in Exhibit A in each file of the Source Code of all such Modifications.\n\n      2.2 You may Deploy Covered Code, provided that You must in each instance:\n\n         (a) satisfy all the conditions of Section 2.1 with respect to the Source Code of the Covered Code;\n\n         (b) make all Your Deployed Modifications publicly available in Source Code form via electronic distribution (e.g. download from a web site) under the terms of this License and subject to the license grants set forth in Section 3 below, and any additional terms You may choose to offer under Section 6. You must continue to make the Source Code of Your Deployed Modifications available for as long as you Deploy the Covered Code or twelve (12) months from the date of initial Deployment, whichever is longer;\n\n         (c) must notify Apple and other third parties of how to obtain Your Deployed Modifications by filling out and submitting the required information found at http://www.apple.com/publicsource/modifications.html; and\n\n         (d) if you Deploy Covered Code in object code, executable form only, include a prominent notice, in the code itself as well as in related documentation, stating that Source Code of the Covered Code is available under the terms of this License with information on how and where to obtain such Source Code.\n\n   3. Your Grants. In consideration of, and as a condition to, the licenses granted to You under this License:\n\n         (a) You hereby grant to Apple and all third parties a non-exclusive, royalty-free license, under Your Applicable Patents and other intellectual property rights owned or controlled by You, to use, reproduce, modify, distribute and Deploy Your Modifications of the same scope and extent as Apple's licenses under Sections 2.1 and 2.2; and\n\n         (b) You hereby grant to Apple and its subsidiaries a non-exclusive, worldwide, royalty-free, perpetual and irrevocable license, under Your Applicable Patents and other intellectual property rights owned or controlled by You, to use, reproduce, execute, compile, display, perform, modify or have modified (for Apple and/or its subsidiaries), sublicense and distribute Your Modifications, in any form, through multiple tiers of distribution.\n\n   4. Larger Works. You may create a Larger Work by combining Covered Code with other code not governed by the terms of this License and distribute the Larger Work as a single product. In each such instance, You must make sure the requirements of this License are fulfilled for the Covered Code or any portion thereof.\n\n   5. Limitations on Patent License. Except as expressly stated in Section 2, no other patent rights, express or implied, are granted by Apple herein. Modifications and/or Larger Works may require additional patent licenses from Apple which Apple may grant in its sole discretion.\n\n   6. Additional Terms. You may choose to offer, and to charge a fee for, warranty, support, indemnity or liability obligations and/or other rights consistent with the scope of the license granted herein (\"Additional Terms\") to one or more recipients of Covered Code. However, You may do so only on Your own behalf and as Your sole responsibility, and not on behalf of Apple. You must obtain the recipient's agreement that any such Additional Terms are offered by You alone, and You hereby agree to indemnify, defend and hold Apple harmless for any liability incurred by or claims asserted against Apple by reason of any such Additional Terms.\n\n   7. Versions of the License. Apple may publish revised and/or new versions of this License from time to time. Each version will be given a distinguishing version number. Once Original Code has been published under a particular version of this License, You may continue to use it under the terms of that version. You may also choose to use such Original Code under the terms of any subsequent version of this License published by Apple. No one other than Apple has the right to modify the terms applicable to Covered Code created under this License.\n\n   8. NO WARRANTY OR SUPPORT. The Original Code may contain in whole or in part pre-release, untested, or not fully tested works. The Original Code may contain errors that could cause failures or loss of data, and may be incomplete or contain inaccuracies. You expressly acknowledge and agree that use of the Original Code, or any portion thereof, is at Your sole and entire risk. THE ORIGINAL CODE IS PROVIDED \"AS IS\" AND WITHOUT WARRANTY, UPGRADES OR SUPPORT OF ANY KIND AND APPLE AND APPLE'S LICENSOR(S) (FOR THE PURPOSES OF SECTIONS 8 AND 9, APPLE AND APPLE'S LICENSOR(S) ARE COLLECTIVELY REFERRED TO AS \"APPLE\") EXPRESSLY DISCLAIM ALL WARRANTIES AND/OR CONDITIONS, EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES AND/OR CONDITIONS OF MERCHANTABILITY OR SATISFACTORY QUALITY AND FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. APPLE DOES NOT WARRANT THAT THE FUNCTIONS CONTAINED IN THE ORIGINAL CODE WILL MEET YOUR REQUIREMENTS, OR THAT THE OPERATION OF THE ORIGINAL CODE WILL BE UNINTERRUPTED OR ERROR-FREE, OR THAT DEFECTS IN THE ORIGINAL CODE WILL BE CORRECTED. NO ORAL OR WRITTEN INFORMATION OR ADVICE GIVEN BY APPLE OR AN APPLE AUTHORIZED REPRESENTATIVE SHALL CREATE A WARRANTY OR IN ANY WAY INCREASE THE SCOPE OF THIS WARRANTY. You acknowledge that the Original Code is not intended for use in the operation of nuclear facilities, aircraft navigation, communication systems, or air traffic control machines in which case the failure of the Original Code could lead to death, personal injury, or severe physical or environmental damage.\n\n   9. Liability.\n\n      9.1 Infringement. If any of the Original Code becomes the subject ofa claim of infringement (\"Affected Original Code\"), Apple may, at its sole discretion and option: (a) attempt to procure the rights necessary for You to continue using the Affected Original Code; (b) modify the Affected Original Code so that it is no longer infringing; or (c) terminate Your rights to use the Affected Original Code, effective immediately upon Apple's posting of a notice to such effect on the Apple web site that is used for implementation of this License.\n\n      9.2 LIMITATION OF LIABILITY. UNDER NO CIRCUMSTANCES SHALL APPLE BE LIABLE FOR ANY INCIDENTAL, SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES ARISING OUT OF OR RELATING TO THIS LICENSE OR YOUR USE OR INABILITY TO USE THE ORIGINAL CODE, OR ANY PORTION THEREOF, WHETHER UNDER A THEORY OF CONTRACT, WARRANTY, TORT (INCLUDING NEGLIGENCE), PRODUCTS LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES AND NOTWITHSTANDING THE FAILURE OF ESSENTIAL PURPOSE OF ANY REMEDY. In no event shall Apple's total liability to You for all damages under this License exceed the amount of fifty dollars ($50.00).\n\n   10. Trademarks. This License does not grant any rights to use the trademarks or trade names \"Apple\", \"Apple Computer\", \"Mac OS X\", \"Mac OS X Server\" or any other trademarks or trade names belonging to Apple (collectively \"Apple Marks\") and no Apple Marks may be used to endorse or promote products derived from the Original Code\n\n   other than as permitted by and in strict compliance at all times with Apple's third party trademark usage guidelines which are posted at http://www.apple.com/legal/guidelinesfor3rdparties.html.\n\n   11. Ownership. Apple retains all rights, title and interest in and to the Original Code and any Modifications made by or on behalf of Apple (\"Apple Modifications\"), and such Apple Modifications will not be automatically subject to this License. Apple may, at its sole discretion, choose to license such Apple Modifications under this License, or on different terms from those contained in this License or may choose not to license them at all. Apple's development, use, reproduction, modification, sublicensing and distribution of Covered Code will not be subject to this License.\n\n   12. Termination.\n\n      12.1 Termination. This License and the rights granted hereunder will terminate:\n\n         (a) automatically without notice from Apple if You fail to comply with any term(s) of this License and fail to cure such breach within 30 days of becoming aware of such breach;\n\n         (b) immediately in the event of the circumstances described in Sections 9.1 and/or 13.6(b); or\n\n         (c) automatically without notice from Apple if You, at any time during the term of this License, commence an action for patent infringement against Apple.\n\n      12.2 Effect of Termination. Upon termination, You agree to immediately stop any further use, reproduction, modification and distribution of the Covered Code, or Affected Original Code in the case of termination under Section 9.1, and to destroy all copies of the Covered Code or Affected Original Code (in the case of\n\n      termination under Section 9.1) that are in your possession or control. All sublicenses to the Covered Code which have been properly granted prior to termination shall survive any termination of this License. Provisions which, by their nature, should remain in effect beyond the termination of this License shall survive, including but not limited to Sections 3, 5, 8, 9, 10, 11, 12.2 and 13. Neither party will be liable to the other for compensation, indemnity or damages of any sort solely as a result of terminating this License in accordance with its terms, and termination of this License will be without prejudice to any other right or remedy of either party.\n\n   13. Miscellaneous.\n\n      13.1 Export Law Assurances. You may not use or otherwise export or re-export the Original Code except as authorized by United States law and the laws of the jurisdiction in which the Original Code was obtained. In particular, but without limitation, the Original Code may not be exported or re-exported (a) into (or to a national or resident of) any U.S. embargoed country or (b) to anyone on the U.S. Treasury Department's list of Specially Designated Nationals or the U.S. Department of Commerce's Table of Denial Orders. By using the Original Code, You represent and warrant that You are not located in, under control of, or a national or resident of any such country or on any such list.\n\n      13.2 Government End Users. The Covered Code is a \"commercial item\" as defined in FAR 2.101. Government software and technical data rights in the Covered Code include only those rights customarily provided to the public as defined in this License. This customary commercial license in technical data and software is provided in\n\n      accordance with FAR 12.211 (Technical Data) and 12.212 (Computer Software) and, for Department of Defense purchases, DFAR 252.227-7015 (Technical Data -- Commercial Items) and 227.7202-3 (Rights in Commercial Computer Software or Computer Software Documentation). Accordingly, all U.S. Government End Users acquire Covered Code with only those rights set forth herein.\n\n      13.3 Relationship of Parties. This License will not be construed as creating an agency, partnership, joint venture or any other form of legal association between You and Apple, and You will not represent to the contrary, whether expressly, by implication, appearance or otherwise.\n\n      13.4 Independent Development. Nothing in this License will impair Apple's right to acquire, license, develop, have others develop for it, market and/or distribute technology or products that perform the same or similar functions as, or otherwise compete with, Modifications, Larger Works, technology or products that You may develop, produce, market or distribute.\n\n      13.5 Waiver; Construction. Failure by Apple to enforce any provision of this License will not be deemed a waiver of future enforcement of that or any other provision. Any law or regulation which provides that the language of a contract shall be construed against the drafter will not apply to this License.\n\n      13.6 Severability. (a) If for any reason a court of competent jurisdiction finds any provision of this License, or portion thereof, to be unenforceable, that provision of the License will be enforced to the maximum extent permissible so as to effect the economic benefits and intent of the parties, and the remainder of this License will continue in full force and effect. (b) Notwithstanding the foregoing, if applicable law prohibits or restricts You from fully and/or specifically complying with Sections 2 and/or 3 or prevents the enforceability of either of those Sections, this License will immediately terminate and You must immediately discontinue any use of the Covered Code and destroy all copies of it that are in your possession or control.\n\n      13.7 Dispute Resolution. Any litigation or other dispute resolution between You and Apple relating to this License shall take place in the Northern District of California, and You and Apple hereby consent to the personal jurisdiction of, and venue in, the state and federal courts within that District with respect to this License. The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded.\n\n      13.8 Entire Agreement; Governing Law. This License constitutes the entire agreement between the parties with respect to the subject matter hereof. This License shall be governed by the laws of the United States and the State of California, except that body of California law concerning conflicts of law.\n\n      Where You are located in the province of Quebec, Canada, the following clause applies: The parties hereby confirm that they have requested that this License and all related documents be drafted in English. Les parties ont exige que le present contrat et tous les documents connexes soient rediges en anglais. EXHIBIT A.\n\n\"Portions Copyright (c) 1999 Apple Computer, Inc. All Rights Reserved. This file contains Original Code and/or Modifications of Original Code as defined in and that are subject to the Apple Public Source License Version 1.0 (the 'License'). You may not use this file except in compliance with the License. Please obtain a copy of the License at http://www.apple.com/publicsource and read it before using this file.\n\nThe Original Code and all software distributed under the License are distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the License for the specific language governing rights and limitations under the License.\""],"licenseIds":["APSL-1.0"],"keywords":["1 0 march","0 march 16","march 16 1999","16 1999 please","1 applicable patents","applicable patents mean","patents mean a","i patents or","i patents and","patents and patent","and patent applications","1 3 deploy","3 deploy means","manner 1 4","1 5 modifications","5 modifications mean","6 original code","such work 1","work 1 7","1 7 source","7 source code","code 1 8","1 8 you","8 you or","s applicable patents","patents and copyrights","longer c must","c must notify","must notify apple","notify apple and","apple and other","and other third","other third parties","third parties of","parties of how","to obtain your","obtain your deployed","deployed modifications by","submitting the required","required information found","modifications html and","html and d","the subject ofa","subject ofa claim","ofa claim of","of infringement affected","infringement affected original","code apple may","sole discretion and","discretion and option","and option a","necessary for you","or c terminate","c terminate your","use the affected","original code effective","code effective immediately","in sections 9","sections 9 1","and or 13","or 13 6","13 6 b","6 b or","1 and to","9 1 that","1 that are","13 1 export","1 export law","export law assurances","law assurances you","assurances you may","or otherwise export","otherwise export or","export or re","or re export","re export the","export the original","original code except","code except as","except as authorized","as authorized by","authorized by united","united states law","states law and","and the laws","which the original","code was obtained","was obtained in","obtained in particular","in particular but","particular but without","but without limitation","limitation the original","code may not","not be exported","be exported or","exported or re","re exported a","exported a into","a into or","into or to","or to a","to a national","of any u","any u s","s embargoed country","embargoed country or","country or b","b to anyone","to anyone on","anyone on the","on the u","u s treasury","s treasury department","treasury department s","department s list","s list of","list of specially","of specially designated","specially designated nationals","designated nationals or","nationals or the","of commerce s","commerce s table","s table of","table of denial","of denial orders","denial orders by","orders by using","using the original","code you represent","you represent and","represent and warrant","and warrant that","warrant that you","are not located","not located in","located in under","in under control","under control of","of or a","or a national","any such country","such country or","country or on","or on any","on any such","any such list","such list 13","list 13 2","13 2 government","2 government end","herein 13 3","13 3 relationship","3 relationship of","otherwise 13 4","13 4 independent","4 independent development","distribute 13 5","13 5 waiver","5 waiver construction","license 13 6","13 6 severability","6 severability a","control 13 7","13 7 dispute","7 dispute resolution","excluded 13 8","13 8 entire","c 1999 apple","1999 apple computer","version 1 0 march","1 0 march 16","0 march 16 1999","march 16 1999 please","16 1999 please read","1 1 applicable patents","1 applicable patents mean","applicable patents mean a","patents mean a in","rights i patents or","i patents or patent","or patent applications that","apple and ii whose","rights i patents and","i patents and patent","patents and patent applications","and patent applications that","you and ii whose","code 1 2 covered","portions thereof 1 3","thereof 1 3 deploy","1 3 deploy means","3 deploy means to","or manner 1 4","manner 1 4 larger","license 1 5 modifications","1 5 modifications mean","5 modifications mean any","covered code 1 6"]},{"licenseTexts":["APPLE PUBLIC SOURCE LICENSE\n\nVersion 1.1 - April 19, 1999 Please read this License carefully before downloading this software.\n\nBy downloading and using this software, you are agreeing to be bound by the terms of this License. If you do not or cannot agree to the terms of this License, please do not download or use the software.\n\n   1. General; Definitions. This License applies to any program or other work which Apple Computer, Inc. (\"Apple\") publicly announces as subject to this Apple Public Source License and which contains a notice placed by Apple identifying such program or work as \"Original Code\" and stating that it is subject to the terms of this Apple Public Source License version 1.1 (or subsequent version thereof), as it may be revised from time to time by Apple (\"License\"). As used in this License:\n\n      1.1 \"Affected Original Code\" means only those specific portions of Original Code that allegedly infringe upon any party's intellectual property rights or are otherwise the subject of a claim of infringement.\n\n      1.2 \"Applicable Patent Rights\" mean: (a) in the case where Apple is the grantor of rights, (i) claims of patents that are now or hereafter acquired, owned by or assigned to Apple and (ii) that cover subject matter contained in the Original Code, but only to the extent necessary to use, reproduce and/or distribute the Original Code without infringement; and (b) in the case where You are the grantor of rights, (i) claims of patents that are now or hereafter acquired, owned by or assigned to You and (ii) that cover subject matter in Your Modifications, taken alone or in combination with Original Code.\n\n      1.3 \"Covered Code\" means the Original Code, Modifications, the combination of Original Code and any Modifications, and/or any respective portions thereof.\n\n      1.4 \"Deploy\" means to use, sublicense or distribute Covered Code other than for Your internal research and development (R\u0026D), and includes without limitation, any and all internal use or distribution of Covered Code within Your business or organization except for R\u0026D use, as well as direct or indirect sublicensing or distribution of Covered Code by You to any third party in any form or manner.\n\n      1.5 \"Larger Work\" means a work which combines Covered Code or portions thereof with code not governed by the terms of this License.\n\n      1.6 \"Modifications\" mean any addition to, deletion from, and/or change to, the substance and/or structure of Covered Code. When code is released as a series of files, a Modification is: (a) any addition to or deletion from the contents of a file containing Covered Code; and/or (b) any new file or other representation of computer program statements that contains any part of Covered Code.\n\n      1.7 \"Original Code\" means (a) the Source Code of a program or other work as originally made available by Apple under this License, including the Source Code of any updates or upgrades to such programs or works made available by Apple under this License, and that has been expressly identified by Apple as such in the header file(s) of such work; and (b) the object code compiled from such Source Code and originally made available by Apple under this License.\n\n      1.8 \"Source Code\" means the human readable form of a program or other work that is suitable for making modifications to it, including all modules it contains, plus any associated interface definition files, scripts used to control compilation and installation of an executable (object code).\n\n      1.9 \"You\" or \"Your\" means an individual or a legal entity exercising rights under this License. For legal entities, \"You\" or \"Your\" includes any entity which controls, is controlled by, or is under common control with, You, where \"control\" means (a) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (b) ownership of fifty percent (50%) or more of the outstanding shares or beneficial ownership of such entity.\n\n   2. Permitted Uses; Conditions \u0026 Restrictions. Subject to the terms and conditions of this License, Apple hereby grants You, effective on the date You accept this License and download the Original Code, a world-wide, royalty-free, non- exclusive license, to the extent of Apple's Applicable Patent Rights and copyrights covering the Original Code, to do the following:\n\n      2.1 You may use, copy, modify and distribute Original Code, with or without Modifications, solely for Your internal research and development, provided that You must in each instance:\n\n         (a) retain and reproduce in all copies of Original Code the copyright and other proprietary notices and disclaimers of Apple as they appear in the Original Code, and keep intact all notices in the Original Code that refer to this License;\n\n         (b) include a copy of this License with every copy of Source Code of Covered Code and documentation You distribute, and You may not offer or impose any terms on such Source Code that alter or restrict this License or the recipients' rights hereunder, except as permitted under Section 6; and\n\n         (c) completely and accurately document all Modifications that you have made and the date of each such Modification, designate the version of the Original Code you used, prominently include a file carrying such information with the Modifications, and duplicate the notice in Exhibit A in each file of the Source Code of all such Modifications.\n\n      2.2 You may Deploy Covered Code, provided that You must in each instance:\n\n         (a) satisfy all the conditions of Section 2.1 with respect to the Source Code of the Covered Code;\n\n         (b) make all Your Deployed Modifications publicly available in Source Code form via electronic distribution (e.g. download from a web site) under the terms of this License and subject to the license grants set forth in Section 3 below, and any additional terms You may choose to offer under Section 6. You must continue to make the Source Code of Your Deployed Modifications available for as long as you Deploy the Covered Code or twelve (12) months from the date of initial Deployment, whichever is longer;\n\n         (c) if You Deploy Covered Code containing Modifications made by You, inform others of how to obtain those Modifications by filling out and submitting the information found at http://www.apple.com/publicsource/modifications.html, if available; and\n\n         (d) if You Deploy Covered Code in object code, executable form only, include a prominent notice, in the code itself as well as in related documentation, stating that Source Code of the Covered Code is available under the terms of this License with information on how and where to obtain such Source Code.\n\n   3. Your Grants. In consideration of, and as a condition to, the licenses granted to You under this License:\n\n      (a) You hereby grant to Apple and all third parties a non-exclusive, royalty-free license, under Your Applicable Patent Rights and other intellectual property rights owned or controlled by You, to use, reproduce, modify, distribute and Deploy Your Modifications of the same scope and extent as Apple's licenses under Sections 2.1 and 2.2; and\n\n      (b) You hereby grant to Apple and its subsidiaries a non-exclusive, worldwide, royalty-free, perpetual and irrevocable license, under Your Applicable Patent Rights and other intellectual property rights owned or controlled by You, to use, reproduce, execute, compile, display, perform, modify or have modified (for Apple and/or its subsidiaries), sublicense and distribute Your Modifications, in any form, through multiple tiers of distribution.\n\n   4. Larger Works. You may create a Larger Work by combining Covered Code with other code not governed by the terms of this License and distribute the Larger Work as a single product. In each such instance, You must make sure the requirements of this License are fulfilled for the Covered Code or any portion thereof.\n\n   5. Limitations on Patent License. Except as expressly stated in Section 2, no other patent rights, express or implied, are granted by Apple herein. Modifications and/or Larger Works may require additional patent licenses from Apple which Apple may grant in its sole discretion.\n\n   6. Additional Terms. You may choose to offer, and to charge a fee for, warranty, support, indemnity or liability obligations and/or other rights consistent with the scope of the license granted herein (\"Additional Terms\") to one or more recipients of Covered Code. However, You may do so only on Your own behalf and as Your sole responsibility, and not on behalf of Apple. You must obtain the recipient's agreement that any such Additional Terms are offered by You alone, and You hereby agree to indemnify, defend and hold Apple harmless for any liability incurred by or claims asserted against Apple by reason of any such Additional Terms.\n\n   7. Versions of the License. Apple may publish revised and/or new versions of this License from time to time. Each version will be given a distinguishing version number. Once Original Code has been published under a particular version of this License, You may continue to use it under the terms of that version. You may also choose to use such Original Code under the terms of any subsequent version of this License published by Apple. No one other than Apple has the right to modify the terms applicable to Covered Code created under this License.\n\n   8. NO WARRANTY OR SUPPORT. The Original Code may contain in whole or in part pre-release, untested, or not fully tested works. The Original Code may contain errors that could cause failures or loss of data, and may be incomplete or contain inaccuracies. You expressly acknowledge and agree that use of the Original Code, or any portion thereof, is at Your sole and entire risk. THE ORIGINAL CODE IS PROVIDED \"AS IS\" AND WITHOUT WARRANTY, UPGRADES OR SUPPORT OF ANY KIND AND APPLE AND APPLE'S LICENSOR(S) (FOR THE PURPOSES OF SECTIONS 8 AND 9, APPLE AND APPLE'S LICENSOR(S) ARE COLLECTIVELY REFERRED TO AS \"APPLE\") EXPRESSLY DISCLAIM ALL WARRANTIES AND/OR CONDITIONS, EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES AND/OR CONDITIONS OF MERCHANTABILITY OR SATISFACTORY QUALITY AND FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. APPLE DOES NOT WARRANT THAT THE FUNCTIONS CONTAINED IN THE ORIGINAL CODE WILL MEET YOUR REQUIREMENTS, OR THAT THE OPERATION OF THE ORIGINAL CODE WILL BE UNINTERRUPTED OR ERROR- FREE, OR THAT DEFECTS IN THE ORIGINAL CODE WILL BE CORRECTED. NO ORAL OR WRITTEN INFORMATION OR ADVICE GIVEN BY APPLE OR AN APPLE AUTHORIZED REPRESENTATIVE SHALL CREATE A WARRANTY OR IN ANY WAY INCREASE THE SCOPE OF THIS WARRANTY. You acknowledge that the Original Code is not intended for use in the operation of nuclear facilities, aircraft navigation, communication systems, or air traffic control machines in which case the failure of the Original Code could lead to death, personal injury, or severe physical or environmental damage.\n\n   9. Liability.\n\n      9.1 Infringement. If any portion of, or functionality implemented by, the Original Code becomes the subject of a claim of infringement, Apple may, at its option: (a) attempt to procure the rights necessary for Apple and You to continue using the Affected Original Code; (b) modify the Affected Original Code so that it is no longer infringing; or (c) suspend Your rights to use, reproduce, modify, sublicense and distribute the Affected Original Code until a final determination of the claim is made by a court or governmental administrative agency of competent jurisdiction and Apple lifts the suspension as set forth below. Such suspension of rights will be effective immediately upon Apple's posting of a notice to such effect on the Apple web site that is used for implementation of this License. Upon such final determination being made, if Apple is legally able, without the payment of a fee or royalty, to resume use, reproduction, modification, sublicensing and distribution of the Affected Original Code, Apple will lift the suspension of rights to the Affected Original Code by posting a notice to such effect on the Apple web site that is used for implementation of this License. If Apple suspends Your rights to Affected Original Code, nothing in this License shall be construed to restrict You, at Your option and subject to applicable law, from replacing the Affected Original Code with non-infringing code or independently negotiating for necessary rights from such third party.\n\n      9.2 LIMITATION OF LIABILITY. UNDER NO CIRCUMSTANCES SHALL APPLE BE LIABLE FOR ANY INCIDENTAL, SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES ARISING OUT OF OR RELATING TO THIS LICENSE OR YOUR USE OR INABILITY TO USE THE ORIGINAL CODE, OR ANY PORTION THEREOF, WHETHER UNDER A THEORY OF CONTRACT, WARRANTY, TORT (INCLUDING NEGLIGENCE), PRODUCTS LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES AND NOTWITHSTANDING THE FAILURE OF ESSENTIAL PURPOSE OF ANY REMEDY. In no event shall Apple's total liability to You for all damages under this License exceed the amount of fifty dollars ($50.00).\n\n   10. Trademarks. This License does not grant any rights to use the trademarks or trade names \"Apple\", \"Apple Computer\", \"Mac OS X\", \"Mac OS X Server\" or any other trademarks or trade names belonging to Apple (collectively \"Apple Marks\") and no Apple Marks may be used to endorse or promote products derived from the Original Code other than as permitted by and in strict compliance at all times with Apple's third party trademark usage guidelines which are posted at http://www.apple.com/legal/guidelinesfor3rdparties.html.\n\n   11. Ownership. Apple retains all rights, title and interest in and to the Original Code and any Modifications made by or on behalf of Apple (\"Apple Modifications\"), and such Apple Modifications will not be automatically subject to this License. Apple may, at its sole discretion, choose to license such Apple Modifications under this License, or on different terms from those contained in this License or may choose not to license them at all. Apple's development, use, reproduction, modification, sublicensing and distribution of Covered Code will not be subject to this License.\n\n   12. Termination.\n\n      12.1 Termination. This License and the rights granted hereunder will terminate:\n\n         (a) automatically without notice from Apple if You fail to comply with any term(s) of this License and fail to cure such breach within 30 days of becoming aware of such breach;\n\n         (b) immediately in the event of the circumstances described in Section 13.5(b); or\n\n         (c) automatically without notice from Apple if You, at any time during the term of this License, commence an action for patent infringement against Apple.\n\n      12.2 Effect of Termination. Upon termination, You agree to immediately stop any further use, reproduction, modification, sublicensing and distribution of the Covered Code and to destroy all copies of the Covered Code that are in your possession or control. All sublicenses to the Covered Code which have been properly granted prior to termination shall survive any termination of this License. Provisions which, by their nature, should remain in effect beyond the termination of this License shall survive, including but not limited to Sections 3, 5, 8, 9, 10, 11, 12.2 and 13. Neither party will be liable to the other for compensation, indemnity or damages of any sort solely as a result of terminating this License in accordance with its terms, and termination of this License will be without prejudice to any other right or remedy of either party.\n\n   13. Miscellaneous.\n\n      13.1 Government End Users. The Covered Code is a \"commercial item\" as defined in FAR 2.101. Government software and technical data rights in the Covered Code include only those rights customarily provided to the public as defined in this License. This customary commercial license in technical data and software is provided in accordance with FAR 12.211 (Technical Data) and 12.212 (Computer Software) and, for Department of Defense purchases, DFAR 252.227-7015 (Technical Data -- Commercial Items) and 227.7202-3 (Rights in Commercial Computer Software or Computer Software Documentation). Accordingly, all U.S. Government End Users acquire Covered Code with only those rights set forth herein.\n\n      13.2 Relationship of Parties. This License will not be construed as creating an agency, partnership, joint venture or any other form of legal association between You and Apple, and You will not represent to the contrary, whether expressly, by implication, appearance or otherwise.\n\n      13.3 Independent Development. Nothing in this License will impair Apple's right to acquire, license, develop, have others develop for it, market and/or distribute technology or products that perform the same or similar functions as, or otherwise compete with, Modifications, Larger Works, technology or products that You may\n\n      develop, produce, market or distribute.\n\n      13.4 Waiver; Construction. Failure by Apple to enforce any provision of this License will not be deemed a waiver of future enforcement of that or any other provision. Any law or regulation which provides that the language of a contract shall be construed against the drafter will not apply to this License.\n\n      13.5 Severability. (a) If for any reason a court of competent jurisdiction finds any provision of this License, or portion thereof, to be unenforceable, that provision of the License will be enforced to the maximum extent permissible so as to effect the economic benefits and intent of the parties, and the remainder of this License will continue in full force and effect. (b) Notwithstanding the foregoing, if applicable law prohibits or restricts You from fully and/or specifically complying with Sections 2 and/or 3 or prevents the enforceability of either of those Sections, this License will immediately terminate and You must immediately discontinue any use of the Covered Code and destroy all copies of it that are in your possession or control.\n\n      13.6 Dispute Resolution. Any litigation or other dispute resolution between You and Apple relating to this License shall take place in the Northern District of California, and You and Apple hereby consent to the personal jurisdiction of, and venue in, the state and federal courts within that District with respect to this License. The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded.\n\n      13.7 Entire Agreement; Governing Law. This License constitutes the entire agreement between the parties with respect to the subject matter hereof. This License shall be governed by the laws of the United States and the State of California, except that body of California law concerning conflicts of law.\n\n      Where You are located in the province of Quebec, Canada, the following clause applies: The parties hereby confirm that they have requested that this License and all related documents be drafted in English. Les parties ont exige que le present contrat et tous les documents connexes soient rediges en anglais. EXHIBIT A.\n\n\"Portions Copyright (c) 1999-2000 Apple Computer, Inc. All Rights Reserved. This file contains Original Code and/or Modifications of Original Code as defined in and that are subject to the Apple Public Source License Version 1.1 (the \"License\"). You may not use this file except in compliance with the License. Please obtain a copy of the License at http://www.apple.com/publicsource and read it before using this file.\n\nThe Original Code and all software distributed under the License are distributed on an \"AS IS\" basis, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT. Please see the License for the specific language governing rights and limitations under the License.\""],"licenseIds":["APSL-1.1"],"keywords":["1 1 april","1 april 19","april 19 1999","19 1999 please","1 1 affected","1 affected original","code means only","means only those","only those specific","those specific portions","specific portions of","portions of original","code that allegedly","that allegedly infringe","allegedly infringe upon","infringe upon any","upon any party","rights or are","or are otherwise","are otherwise the","otherwise the subject","of infringement 1","infringement 1 2","1 2 applicable","2 applicable patent","longer c if","covered code containing","code containing modifications","containing modifications made","by you inform","you inform others","inform others of","others of how","to obtain those","obtain those modifications","those modifications by","submitting the information","the information found","modifications html if","html if available","if available and","available and d","portion of or","of or functionality","or functionality implemented","functionality implemented by","implemented by the","of infringement apple","infringement apple may","at its option","its option a","necessary for apple","and you to","or c suspend","c suspend your","suspend your rights","reproduce modify sublicense","distribute the affected","original code until","code until a","until a final","a final determination","final determination of","determination of the","of the claim","the claim is","claim is made","made by a","a court or","court or governmental","or governmental administrative","governmental administrative agency","administrative agency of","agency of competent","competent jurisdiction and","jurisdiction and apple","and apple lifts","apple lifts the","lifts the suspension","the suspension as","suspension as set","forth below such","below such suspension","such suspension of","of rights will","rights will be","will be effective","be effective immediately","license upon such","upon such final","such final determination","final determination being","determination being made","being made if","made if apple","if apple is","apple is legally","is legally able","legally able without","able without the","without the payment","royalty to resume","to resume use","resume use reproduction","of the affected","code apple will","apple will lift","will lift the","lift the suspension","the suspension of","of rights to","to the affected","original code by","code by posting","by posting a","posting a notice","license if apple","if apple suspends","apple suspends your","suspends your rights","rights to affected","to affected original","original code nothing","be construed to","construed to restrict","to restrict you","restrict you at","you at your","your option and","option and subject","applicable law from","law from replacing","from replacing the","replacing the affected","code with non","with non infringing","non infringing code","infringing code or","code or independently","or independently negotiating","independently negotiating for","negotiating for necessary","for necessary rights","necessary rights from","rights from such","from such third","third party 9","party 9 2","1999 2000 apple","2000 apple computer","version 1 1 april","1 1 april 19","1 april 19 1999","april 19 1999 please","19 1999 please read","1 or subsequent version","license 1 1 affected","1 1 affected original","1 affected original code","affected original code means","original code means only","code means only those","means only those specific","only those specific portions","those specific portions of","specific portions of original","portions of original code","of original code that","original code that allegedly","code that allegedly infringe","that allegedly infringe upon","allegedly infringe upon any","infringe upon any party","upon any party s","any party s intellectual","property rights or are","rights or are otherwise","or are otherwise the","are otherwise the subject","otherwise the subject of","claim of infringement 1","of infringement 1 2","infringement 1 2 applicable","1 2 applicable patent","2 applicable patent rights","is longer c if","longer c if you","c if you deploy","deploy covered code containing","covered code containing modifications","code containing modifications made","containing modifications made by","made by you inform","by you inform others","you inform others of","inform others of how","others of how to","how to obtain those","to obtain those modifications","obtain those modifications by"]},{"licenseTexts":["Apple Public Source License Ver. 1.2\n\n   1. General; Definitions. This License applies to any program or other work which Apple Computer, Inc. (\"Apple\") makes publicly available and which contains a notice placed by Apple identifying such program or work as \"Original Code\" and stating that it is subject to the terms of this Apple Public Source License version 1.2 (or subsequent version thereof) (\"License\"). As used in this License:\n\n      1.1 \"Applicable Patent Rights\" mean: (a) in the case where Apple is the grantor of rights, (i) claims of patents that are now or hereafter acquired, owned by or assigned to Apple and (ii) that cover subject matter contained in the Original Code, but only to the extent necessary to use, reproduce and/or distribute the Original Code without infringement; and (b) in the case where You are the grantor of rights, (i) claims of patents that are now or hereafter acquired, owned by or assigned to You and (ii) that cover subject matter in Your Modifications, taken alone or in combination with Original Code.\n\n      1.2 \"Contributor\" means any person or entity that creates or contributes to the creation of Modifications.\n\n      1.3 \"Covered Code\" means the Original Code, Modifications, the combination of Original Code and any Modifications, and/or any respective portions thereof.\n\n      1.4 \"Deploy\" means to use, sublicense or distribute Covered Code other than for Your internal research and development (R\u0026D) and/or Personal Use, and includes without limitation, any and all internal use or distribution of Covered Code within Your business or organization except for R\u0026D use and/or Personal Use, as well as direct or indirect sublicensing or distribution of Covered Code by You to any third party in any form or manner.\n\n      1.5 \"Larger Work\" means a work which combines Covered Code or portions thereof with code not governed by the terms of this License.\n\n      1.6 \"Modifications\" mean any addition to, deletion from, and/or change to, the substance and/or structure of the Original Code, any previous Modifications, the combination of Original Code and any previous Modifications, and/or any respective portions thereof. When code is released as a series of files, a Modification is: (a) any addition to or deletion from the contents of a file containing Covered Code; and/or (b) any new file or other representation of computer program statements that contains any part of Covered Code.\n\n      1.7 \"Original Code\" means (a) the Source Code of a program or other work as originally made available by Apple under this License, including the Source Code of any updates or upgrades to such programs or works made available by Apple under this License, and that has been expressly identified by Apple as such in the header file(s) of such work; and (b) the object code compiled from such Source Code and originally made available by Apple under this License.\n\n      1.8 \"Personal Use\" means use of Covered Code by an individual solely for his or her personal, private and non-commercial purposes. An individual's use of Covered Code in his or her capacity as an officer, employee, member, independent contractor or agent of a corporation, business or organization (commercial or non-commercial) does not qualify as Personal Use.\n\n      1.9 \"Source Code\" means the human readable form of a program or other work that is suitable for making modifications to it, including all modules it contains, plus any associated interface definition files, scripts used to control compilation and installation of an executable (object code).\n\n      1.10 \"You\" or \"Your\" means an individual or a legal entity exercising rights under this License. For legal entities, \"You\" or \"Your\" includes any entity which controls, is controlled by, or is under common control with, You, where \"control\" means (a) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (b) ownership of fifty percent (50%) or more of the outstanding shares or beneficial ownership of such entity.\n\n   2. Permitted Uses; Conditions \u0026 Restrictions.Subject to the terms and conditions of this License, Apple hereby grants You, effective on the date You accept this License and download the Original Code, a world-wide, royalty-free, non-exclusive license, to the extent of Apple's Applicable Patent Rights and copyrights covering the Original Code, to do the following:\n\n      2.1 You may use, reproduce, display, perform, modify and distribute Original Code, with or without Modifications, solely for Your internal research and development and/or Personal Use, provided that in each instance:\n\n         (a) You must retain and reproduce in all copies of Original Code the copyright and other proprietary notices and disclaimers of Apple as they appear in the Original Code, and keep intact all notices in the Original Code that refer to this License; and\n\n         (b) You must include a copy of this License with every copy of Source Code of Covered Code and documentation You distribute, and You may not offer or impose any terms on such Source Code that alter or restrict this License or the recipients' rights hereunder, except as permitted under Section 6.\n\n      2.2 You may use, reproduce, display, perform, modify and Deploy Covered Code, provided that in each instance:\n\n         (a) You must satisfy all the conditions of Section 2.1 with respect to the Source Code of the Covered Code;\n\n         (b) You must duplicate, to the extent it does not already exist, the notice in Exhibit A in each file of the Source Code of all Your Modifications, and cause the modified files to carry prominent notices stating that You changed the files and the date of any change;\n\n         (c) You must make Source Code of all Your Deployed Modifications publicly available under the terms of this License, including the license grants set forth in Section 3 below, for as long as you Deploy the Covered Code or twelve (12) months from the date of initial Deployment, whichever is longer. You should preferably distribute the Source Code of Your Deployed Modifications electronically (e.g. download from a web site); and\n\n         (d) if You Deploy Covered Code in object code, executable form only, You must include a prominent notice, in the code itself as well as in related documentation, stating that Source Code of the Covered Code is available under the terms of this License with information on how and where to obtain such Source Code.\n\n      2.3 You expressly acknowledge and agree that although Apple and each Contributor grants the licenses to their respective portions of the Covered Code set forth herein, no assurances are provided by Apple or any Contributor that the Covered Code does not infringe the patent or other intellectual property rights of any other entity. Apple and each Contributor disclaim any liability to You for claims brought by any other entity based on infringement of intellectual property rights or otherwise. As a condition to exercising the rights and licenses granted hereunder, You hereby assume sole responsibility to secure any other intellectual property rights needed, if any. For example, if a third party patent license is required to allow You to distribute the Covered Code, it is Your responsibility to acquire that license before distributing the Covered Code.\n\n   3. Your Grants. In consideration of, and as a condition to, the licenses granted to You under this License:\n\n      (a) You hereby grant to Apple and all third parties a non-exclusive, royalty-free license, under Your Applicable Patent Rights and other intellectual property rights (other than patent) owned or controlled by You, to use, reproduce, display, perform, modify, distribute and Deploy Your Modifications of the same scope and extent as Apple's licenses under Sections 2.1 and 2.2; and\n\n      (b) You hereby grant to Apple and its subsidiaries a non-exclusive, worldwide, royalty-free, perpetual and irrevocable license, under Your Applicable Patent Rights and other intellectual property rights (other than patent) owned or controlled by You, to use, reproduce, display, perform, modify or have modified (for Apple and/or its subsidiaries), sublicense and distribute Your Modifications, in any form, through multiple tiers of distribution.\n\n   4. Larger Works. You may create a Larger Work by combining Covered Code with other code not governed by the terms of this License and distribute the Larger Work as a single product. In each such instance, You must make sure the requirements of this License are fulfilled for the Covered Code or any portion thereof.\n\n   5. Limitations on Patent License. Except as expressly stated in Section 2, no other patent rights, express or implied, are granted by Apple herein. Modifications and/or Larger Works may require additional patent licenses from Apple which Apple may grant in its sole discretion.\n\n   6. Additional Terms. You may choose to offer, and to charge a fee for, warranty, support, indemnity or liability obligations and/or other rights consistent with the scope of the license granted herein (\"Additional Terms\") to one or more recipients of Covered Code. However, You may do so only on Your own behalf and as Your sole responsibility, and not on behalf of Apple or any Contributor. You must obtain the recipient's agreement that any such Additional Terms are offered by You alone, and You hereby agree to indemnify, defend and hold Apple and every Contributor harmless for any liability incurred by or claims asserted against Apple or such Contributor by reason of any such Additional Terms.\n\n   7. Versions of the License. Apple may publish revised and/or new versions of this License from time to time. Each version will be given a distinguishing version number. Once Original Code has been published under a particular version of this License, You may continue to use it under the terms of that version. You may also choose to use such Original Code under the terms of any subsequent version of this License published by Apple. No one other than Apple has the right to modify the terms applicable to Covered Code created under this License.\n\n   8. NO WARRANTY OR SUPPORT. The Covered Code may contain in whole or in part pre-release, untested, or not fully tested works. The Covered Code may contain errors that could cause failures or loss of data, and may be incomplete or contain inaccuracies. You expressly acknowledge and agree that use of the Covered Code, or any portion thereof, is at Your sole and entire risk. THE COVERED CODE IS PROVIDED \"AS IS\" AND WITHOUT WARRANTY, UPGRADES OR SUPPORT OF ANY KIND AND APPLE AND APPLE'S LICENSOR(S) (COLLECTIVELY REFERRED TO AS \"APPLE\" FOR THE PURPOSES OF SECTIONS 8 AND 9) AND ALL CONTRIBUTORS EXPRESSLY DISCLAIM ALL WARRANTIES AND/OR CONDITIONS, EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES AND/OR CONDITIONS OF MERCHANTABILITY, OF SATISFACTORY QUALITY, OF FITNESS FOR A PARTICULAR PURPOSE, OF ACCURACY, OF QUIET ENJOYMENT, AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. APPLE AND EACH CONTRIBUTOR DOES NOT WARRANT AGAINST INTERFERENCE WITH YOUR ENJOYMENT OF THE COVERED CODE, THAT THE FUNCTIONS CONTAINED IN THE COVERED CODE WILL MEET YOUR REQUIREMENTS, THAT THE OPERATION OF THE COVERED CODE WILL BE UNINTERRUPTED OR ERROR-FREE, OR THAT DEFECTS IN THE COVERED CODE WILL BE CORRECTED. NO ORAL OR WRITTEN INFORMATION OR ADVICE GIVEN BY APPLE, AN APPLE AUTHORIZED REPRESENTATIVE OR ANY CONTRIBUTOR SHALL CREATE A WARRANTY. You acknowledge that the Covered Code is not intended for use in the operation of nuclear facilities, aircraft navigation, communication systems, or air traffic control machines in which case the failure of the Covered Code could lead to death, personal injury, or severe physical or environmental damage.\n\n   9. LIMITATION OF LIABILITY. TO THE EXTENT NOT PROHIBITED BY LAW, IN NO EVENT SHALL APPLE OR ANY CONTRIBUTOR BE LIABLE FOR ANY INCIDENTAL, SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES ARISING OUT OF OR RELATING TO THIS LICENSE OR YOUR USE OR INABILITY TO USE THE COVERED CODE, OR ANY PORTION THEREOF, WHETHER UNDER A THEORY OF CONTRACT, WARRANTY, TORT (INCLUDING NEGLIGENCE), PRODUCTS LIABILITY OR OTHERWISE, EVEN IF APPLE OR SUCH CONTRIBUTOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES AND NOTWITHSTANDING THE FAILURE OF ESSENTIAL PURPOSE OF ANY REMEDY. SOME JURISDICTIONS DO NOT ALLOW THE LIMITATION OF LIABILITY OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THIS LIMITATION MAY NOT APPLY TO YOU. In no event shall Apple's total liability to You for all damages (other than as may be required by applicable law) under this License exceed the amount of fifty dollars ($50.00).\n\n   10. Trademarks. This License does not grant any rights to use the trademarks or trade names \"Apple\", \"Apple Computer\", \"Mac OS X\", \"Mac OS X Server\", \"QuickTime\", \"QuickTime Streaming Server\" or any other trademarks or trade names belonging to Apple (collectively \"Apple Marks\") or to any trademark or trade name belonging to any Contributor. No Apple Marks may be used to endorse or promote products derived from the Original Code other than as permitted by and in strict compliance at all times with Apple's third party trademark usage guidelines which are posted at http://www.apple.com/legal/guidelinesfor3rdparties.html.\n\n   11. Ownership. Subject to the licenses granted under this License, each Contributor retains all rights, title and interest in and to any Modifications made by such Contributor. Apple retains all rights, title and interest in and to the Original Code and any Modifications made by or on behalf of Apple (\"Apple Modifications\"), and such Apple Modifications will not be automatically subject to this License. Apple may, at its sole discretion, choose to license such Apple Modifications under this License, or on different terms from those contained in this License or may choose not to license them at all.\n\n   12. Termination.\n\n      12.1 Termination. This License and the rights granted hereunder will terminate:\n\n         (a) automatically without notice from Apple if You fail to comply with any term(s) of this License and fail to cure such breach within 30 days of becoming aware of such breach;\n\n         (b) immediately in the event of the circumstances described in Section 13.5(b); or\n\n         (c) automatically without notice from Apple if You, at any time during the term of this License, commence an action for patent infringement against Apple.\n\n      12.2 Effect of Termination. Upon termination, You agree to immediately stop any further use, reproduction, modification, sublicensing and distribution of the Covered Code and to destroy all copies of the Covered Code that are in your possession or control. All sublicenses to the Covered Code which have been properly granted prior to termination shall survive any termination of this License. Provisions which, by their nature, should remain in effect beyond the termination of this License shall survive, including but not limited to Sections 3, 5, 8, 9, 10, 11, 12.2 and 13. No party will be liable to any other for compensation, indemnity or damages of any sort solely as a result of terminating this License in accordance with its terms, and termination of this License will be without prejudice to any other right or remedy of any party.\n\n   13. Miscellaneous.\n\n      13.1 Government End Users. The Covered Code is a \"commercial item\" as defined in FAR 2.101. Government software and technical data rights in the Covered Code include only those rights customarily provided to the public as defined in this License. This customary commercial license in technical data and software is provided in accordance with FAR 12.211 (Technical Data) and 12.212 (Computer Software) and, for Department of Defense purchases, DFAR 252.227-7015 (Technical Data -- Commercial Items) and 227.7202-3 (Rights in Commercial Computer Software or Computer Software Documentation). Accordingly, all U.S. Government End Users acquire Covered Code with only those rights set forth herein.\n\n      13.2 Relationship of Parties. This License will not be construed as creating an agency, partnership, joint venture or any other form of legal association between or amongYou, Apple or any Contributor, and You will not represent to the contrary, whether expressly, by implication, appearance or otherwise.\n\n      13.3 Independent Development. Nothing in this License will impair Apple's right to acquire, license, develop, have others develop for it, market and/or distribute technology or products that perform the same or similar functions as, or otherwise compete with, Modifications, Larger Works, technology or products that You may develop, produce, market or distribute.\n\n      13.4 Waiver; Construction. Failure by Apple or any Contributor to enforce any provision of this License will not be deemed a waiver of future enforcement of that or any other provision. Any law or regulation which provides that the language of a contract shall be construed against the drafter will not apply to this License.\n\n      13.5 Severability. (a) If for any reason a court of competent jurisdiction finds any provision of this License, or portion thereof, to be unenforceable, that provision of the License will be enforced to the maximum extent permissible so as to effect the economic benefits and intent of the parties, and the remainder of this License will continue in full force and effect. (b) Notwithstanding the foregoing, if applicable law prohibits or restricts You from fully and/or specifically complying with Sections 2 and/or 3 or prevents the enforceability of either of those Sections, this License will immediately terminate and You must immediately discontinue any use of the Covered Code and destroy all copies of it that are in your possession or control.\n\n      13.6 Dispute Resolution. Any litigation or other dispute resolution between You and Apple relating to this License shall take place in the Northern District of California, and You and Apple hereby consent to the personal jurisdiction of, and venue in, the state and federal courts within that District with respect to this License. The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded.\n\n      13.7 Entire Agreement; Governing Law. This License constitutes the entire agreement between the parties with respect to the subject matter hereof. This License shall be governed by the laws of the United States and the State of California, except that body of California law concerning conflicts of law.\n\n      Where You are located in the province of Quebec, Canada, the following clause applies: The parties hereby confirm that they have requested that this License and all related documents be drafted in English. Les parties ont exigé que le présent contrat et tous les documents connexes soient rédigés en anglais. EXHIBIT A.\n\n\"Portions Copyright (c) 1999-2001 Apple Computer, Inc. All Rights Reserved.\n\nThis file contains Original Code and/or Modifications of Original Code as defined in and that are subject to the Apple Public Source License Version 1.2 (the 'License'). You may not use this file except in compliance with the License. Please obtain a copy of the License at http://www.apple.com/publicsource and read it before using this file.\n\nThe Original Code and all software distributed under the License are distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. Please see the License for the specific language governing rights and limitations under the License.\""],"licenseIds":["APSL-1.2"],"keywords":["source license ver","license ver 1","ver 1 2","2 1 general","2 or subsequent","thereof license as","site and d","code 2 3","x server quicktime","server quicktime quicktime","contributor no apple","between or amongyou","or amongyou apple","amongyou apple or","c 1999 2001","1999 2001 apple","2001 apple computer","public source license ver","source license ver 1","license ver 1 2","ver 1 2 1","1 2 1 general","2 1 general definitions","computer inc apple makes","1 2 or subsequent","2 or subsequent version","version thereof license as","thereof license as used","6 2 2 you","web site and d","site and d if","source code 2 3","code 2 3 you","os x server quicktime","x server quicktime quicktime","server quicktime quicktime streaming","any contributor no apple","contributor no apple marks","association between or amongyou","between or amongyou apple","or amongyou apple or","amongyou apple or any","copyright c 1999 2001","c 1999 2001 apple","1999 2001 apple computer","2001 apple computer inc","apple public source license ver","public source license ver 1","source license ver 1 2","license ver 1 2 1","ver 1 2 1 general","1 2 1 general definitions","2 1 general definitions this","apple computer inc apple makes","computer inc apple makes publicly","version 1 2 or subsequent","1 2 or subsequent version","2 or subsequent version thereof","subsequent version thereof license as","version thereof license as used","thereof license as used in","section 6 2 2 you","6 2 2 you may","a web site and d","web site and d if","site and d if you","such source code 2 3","source code 2 3 you","code 2 3 you expressly","reproduce display perform modify or","mac os x server quicktime","os x server quicktime quicktime","x server quicktime quicktime streaming","server quicktime quicktime streaming server","to any contributor no apple","any contributor no apple marks","contributor no apple marks may","legal association between or amongyou","association between or amongyou apple","between or amongyou apple or","or amongyou apple or any","amongyou apple or any contributor","portions copyright c 1999 2001","copyright c 1999 2001 apple","c 1999 2001 apple computer","1999 2001 apple computer inc","2001 apple computer inc all"]},{"licenseTexts":["APPLE PUBLIC SOURCE LICENSE\n\nVersion 2.0 - August 6, 2003 Please read this License carefully before downloading this software. By downloading or using this software, you are agreeing to be bound by the terms of this License. If you do not or cannot agree to the terms of this License, please do not download or use the software.\n\nApple Note: In January 2007, Apple changed its corporate name from \"Apple Computer, Inc.\" to \"Apple Inc.\" This change has been reflected below and copyright years updated, but no other changes have been made to the APSL 2.0.\n\n   1. General; Definitions. This License applies to any program or other work which Apple Inc. (\"Apple\") makes publicly available and which contains a notice placed by Apple identifying such program or work as \"Original Code\" and stating that it is subject to the terms of this Apple Public Source License version 2.0 (\"License\"). As used in this License:\n\n      1.1 \"Applicable Patent Rights\" mean: (a) in the case where Apple is the grantor of rights, (i) claims of patents that are now or hereafter acquired, owned by or assigned to Apple and (ii) that cover subject matter contained in the Original Code, but only to the extent necessary to use, reproduce and/or distribute the Original Code without infringement; and (b) in the case where You are the grantor of rights, (i) claims of patents that are now or hereafter acquired, owned by or assigned to You and (ii) that cover subject matter in Your Modifications, taken alone or in combination with Original Code.\n\n      1.2 \"Contributor\" means any person or entity that creates or contributes to the creation of Modifications.\n\n      1.3 \"Covered Code\" means the Original Code, Modifications, the combination of Original Code and any Modifications, and/or any respective portions thereof.\n\n      1.4 \"Externally Deploy\" means: (a) to sublicense, distribute or otherwise make Covered Code available, directly or indirectly, to anyone other than You; and/or (b) to use Covered Code, alone or as part of a Larger Work, in any way to provide a service, including but not limited to delivery of content, through electronic communication with a client other than You.\n\n      1.5 \"Larger Work\" means a work which combines Covered Code or portions thereof with code not governed by the terms of this License.\n\n      1.6 \"Modifications\" mean any addition to, deletion from, and/or change to, the substance and/or structure of the Original Code, any previous Modifications, the combination of Original Code and any previous Modifications, and/or any respective portions thereof. When code is released as a series of files, a Modification is: (a) any addition to or deletion from the contents of a file containing Covered Code; and/or (b) any new file or other representation of computer program statements that contains any part of Covered Code.\n\n      1.7 \"Original Code\" means (a) the Source Code of a program or other work as originally made available by Apple under this License, including the Source Code of any updates or upgrades to such programs or works made available by Apple under this License, and that has been expressly identified by Apple as such in the header file(s) of such work; and (b) the object code compiled from such Source Code and originally made available by Apple under this License\n\n      1.8 \"Source Code\" means the human readable form of a program or other work that is suitable for making modifications to it, including all modules it contains, plus any associated interface definition files, scripts used to control compilation and installation of an executable (object code).\n\n      1.9 \"You\" or \"Your\" means an individual or a legal entity exercising rights under this License. For legal entities, \"You\" or \"Your\" includes any entity which controls, is controlled by, or is under common control with, You, where \"control\" means (a) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (b) ownership of fifty percent (50%) or more of the outstanding shares or beneficial ownership of such entity.\n\n   2. Permitted Uses; Conditions \u0026 Restrictions. Subject to the terms and conditions of this License, Apple hereby grants You, effective on the date You accept this License and download the Original Code, a world-wide, royalty-free, non-exclusive license, to the extent of Apple's Applicable Patent Rights and copyrights covering the Original Code, to do the following:\n\n      2.1 Unmodified Code. You may use, reproduce, display, perform, internally distribute within Your organization, and Externally Deploy verbatim, unmodified copies of the Original Code, for commercial or non-commercial purposes, provided that in each instance:\n\n         (a) You must retain and reproduce in all copies of Original Code the copyright and other proprietary notices and disclaimers of Apple as they appear in the Original Code, and keep intact all notices in the Original Code that refer to this License; and\n\n         (b) You must include a copy of this License with every copy of Source Code of Covered Code and documentation You distribute or Externally Deploy, and You may not offer or impose any terms on such Source Code that alter or restrict this License or the recipients' rights hereunder, except as permitted under Section 6.\n\n      2.2 Modified Code. You may modify Covered Code and use, reproduce, display, perform, internally distribute within Your organization, and Externally Deploy Your Modifications and Covered Code, for commercial or non-commercial purposes, provided that in each instance You also meet all of these conditions:\n\n         (a) You must satisfy all the conditions of Section 2.1 with respect to the Source Code of the Covered Code;\n\n         (b) You must duplicate, to the extent it does not already exist, the notice in Exhibit A in each file of the Source Code of all Your Modifications, and cause the modified files to carry prominent notices stating that You changed the files and the date of any change; and\n\n         (c) If You Externally Deploy Your Modifications, You must make Source Code of all Your Externally Deployed Modifications either available to those to whom You have Externally Deployed Your Modifications, or publicly available. Source Code of Your Externally Deployed Modifications must be released under the terms set forth in this License, including the license grants set forth in Section 3 below, for as long as you Externally Deploy the Covered Code or twelve (12) months from the date of initial External Deployment, whichever is longer. You should preferably distribute the Source Code of Your Externally Deployed Modifications electronically (e.g. download from a web site).\n\n      2.3 Distribution of Executable Versions. In addition, if You Externally Deploy Covered Code (Original Code and/or Modifications) in object code, executable form only, You must include a prominent notice, in the code itself as well as in related documentation, stating that Source Code of the Covered Code is available under the terms of this License with information on how and where to obtain such Source Code.\n\n      2.4 Third Party Rights. You expressly acknowledge and agree that although Apple and each Contributor grants the licenses to their respective portions of the Covered Code set forth herein, no assurances are provided by Apple or any Contributor that the Covered Code does not infringe the patent or other intellectual property rights of any other entity. Apple and each Contributor disclaim any liability to You for claims brought by any other entity based on infringement of intellectual property rights or otherwise. As a condition to exercising the rights and licenses granted hereunder, You hereby assume sole responsibility to secure any other intellectual property rights needed, if any. For example, if a third party patent license is required to allow You to distribute the Covered Code, it is Your responsibility to acquire that license before distributing the Covered Code.\n\n   3. Your Grants. In consideration of, and as a condition to, the licenses granted to You under this License, You hereby grant to any person or entity receiving or distributing Covered Code under this License a non-exclusive, royalty-free, perpetual, irrevocable license, under Your Applicable Patent Rights and other intellectual property rights (other than patent) owned or controlled by You, to use, reproduce, display, perform, modify, sublicense, distribute and Externally Deploy Your Modifications of the same scope and extent as Apple's licenses under Sections 2.1 and 2.2 above.\n\n   4. Larger Works. You may create a Larger Work by combining Covered Code with other code not governed by the terms of this License and distribute the Larger Work as a single product. In each such instance, You must make sure the requirements of this License are fulfilled for the Covered Code or any portion thereof.\n\n   5. Limitations on Patent License. Except as expressly stated in Section 2, no other patent rights, express or implied, are granted by Apple herein. Modifications and/or Larger Works may require additional patent licenses from Apple which Apple may grant in its sole discretion.\n\n   6. Additional Terms. You may choose to offer, and to charge a fee for, warranty, support, indemnity or liability obligations and/or other rights consistent with the scope of the license granted herein (\"Additional Terms\") to one or more recipients of Covered Code. However, You may do so only on Your own behalf and as Your sole responsibility, and not on behalf of Apple or any Contributor. You must obtain the recipient's agreement that any such Additional Terms are offered by You alone, and You hereby agree to indemnify, defend and hold Apple and every Contributor harmless for any liability incurred by or claims asserted against Apple or such Contributor by reason of any such Additional Terms.\n\n   7. Versions of the License. Apple may publish revised and/or new versions of this License from time to time. Each version will be given a distinguishing version number. Once Original Code has been published under a particular version of this License, You may continue to use it under the terms of that version. You may also choose to use such Original Code under the terms of any subsequent version of this License published by Apple. No one other than Apple has the right to modify the terms applicable to Covered Code created under this License.\n\n   8. NO WARRANTY OR SUPPORT. The Covered Code may contain in whole or in part pre-release, untested, or not fully tested works. The Covered Code may contain errors that could cause failures or loss of data, and may be incomplete or contain inaccuracies. You expressly acknowledge and agree that use of the Covered Code, or any portion thereof, is at Your sole and entire risk. THE COVERED CODE IS PROVIDED \"AS IS\" AND WITHOUT WARRANTY, UPGRADES OR SUPPORT OF ANY KIND AND APPLE AND APPLE'S LICENSOR(S) (COLLECTIVELY REFERRED TO AS \"APPLE\" FOR THE PURPOSES OF SECTIONS 8 AND 9) AND ALL CONTRIBUTORS EXPRESSLY DISCLAIM ALL WARRANTIES AND/OR CONDITIONS, EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES AND/OR CONDITIONS OF MERCHANTABILITY, OF SATISFACTORY QUALITY, OF FITNESS FOR A PARTICULAR PURPOSE, OF ACCURACY, OF QUIET ENJOYMENT, AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. APPLE AND EACH CONTRIBUTOR DOES NOT WARRANT AGAINST INTERFERENCE WITH YOUR ENJOYMENT OF THE COVERED CODE, THAT THE FUNCTIONS CONTAINED IN THE COVERED CODE WILL MEET YOUR REQUIREMENTS, THAT THE OPERATION OF THE COVERED CODE WILL BE UNINTERRUPTED OR ERROR-FREE, OR THAT DEFECTS IN THE COVERED CODE WILL BE CORRECTED. NO ORAL OR WRITTEN INFORMATION OR ADVICE GIVEN BY APPLE, AN APPLE AUTHORIZED REPRESENTATIVE OR ANY CONTRIBUTOR SHALL CREATE A WARRANTY. You acknowledge that the Covered Code is not intended for use in the operation of nuclear facilities, aircraft navigation, communication systems, or air traffic control machines in which case the failure of the Covered Code could lead to death, personal injury, or severe physical or environmental damage.\n\n   9. LIMITATION OF LIABILITY. TO THE EXTENT NOT PROHIBITED BY LAW, IN NO EVENT SHALL APPLE OR ANY CONTRIBUTOR BE LIABLE FOR ANY INCIDENTAL, SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES ARISING OUT OF OR RELATING TO THIS LICENSE OR YOUR USE OR INABILITY TO USE THE COVERED CODE, OR ANY PORTION THEREOF, WHETHER UNDER A THEORY OF CONTRACT, WARRANTY, TORT (INCLUDING NEGLIGENCE), PRODUCTS LIABILITY OR OTHERWISE, EVEN IF APPLE OR SUCH CONTRIBUTOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES AND NOTWITHSTANDING THE FAILURE OF ESSENTIAL PURPOSE OF ANY REMEDY. SOME JURISDICTIONS DO NOT ALLOW THE LIMITATION OF LIABILITY OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THIS LIMITATION MAY NOT APPLY TO YOU. In no event shall Apple's total liability to You for all damages (other than as may be required by applicable law) under this License exceed the amount of fifty dollars ($50.00).\n\n   10. Trademarks. This License does not grant any rights to use the trademarks or trade names \"Apple\", \"Mac\", \"Mac OS\", \"QuickTime\", \"QuickTime Streaming Server\" or any other trademarks, service marks, logos or trade names belonging to Apple (collectively \"Apple Marks\") or to any trademark, service mark, logo or trade name belonging to any Contributor. You agree not to use any Apple Marks in or as part of the name of products derived from the Original Code or to endorse or promote products derived from the Original Code other than as expressly permitted by and in strict compliance at all times with Apple's third party trademark usage guidelines which are posted at http://www.apple.com/legal/guidelinesfor3rdparties.html.\n\n   11. Ownership. Subject to the licenses granted under this License, each Contributor retains all rights, title and interest in and to any Modifications made by such Contributor. Apple retains all rights, title and interest in and to the Original Code and any Modifications made by or on behalf of Apple (\"Apple Modifications\"), and such Apple Modifications will not be automatically subject to this License. Apple may, at its sole discretion, choose to license such Apple Modifications under this License, or on different terms from those contained in this License or may choose not to license them at all.\n\n   12. Termination.\n\n      12.1 Termination. This License and the rights granted hereunder will terminate:\n\n         (a) automatically without notice from Apple if You fail to comply with any term(s) of this License and fail to cure such breach within 30 days of becoming aware of such breach;\n\n         (b) immediately in the event of the circumstances described in Section 13.5(b); or\n\n         (c) automatically without notice from Apple if You, at any time during the term of this License, commence an action for patent infringement against Apple; provided that Apple did not first commence an action for patent infringement against You in that instance.\n\n      12.2 Effect of Termination. Upon termination, You agree to immediately stop any further use, reproduction, modification, sublicensing and distribution of the Covered Code. All sublicenses to the Covered Code which have been properly granted prior to termination shall survive any termination of this License. Provisions which, by their nature, should remain in effect beyond the termination of this License shall survive, including but not limited to Sections 3, 5, 8, 9, 10, 11, 12.2 and 13. No party will be liable to any other for compensation, indemnity or damages of any sort solely as a result of terminating this License in accordance with its terms, and termination of this License will be without prejudice to any other right or remedy of any party.\n\n   13. Miscellaneous.\n\n      13.1 Government End Users. The Covered Code is a \"commercial item\" as defined in FAR 2.101. Government software and technical data rights in the Covered Code include only those rights customarily provided to the public as defined in this License. This customary commercial license in technical data and software is provided in accordance with FAR 12.211 (Technical Data) and 12.212 (Computer Software) and, for Department of Defense purchases, DFAR 252.227-7015 (Technical Data -- Commercial Items) and 227.7202-3 (Rights in Commercial Computer Software or Computer Software Documentation). Accordingly, all U.S. Government End Users acquire Covered Code with only those rights set forth herein.\n\n      13.2 Relationship of Parties. This License will not be construed as creating an agency, partnership, joint venture or any other form of legal association between or among You, Apple or any Contributor, and You will not represent to the contrary, whether expressly, by implication, appearance or otherwise.\n\n      13.3 Independent Development. Nothing in this License will impair Apple's right to acquire, license, develop, have others develop for it, market and/or distribute technology or products that perform the same or similar functions as, or otherwise compete with, Modifications, Larger Works, technology or products that You may develop, produce, market or distribute.\n\n      13.4 Waiver; Construction. Failure by Apple or any Contributor to enforce any provision of this License will not be deemed a waiver of future enforcement of that or any other provision. Any law or regulation which provides that the language of a contract shall be construed against the drafter will not apply to this License.\n\n      13.5 Severability. (a) If for any reason a court of competent jurisdiction finds any provision of this License, or portion thereof, to be unenforceable, that provision of the License will be enforced to the maximum extent permissible so as to effect the economic benefits and intent of the parties, and the remainder of this License will continue in full force and effect. (b) Notwithstanding the foregoing, if applicable law prohibits or restricts You from fully and/or specifically complying with Sections 2 and/or 3 or prevents the enforceability of either of those Sections, this License will immediately terminate and You must immediately discontinue any use of the Covered Code and destroy all copies of it that are in your possession or control.\n\n      13.6 Dispute Resolution. Any litigation or other dispute resolution between You and Apple relating to this License shall take place in the Northern District of California, and You and Apple hereby consent to the personal jurisdiction of, and venue in, the state and federal courts within that District with respect to this License. The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded.\n\n      13.7 Entire Agreement; Governing Law. This License constitutes the entire agreement between the parties with respect to the subject matter hereof. This License shall be governed by the laws of the United States and the State of California, except that body of California law concerning conflicts of law.\n\n      Where You are located in the province of Quebec, Canada, the following clause applies: The parties hereby confirm that they have requested that this License and all related documents be drafted in English. Les parties ont exigé que le présent contrat et tous les documents connexes soient rédigés en anglais. EXHIBIT A.\n\n\"Portions Copyright (c) 1999-2007 Apple Inc. All Rights Reserved.\n\nThis file contains Original Code and/or Modifications of Original Code as defined in and that are subject to the Apple Public Source License Version 2.0 (the 'License'). You may not use this file except in compliance with the License. Please obtain a copy of the License at http://www.opensource.apple.com/apsl/ and read it before using this file.\n\nThe Original Code and all software distributed under the License are distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. Please see the License for the specific language governing rights and limitations under the License.\""],"licenseIds":["APSL-2.0"],"keywords":["2 0 august","0 august 6","august 6 2003","6 2003 please","2003 please read","the software apple","software apple note","apple note in","note in january","in january 2007","january 2007 apple","2007 apple changed","apple changed its","changed its corporate","its corporate name","corporate name from","name from apple","from apple computer","computer inc to","inc to apple","to apple inc","apple inc this","inc this change","this change has","change has been","has been reflected","been reflected below","reflected below and","below and copyright","and copyright years","copyright years updated","years updated but","updated but no","but no other","no other changes","other changes have","been made to","to the apsl","the apsl 2","apsl 2 0","which apple inc","0 license as","1 4 externally","4 externally deploy","deploy means a","means a to","a to sublicense","to sublicense distribute","otherwise make covered","make covered code","code available directly","available directly or","indirectly to anyone","than you and","b to use","to use covered","use covered code","covered code alone","code alone or","larger work in","way to provide","provide a service","service including but","limited to delivery","to delivery of","delivery of content","of content through","content through electronic","through electronic communication","electronic communication with","communication with a","with a client","a client other","client other than","you 1 5","2 1 unmodified","1 unmodified code","unmodified code you","externally deploy verbatim","deploy verbatim unmodified","verbatim unmodified copies","distribute or externally","externally deploy and","deploy and you","2 2 modified","2 modified code","modified code you","modify covered code","and use reproduce","instance you also","change and c","deployed modifications either","modifications either available","either available to","available to those","to those to","whom you have","you have externally","have externally deployed","externally deployed your","deployed your modifications","modifications or publicly","or publicly available","publicly available source","deployed modifications must","modifications must be","must be released","the terms set","terms set forth","as you externally","externally deploy the","of initial external","initial external deployment","external deployment whichever","web site 2","site 2 3","2 3 distribution","executable versions in","versions in addition","externally deploy covered","covered code original","code original code","modifications in object","2 4 third","4 third party","party rights you","rights you expressly","grant to any","or entity receiving","entity receiving or","receiving or distributing","or distributing covered","distributing covered code","free perpetual irrevocable","perpetual irrevocable license","sublicense distribute and","distribute and externally","2 above 4","above 4 larger","names apple mac","apple mac mac","mac mac os","mac os quicktime","os quicktime quicktime","use any apple","any apple marks","apple marks in","code or to","than as expressly","as expressly permitted","expressly permitted by","against apple provided","apple provided that","provided that apple","that apple did","apple did not","did not first","not first commence","first commence an","infringement against you","against you in","you in that","in that instance","that instance 12","instance 12 2","covered code all","code all sublicenses","among you apple","you apple or","c 1999 2007","1999 2007 apple","http www opensource","www opensource apple","opensource apple com","apple com apsl","com apsl and","apsl and read","version 2 0 august","2 0 august 6","0 august 6 2003","august 6 2003 please","6 2003 please read","2003 please read this","software by downloading or","downloading or using this","or using this software","use the software apple","the software apple note","software apple note in","apple note in january","note in january 2007","in january 2007 apple","january 2007 apple changed","2007 apple changed its","apple changed its corporate","changed its corporate name","its corporate name from","corporate name from apple","name from apple computer","from apple computer inc"]},{"licenseTexts":["This is APREAMBL.TEX, version 1.10e, written by Hans-Hermann Bode\n\n(HHBODE@DOSUNI1.BITNET), for the BibTeX `adaptable' family, version 1.10.\n\nSee the file APREAMBL.DOC for a detailed documentation.\n\nThis program is distributed WITHOUT ANY WARRANTY, express or implied.\n\nCopyright (C) 1991, 1992 Hans-Hermann Bode\n\nPermission is granted to make and distribute verbatim copies of this document provided that the copyright notice and this permission notice are preserved on all copies.\n\nPermission is granted to copy and distribute modified versions of this document under the conditions for verbatim copying, provided that the entire resulting derived work is distributed under the terms of a permission notice identical to this one."],"licenseIds":["Abstyles"],"keywords":["this is apreambl","is apreambl tex","apreambl tex version","tex version 1","version 1 10e","1 10e written","10e written by","written by hans","by hans hermann","hermann bode hhbode","bode hhbode dosuni1","hhbode dosuni1 bitnet","dosuni1 bitnet for","bitnet for the","for the bibtex","the bibtex adaptable","bibtex adaptable family","adaptable family version","family version 1","version 1 10","1 10 see","10 see the","the file apreambl","file apreambl doc","apreambl doc for","doc for a","for a detailed","a detailed documentation","detailed documentation this","documentation this program","is distributed without","distributed without any","or implied copyright","implied copyright c","c 1991 1992","1991 1992 hans","1992 hans hermann","hermann bode permission","bode permission is","this document provided","this is apreambl tex","is apreambl tex version","apreambl tex version 1","tex version 1 10e","version 1 10e written","1 10e written by","10e written by hans","written by hans hermann","by hans hermann bode","hans hermann bode hhbode","hermann bode hhbode dosuni1","bode hhbode dosuni1 bitnet","hhbode dosuni1 bitnet for","dosuni1 bitnet for the","bitnet for the bibtex","for the bibtex adaptable","the bibtex adaptable family","bibtex adaptable family version","adaptable family version 1","family version 1 10","version 1 10 see","1 10 see the","10 see the file","see the file apreambl","the file apreambl doc","file apreambl doc for","apreambl doc for a","doc for a detailed","for a detailed documentation","a detailed documentation this","detailed documentation this program","documentation this program is","program is distributed without","is distributed without any","distributed without any warranty","express or implied copyright","or implied copyright c","implied copyright c 1991","copyright c 1991 1992","c 1991 1992 hans","1991 1992 hans hermann","1992 hans hermann bode","hans hermann bode permission","hermann bode permission is","bode permission is granted","of this document provided","this document provided that","versions of this document","of this document under","this is apreambl tex version","is apreambl tex version 1","apreambl tex version 1 10e","tex version 1 10e written","version 1 10e written by","1 10e written by hans","10e written by hans hermann","written by hans hermann bode","by hans hermann bode hhbode","hans hermann bode hhbode dosuni1","hermann bode hhbode dosuni1 bitnet","bode hhbode dosuni1 bitnet for","hhbode dosuni1 bitnet for the","dosuni1 bitnet for the bibtex","bitnet for the bibtex adaptable","for the bibtex adaptable family","the bibtex adaptable family version","bibtex adaptable family version 1","adaptable family version 1 10","family version 1 10 see","version 1 10 see the","1 10 see the file","10 see the file apreambl","see the file apreambl doc","the file apreambl doc for","file apreambl doc for a","apreambl doc for a detailed","doc for a detailed documentation","for a detailed documentation this","a detailed documentation this program","detailed documentation this program is","documentation this program is distributed","this program is distributed without","program is distributed without any","is distributed without any warranty","distributed without any warranty express","warranty express or implied copyright","express or implied copyright c","or implied copyright c 1991","implied copyright c 1991 1992","copyright c 1991 1992 hans","c 1991 1992 hans hermann","1991 1992 hans hermann bode","1992 hans hermann bode permission","hans hermann bode permission is","hermann bode permission is granted","bode permission is granted to","copies of this document provided","of this document provided that","this document provided that the","document provided that the copyright","modified versions of this document","versions of this document under","of this document under the","this document under the conditions","document under the conditions for"]},{"licenseTexts":["Adobe Systems Incorporated(r) Source Code License Agreement Copyright(c) 2006 Adobe Systems Incorporated. All rights reserved.\n\nPlease read this Source Code License Agreement carefully before using the source code.\n\nAdobe Systems Incorporated grants to you a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license, to reproduce, prepare derivative works of, publicly display, publicly perform, and distribute this source code and such derivative works in source or object code form without any attribution requirements.\n\nThe name \"Adobe Systems Incorporated\" must not be used to endorse or promote products derived from the source code without prior written permission.\n\nYou agree to indemnify, hold harmless and defend Adobe Systems Incorporated from and against any loss, damage, claims or lawsuits, including attorney's fees that arise or result from your use or distribution of the source code.\n\nTHIS SOURCE CODE IS PROVIDED \"AS IS\" AND \"WITH ALL FAULTS\", WITHOUT ANY TECHNICAL SUPPORT OR ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. ALSO, THERE IS NO WARRANTY OF NON-INFRINGEMENT, TITLE OR QUIET ENJOYMENT. IN NO EVENT SHALL MACROMEDIA OR ITS SUPPLIERS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOURCE CODE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."],"licenseIds":["Adobe-2006"],"keywords":["systems incorporated r","incorporated r source","r source code","license agreement copyright","agreement copyright c","c 2006 adobe","2006 adobe systems","read this source","license agreement carefully","agreement carefully before","carefully before using","before using the","source code adobe","code adobe systems","systems incorporated grants","incorporated grants to","code and such","code form without","form without any","without any attribution","any attribution requirements","attribution requirements the","requirements the name","the name adobe","name adobe systems","systems incorporated must","incorporated must not","source code without","written permission you","permission you agree","to indemnify hold","indemnify hold harmless","harmless and defend","and defend adobe","defend adobe systems","systems incorporated from","incorporated from and","any loss damage","loss damage claims","damage claims or","claims or lawsuits","or lawsuits including","lawsuits including attorney","including attorney s","s fees that","fees that arise","that arise or","arise or result","or result from","code this source","is and with","and with all","all faults without","faults without any","without any technical","any technical support","support or any","or any expressed","are disclaimed also","disclaimed also there","also there is","non infringement title","infringement title or","title or quiet","or quiet enjoyment","quiet enjoyment in","enjoyment in no","event shall macromedia","shall macromedia or","macromedia or its","or its suppliers","its suppliers be","suppliers be liable","code even if","adobe systems incorporated r","systems incorporated r source","incorporated r source code","r source code license","code license agreement copyright","license agreement copyright c","agreement copyright c 2006","copyright c 2006 adobe","c 2006 adobe systems","2006 adobe systems incorporated","please read this source","read this source code","this source code license","code license agreement carefully","license agreement carefully before","agreement carefully before using","carefully before using the","before using the source","using the source code","the source code adobe","source code adobe systems","code adobe systems incorporated","adobe systems incorporated grants","systems incorporated grants to","incorporated grants to you","display publicly perform and","publicly perform and distribute","perform and distribute this","this source code and","source code and such","code and such derivative","object code form without","code form without any","form without any attribution","without any attribution requirements","any attribution requirements the","attribution requirements the name","requirements the name adobe","the name adobe systems","name adobe systems incorporated","adobe systems incorporated must","systems incorporated must not","incorporated must not be","derived from the source","the source code without","source code without prior","prior written permission you","written permission you agree","permission you agree to","agree to indemnify hold","to indemnify hold harmless","indemnify hold harmless and","hold harmless and defend","harmless and defend adobe","and defend adobe systems","defend adobe systems incorporated","adobe systems incorporated from","systems incorporated from and","incorporated from and against","against any loss damage","any loss damage claims","loss damage claims or","damage claims or lawsuits","claims or lawsuits including","or lawsuits including attorney","lawsuits including attorney s","including attorney s fees","attorney s fees that","s fees that arise","fees that arise or","that arise or result","arise or result from","or result from your","your use or distribution","the source code this","source code this source","code this source code","this source code is","as is and with","is and with all","and with all faults","with all faults without","all faults without any","faults without any technical","without any technical support","any technical support or","technical support or any","support or any expressed","or any expressed or","purpose are disclaimed also","are disclaimed also there","disclaimed also there is","also there is no","is no warranty of","no warranty of non","of non infringement title","non infringement title or","infringement title or quiet","title or quiet enjoyment","or quiet enjoyment in","quiet enjoyment in no","enjoyment in no event","no event shall macromedia","event shall macromedia or","shall macromedia or its","macromedia or its suppliers","or its suppliers be","its suppliers be liable","suppliers be liable for","this source code even","source code even if","code even if advised","adobe systems incorporated r source","systems incorporated r source code","incorporated r source code license","r source code license agreement","source code license agreement copyright","code license agreement copyright c","license agreement copyright c 2006","agreement copyright c 2006 adobe","copyright c 2006 adobe systems","c 2006 adobe systems incorporated","2006 adobe systems incorporated all","incorporated all rights reserved please","reserved please read this source","please read this source code"]},{"licenseTexts":["Copyright (c) 1997,1998,2002,2007 Adobe Systems Incorporated\n\nPermission is hereby granted, free of charge, to any person obtaining a copy of this documentation file to use, copy, publish, distribute, sublicense, and/or sell copies of the documentation, and to permit others to do the same, provided that:\n\n   - No modification, editing or other alteration of this document is allowed; and\n\n   - The above copyright notice and this permission notice shall be included in all copies of the documentation.\n\nPermission is hereby granted, free of charge, to any person obtaining a copy of this documentation file, to create their own derivative works from the content of this document to use, copy, publish, distribute, sublicense, and/or sell the derivative works, and to permit others to do the same, provided that the derived work is not represented as being a copy or version of this document.\n\nAdobe shall not be liable to any party for any loss of revenue or profit or for indirect, incidental, special, consequential, or other similar damages, whether based on tort (including without limitation negligence or strict liability), contract or other legal or equitable grounds even if Adobe has been advised or had reason to know of the possibility of such damages. The Adobe materials are provided on an \"AS IS\" basis. Adobe specifically disclaims all express, statutory, or implied warranties relating to the Adobe materials, including but not limited to those concerning merchantability or fitness for a particular purpose or non-infringement of any third party rights regarding the Adobe materials."],"licenseIds":["Adobe-Glyph"],"keywords":["copyright c 1997","c 1997 1998","1997 1998 2002","1998 2002 2007","2002 2007 adobe","2007 adobe systems","systems incorporated permission","incorporated permission is","file to use","provided that no","that no modification","no modification editing","modification editing or","editing or other","or other alteration","alteration of this","document is allowed","allowed and the","the documentation permission","documentation permission is","to create their","create their own","their own derivative","works from the","from the content","document to use","or sell the","sell the derivative","that the derived","is not represented","not represented as","represented as being","being a copy","copy or version","or version of","this document adobe","document adobe shall","adobe shall not","any loss of","of revenue or","revenue or profit","or profit or","profit or for","or for indirect","for indirect incidental","incidental special consequential","special consequential or","other similar damages","similar damages whether","damages whether based","based on tort","on tort including","contract or other","or equitable grounds","equitable grounds even","grounds even if","even if adobe","if adobe has","adobe has been","been advised or","advised or had","or had reason","had reason to","reason to know","to know of","know of the","damages the adobe","adobe materials are","materials are provided","are provided on","is basis adobe","basis adobe specifically","adobe specifically disclaims","all express statutory","express statutory or","statutory or implied","implied warranties relating","warranties relating to","to the adobe","adobe materials including","materials including but","limited to those","to those concerning","those concerning merchantability","concerning merchantability or","party rights regarding","rights regarding the","regarding the adobe","copyright c 1997 1998","c 1997 1998 2002","1997 1998 2002 2007","1998 2002 2007 adobe","2002 2007 adobe systems","2007 adobe systems incorporated","adobe systems incorporated permission","systems incorporated permission is","incorporated permission is hereby","documentation file to use","file to use copy","the documentation and to","documentation and to permit","same provided that no","provided that no modification","that no modification editing","no modification editing or","modification editing or other","editing or other alteration","or other alteration of","other alteration of this","alteration of this document","this document is allowed","document is allowed and","is allowed and the","allowed and the above","of the documentation permission","the documentation permission is","documentation permission is hereby","documentation file to create","file to create their","to create their own","create their own derivative","their own derivative works","own derivative works from","derivative works from the","works from the content","from the content of","content of this document","of this document to","this document to use","document to use copy","and or sell the","or sell the derivative","sell the derivative works","works and to permit","same provided that the","provided that the derived","that the derived work","derived work is not","work is not represented","is not represented as","not represented as being","represented as being a","as being a copy","being a copy or","a copy or version","copy or version of","or version of this","version of this document","of this document adobe","this document adobe shall","document adobe shall not","adobe shall not be","party for any loss","for any loss of","any loss of revenue","loss of revenue or","of revenue or profit","revenue or profit or","or profit or for","profit or for indirect","or for indirect incidental","for indirect incidental special","indirect incidental special consequential","incidental special consequential or","special consequential or other","consequential or other similar","or other similar damages","other similar damages whether","similar damages whether based","damages whether based on","whether based on tort","based on tort including","on tort including without","liability contract or other","contract or other legal","or other legal or","legal or equitable grounds","or equitable grounds even","equitable grounds even if","grounds even if adobe","even if adobe has","if adobe has been","adobe has been advised","has been advised or","been advised or had","advised or had reason","or had reason to","had reason to know","reason to know of","to know of the","know of the possibility","such damages the adobe","damages the adobe materials","the adobe materials are","adobe materials are provided","materials are provided on","are provided on an","as is basis adobe","is basis adobe specifically","basis adobe specifically disclaims"]},{"licenseTexts":["(C) 1988, 1989 by Adobe Systems Incorporated. All rights reserved.\n\nThis file may be freely copied and redistributed as long as:\n\n   1) This entire notice continues to be included in the file,\n\n   2) If the file has been modified in any way, a notice of such modification is conspicuously indicated.\n\nPostScript, Display PostScript, and Adobe are registered trademarks of Adobe Systems Incorporated.\n\nTHE INFORMATION BELOW IS FURNISHED AS IS, IS SUBJECT TO CHANGE WITHOUT NOTICE, AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY ADOBE SYSTEMS INCORPORATED. ADOBE SYSTEMS INCORPORATED ASSUMES NO RESPONSIBILITY OR LIABILITY FOR ANY ERRORS OR INACCURACIES, MAKES NO WARRANTY OF ANY KIND (EXPRESS, IMPLIED OR STATUTORY) WITH RESPECT TO THIS INFORMATION, AND EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES OF MERCHANTABILITY, FITNESS FOR PARTICULAR PURPOSES AND NONINFRINGEMENT OF THIRD PARTY RIGHTS."],"licenseIds":["Afmparse"],"keywords":["c 1988 1989","1988 1989 by","1989 by adobe","freely copied and","copied and redistributed","and redistributed as","redistributed as long","long as 1","as 1 this","1 this entire","entire notice continues","notice continues to","continues to be","the file 2","file 2 if","the file has","modified in any","way a notice","modification is conspicuously","is conspicuously indicated","conspicuously indicated postscript","indicated postscript display","postscript display postscript","display postscript and","postscript and adobe","and adobe are","adobe are registered","are registered trademarks","trademarks of adobe","of adobe systems","systems incorporated the","incorporated the information","the information below","information below is","below is furnished","is furnished as","furnished as is","as is is","is is subject","subject to change","to change without","change without notice","without notice and","notice and should","as a commitment","a commitment by","commitment by adobe","systems incorporated adobe","incorporated adobe systems","systems incorporated assumes","incorporated assumes no","assumes no responsibility","responsibility or liability","errors or inaccuracies","or inaccuracies makes","inaccuracies makes no","or statutory with","statutory with respect","to this information","this information and","information and expressly","and expressly disclaims","expressly disclaims any","and all warranties","all warranties of","fitness for particular","for particular purposes","particular purposes and","purposes and noninfringement","c 1988 1989 by","1988 1989 by adobe","1989 by adobe systems","reserved this file may","be freely copied and","freely copied and redistributed","copied and redistributed as","and redistributed as long","redistributed as long as","as long as 1","long as 1 this","as 1 this entire","1 this entire notice","this entire notice continues","entire notice continues to","notice continues to be","continues to be included","included in the file","in the file 2","the file 2 if","file 2 if the","if the file has","the file has been","file has been modified","been modified in any","modified in any way","any way a notice","way a notice of","a notice of such","notice of such modification","of such modification is","such modification is conspicuously","modification is conspicuously indicated","is conspicuously indicated postscript","conspicuously indicated postscript display","indicated postscript display postscript","postscript display postscript and","display postscript and adobe","postscript and adobe are","and adobe are registered","adobe are registered trademarks","are registered trademarks of","registered trademarks of adobe","trademarks of adobe systems","of adobe systems incorporated","adobe systems incorporated the","systems incorporated the information","incorporated the information below","the information below is","information below is furnished","below is furnished as","is furnished as is","furnished as is is","as is is subject","is is subject to","is subject to change","subject to change without","to change without notice","change without notice and","without notice and should","notice and should not","should not be construed","construed as a commitment","as a commitment by","a commitment by adobe","commitment by adobe systems","adobe systems incorporated adobe","systems incorporated adobe systems","incorporated adobe systems incorporated","adobe systems incorporated assumes","systems incorporated assumes no","incorporated assumes no responsibility","assumes no responsibility or","no responsibility or liability","responsibility or liability for","or liability for any","liability for any errors","any errors or inaccuracies","errors or inaccuracies makes","or inaccuracies makes no","inaccuracies makes no warranty","implied or statutory with","or statutory with respect","statutory with respect to","respect to this information","to this information and","this information and expressly","information and expressly disclaims","and expressly disclaims any","expressly disclaims any and","any and all warranties","and all warranties of","all warranties of merchantability","merchantability fitness for particular","fitness for particular purposes","for particular purposes and","particular purposes and noninfringement","purposes and noninfringement of","c 1988 1989 by adobe","1988 1989 by adobe systems","1989 by adobe systems incorporated","by adobe systems incorporated all","rights reserved this file may","reserved this file may be","file may be freely copied","may be freely copied and","be freely copied and redistributed","freely copied and redistributed as","copied and redistributed as long","and redistributed as long as","redistributed as long as 1","as long as 1 this","long as 1 this entire","as 1 this entire notice","1 this entire notice continues","this entire notice continues to","entire notice continues to be","notice continues to be included","continues to be included in","be included in the file","included in the file 2","in the file 2 if","the file 2 if the","file 2 if the file","2 if the file has","if the file has been","the file has been modified","file has been modified in","has been modified in any","been modified in any way","modified in any way a"]},{"licenseTexts":["Aladdin Free Public License\n\n(Version 8, November 18, 1999) Copyright (C) 1994, 1995, 1997, 1998, 1999 Aladdin Enterprises,\n\nMenlo Park, California, U.S.A. All rights reserved. NOTE: This License is not the same as any of the GNU Licenses published by the Free Software Foundation. Its terms are substantially different from those of the GNU Licenses. If you are familiar with the GNU Licenses, please read this license with extra care.\n\nAladdin Enterprises hereby grants to anyone the permission to apply this License to their own work, as long as the entire License (including the above notices and this paragraph) is copied with no changes, additions, or deletions except for changing the first paragraph of Section 0 to include a suitable description of the work to which the license is being applied and of the person or entity that holds the copyright in the work, and, if the License is being applied to a work created in a country other than the United States, replacing the first paragraph of Section 6 with an appropriate reference to the laws of the appropriate country.\n\n   0. Subject Matter\n\n   This License applies to the computer program known as \"Aladdin Ghostscript.\" The \"Program\", below, refers to such program. The Program is a copyrighted work whose copyright is held by Aladdin Enterprises (the \"Licensor\"). Please note that Aladdin Ghostscript is neither the program known as \"GNU Ghostscript\" nor the version of Ghostscript available for commercial licensing from Artifex Software Inc.\n\n   A \"work based on the Program\" means either the Program or any derivative work of the Program, as defined in the United States Copyright Act of 1976, such as a translation or a modification.\n\n   BY MODIFYING OR DISTRIBUTING THE PROGRAM (OR ANY WORK BASED ON THE PROGRAM), YOU INDICATE YOUR ACCEPTANCE OF THIS LICENSE TO DO SO, AND ALL ITS TERMS AND CONDITIONS FOR COPYING, DISTRIBUTING OR MODIFYING THE PROGRAM OR WORKS BASED ON IT. NOTHING OTHER THAN THIS LICENSE GRANTS YOU PERMISSION TO MODIFY OR DISTRIBUTE THE PROGRAM OR ITS DERIVATIVE WORKS. THESE ACTIONS ARE PROHIBITED BY LAW. IF YOU DO NOT ACCEPT THESE TERMS AND CONDITIONS, DO NOT MODIFY OR DISTRIBUTE THE PROGRAM.\n\n   1. Licenses.\n\n   Licensor hereby grants you the following rights, provided that you comply with all of the restrictions set forth in this License and provided, further, that you distribute an unmodified copy of this License with the Program:\n\n      (a) You may copy and distribute literal (i.e., verbatim) copies of the Program's source code as you receive it throughout the world, in any medium.\n\n      (b) You may modify the Program, create works based on the Program and distribute copies of such throughout the world, in any medium.\n\n   2. Restrictions.\n\n   This license is subject to the following restrictions:\n\n      (a) Distribution of the Program or any work based on the Program by a commercial organization to any third party is prohibited if any payment is made in connection with such distribution, whether directly (as in payment for a copy of the Program) or indirectly (as in payment for some service related to the Program, or payment for some product or service that includes a copy of the Program \"without charge\"; these are only examples, and not an exhaustive enumeration of prohibited activities). The following methods of distribution involving payment shall not in and of themselves be a violation of this restriction:\n\n         (i) Posting the Program on a public access information storage and retrieval service for which a fee is received for retrieving information (such as an on-line service), provided that the fee is not content-dependent (i.e., the fee would be the same for retrieving the same volume of information consisting of random data) and that access to the service and to the Program is available independent of any other product or service. An example of a service that does not fall under this section is an on-line service that is operated by a company and that is only available to customers of that company. (This is not an exhaustive enumeration.)\n\n         (ii) Distributing the Program on removable computer-readable media, provided that the files containing the Program are reproduced entirely and verbatim on such media, that all information on such media be redistributable for non-commercial purposes without charge, and that such media are distributed by themselves (except for accompanying documentation) independent of any other product or service. Examples of such media include CD-ROM, magnetic tape, and optical storage media. (This is not intended to be an exhaustive list.) An example of a distribution that does not fall under this section is a CD-ROM included in a book or magazine. (This is not an exhaustive enumeration.)\n\n      (b) Activities other than copying, distribution and modification of the Program are not subject to this License and they are outside its scope. Functional use (running) of the Program is not restricted, and any output produced through the use of the Program is subject to this license only if its contents constitute a work based on the Program (independent of having been made by running the Program).\n\n      (c) You must meet all of the following conditions with respect to any work that you distribute or publish that in whole or in part contains or is derived from the Program or any part thereof (\"the Work\"):\n\n         (i) If you have modified the Program, you must cause the Work to carry prominent notices stating that you have modified the Program's files and the date of any change. In each source file that you have modified, you must include a prominent notice that you have modified the file, including your name, your e-mail address (if any), and the date and purpose of the change;\n\n         (ii) You must cause the Work to be licensed as a whole and at no charge to all third parties under the terms of this License;\n\n         (iii) If the Work normally reads commands interactively when run, you must cause it, at each time the Work commences operation, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty). Such notice must also state that users may redistribute the Work only under the conditions of this License and tell the user how to view the copy of this License included with the Work. (Exceptions: if the Program is interactive but normally prints or displays such an announcement only at the request of a user, such as in an \"About box\", the Work is required to print or display the notice only under the same circumstances; if the Program itself is interactive but does not normally print such an announcement, the Work is not required to print an announcement.);\n\n         (iv) You must accompany the Work with the complete corresponding machine-readable source code, delivered on a medium customarily used for software interchange. The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable code. If you distribute with the Work any component that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, you must also distribute the source code of that component if you have it and are allowed to do so;\n\n         (v) If you distribute any written or printed material at all with the Work, such material must include either a written copy of this License, or a prominent written indication that the Work is covered by this License and written instructions for printing and/or displaying the copy of the License on the distribution medium;\n\n         (vi) You may not impose any further restrictions on the recipient's exercise of the rights granted herein.\n\n         If distribution of executable or object code is made by offering the equivalent ability to copy from a designated place, then offering equivalent ability to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source code along with the object code.\n\n   3. Reservation of Rights.\n\n   No rights are granted to the Program except as expressly set forth herein. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance.\n\n   4. Other Restrictions.\n\n   If the distribution and/or use of the Program is restricted in certain countries for any reason, Licensor may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License.\n\n   5. Limitations.\n\n   THE PROGRAM IS PROVIDED TO YOU \"AS IS,\" WITHOUT WARRANTY. THERE IS NO WARRANTY FOR THE PROGRAM, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.\n\n   IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL LICENSOR, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\n   6. General.\n\n   This License is governed by the laws of the State of California, U.S.A., excluding choice of law rules.\n\n   If any part of this License is found to be in conflict with the law, that part shall be interpreted in its broadest meaning consistent with the law, and no other parts of the License shall be affected.\n\n   For United States Government users, the Program is provided with RESTRICTED RIGHTS. If you are a unit or agency of the United States Government or are acquiring the Program for any such unit or agency, the following apply:\n\n   If the unit or agency is the Department of Defense (\"DOD\"), the Program and its documentation are classified as \"commercial computer software\" and \"commercial computer software documentation\" respectively and, pursuant to DFAR Section 227.7202, the Government is acquiring the Program and its documentation in accordance with the terms of this License. If the unit or agency is other than DOD, the Program and its documentation are classified as \"commercial computer software\" and \"commercial computer software documentation\" respectively and, pursuant to FAR Section 12.212, the Government is acquiring the Program and its documentation in accordance with the terms of this License."],"licenseIds":["Aladdin"],"keywords":["aladdin free public","free public license","license version 8","version 8 november","8 november 18","november 18 1999","18 1999 copyright","1994 1995 1997","1995 1997 1998","1997 1998 1999","1998 1999 aladdin","1999 aladdin enterprises","aladdin enterprises menlo","enterprises menlo park","menlo park california","park california u","not the same","same as any","as any of","gnu licenses published","licenses published by","software foundation its","foundation its terms","terms are substantially","are substantially different","substantially different from","gnu licenses if","you are familiar","are familiar with","familiar with the","gnu licenses please","licenses please read","license with extra","with extra care","extra care aladdin","care aladdin enterprises","aladdin enterprises hereby","enterprises hereby grants","grants to anyone","to anyone the","anyone the permission","the permission to","permission to apply","license to their","to their own","their own work","own work as","as the entire","entire license including","the above notices","above notices and","paragraph is copied","is copied with","copied with no","with no changes","no changes additions","changes additions or","additions or deletions","or deletions except","deletions except for","except for changing","for changing the","changing the first","of section 0","section 0 to","0 to include","include a suitable","a suitable description","suitable description of","being applied and","applied and of","entity that holds","that holds the","holds the copyright","work and if","if the license","being applied to","a work created","work created in","created in a","a country other","country other than","than the united","united states replacing","states replacing the","replacing the first","section 6 with","6 with an","with an appropriate","an appropriate reference","appropriate reference to","of the appropriate","the appropriate country","appropriate country 0","country 0 subject","0 subject matter","subject matter this","matter this license","to the computer","computer program known","known as aladdin","as aladdin ghostscript","aladdin ghostscript the","ghostscript the program","such program the","is a copyrighted","a copyrighted work","copyrighted work whose","work whose copyright","whose copyright is","copyright is held","is held by","held by aladdin","by aladdin enterprises","aladdin enterprises the","enterprises the licensor","the licensor please","licensor please note","note that aladdin","that aladdin ghostscript","aladdin ghostscript is","ghostscript is neither","is neither the","neither the program","the program known","known as gnu","as gnu ghostscript","gnu ghostscript nor","ghostscript nor the","nor the version","version of ghostscript","of ghostscript available","ghostscript available for","available for commercial","for commercial licensing","commercial licensing from","licensing from artifex","from artifex software","artifex software inc","software inc a","inc a work","states copyright act","copyright act of","act of 1976","of 1976 such","1976 such as","a translation or","translation or a","a modification by","modification by modifying","it nothing other","not accept these","and conditions do","program 1 licenses","1 licenses licensor","licenses licensor hereby","you the following","following rights provided","rights provided that","of the restrictions","and provided further","provided further that","further that you","distribute an unmodified","program a you","and distribute literal","distribute literal i","literal i e","i e verbatim","e verbatim copies","receive it throughout","it throughout the","any medium b","medium b you","the program create","program create works","create works based","of such throughout","such throughout the","any medium 2","medium 2 restrictions","2 restrictions this","restrictions this license","restrictions a distribution","program by a","by a commercial","a commercial organization","commercial organization to","organization to any","party is prohibited","is prohibited if","prohibited if any","if any payment","any payment is","payment is made","made in connection","with such distribution","such distribution whether","distribution whether directly","whether directly as"]},{"licenseTexts":["Copyright (c) 1995-1999 The Apache Group. All rights reserved.\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n   2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   3. All advertising materials mentioning features or use of this software must display the following acknowledgment: \"This product includes software developed by the Apache Group for use in the Apache HTTP server project (http://www.apache.org/) .\"\n\n   4. The name \"Apache Server\" and \"Apache Group\" must not be used to endorse or promote products derived from this software without prior written permission. For written permission, please contact apache@apache.org .\n\n   5. Products derived from this software may not be called \"Apache\" nor may \"Apache\" appear in their name, without prior written permission of the Apache Group .\n\n   6. Redistributions of any form whatsoever must retain the following acknowledgment:\n\n   \"This product includes software developed by the Apache Group for use in the Apache HTTP server project (http://www.apache.org/) .\"\n\nTHIS SOFTWARE IS PROVIDED BY THE APACHE GROUP ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE APACHE GROUP OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\nThis software consists of voluntary contributions made by many individuals on behalf of the Apache Group and was originally based on public domain software written at the National Center for Supercomputing Applications, University of Illinois, Urbana-Champaign. For more information on the Apache Group and the Apache HTTP server project, please see \u003chttp://www.apache.org/\u003e."],"licenseIds":["Apache-1.0"],"keywords":["1995 1999 the","1999 the apache","apache group all","apache org 4","name apache server","apache server and","server and apache","and apache group","apache group must","group must not","called apache nor","apache nor may","may apache appear","apache appear in","apache group 6","group 6 redistributions","apache org this","apache group as","group as is","apache group or","group or its","group and was","based on public","on public domain","domain software written","software written at","urbana champaign for","champaign for more","server project please","c 1995 1999 the","1995 1999 the apache","1999 the apache group","the apache group all","apache group all rights","www apache org 4","apache org 4 the","org 4 the name","the name apache server","name apache server and","apache server and apache","server and apache group","and apache group must","apache group must not","group must not be","be called apache nor","called apache nor may","apache nor may apache","nor may apache appear","may apache appear in","apache appear in their","the apache group 6","apache group 6 redistributions","group 6 redistributions of","www apache org this","apache org this software","provided by the apache","the apache group as","apache group as is","group as is and","shall the apache group","the apache group or","apache group or its","group or its contributors","apache group and was","group and was originally","originally based on public","based on public domain","on public domain software","public domain software written","domain software written at","software written at the","illinois urbana champaign for","urbana champaign for more","champaign for more information","on the apache group","apache group and the","group and the apache","and the apache http","http server project please","server project please see","copyright c 1995 1999 the","c 1995 1999 the apache","1995 1999 the apache group","1999 the apache group all","the apache group all rights","apache group all rights reserved","http www apache org 4","www apache org 4 the","apache org 4 the name","org 4 the name apache","4 the name apache server","the name apache server and","name apache server and apache","apache server and apache group","server and apache group must","and apache group must not","apache group must not be","group must not be used","not be called apache nor","be called apache nor may","called apache nor may apache","apache nor may apache appear","nor may apache appear in","may apache appear in their","apache appear in their name","permission of the apache group","of the apache group 6","the apache group 6 redistributions","apache group 6 redistributions of","group 6 redistributions of any","http www apache org this","www apache org this software","apache org this software is","is provided by the apache","provided by the apache group","by the apache group as","the apache group as is","apache group as is and","group as is and any","event shall the apache group","shall the apache group or","the apache group or its","apache group or its contributors","group or its contributors be","behalf of the apache group","of the apache group and","the apache group and was","apache group and was originally","group and was originally based","was originally based on public","originally based on public domain","based on public domain software","on public domain software written","public domain software written at","domain software written at the","software written at the national","of illinois urbana champaign for","illinois urbana champaign for more","urbana champaign for more information","champaign for more information on","information on the apache group","on the apache group and","the apache group and the","apache group and the apache","group and the apache http","and the apache http server","apache http server project please","http server project please see","server project please see http"]},{"licenseTexts":["Apache License 1.1 Copyright (c) 2000 The Apache Software Foundation. All rights reserved.\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n   2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   3. The end-user documentation included with the redistribution, if any, must include the following acknowledgment:\n\n   \"This product includes software developed by the Apache Software Foundation (http://www.apache.org/) .\"\n\n   Alternately, this acknowledgment may appear in the software itself, if and wherever such third-party acknowledgments normally appear.\n\n   4. The name \"Apache\" and \"Apache Software Foundation\" must not be used to endorse or promote products derived from this software without prior written permission. For written permission, please contact apache@apache.org .\n\n   5. Products derived from this software may not be called \"Apache\" [ex. \"Jakarta,\" \"Apache,\" or \"Apache Commons,\"] nor may \"Apache\" [ex. the names] appear in their name, without prior written permission of the Apache Software Foundation.\n\nTHIS SOFTWARE IS PROVIDED ''AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\nThis software consists of voluntary contributions made by many individuals on behalf of the Apache Software Foundation. For more information on the Apache Software Foundation, please see http://www.apache.org/. Portions of this software are based upon public domain software originally written at the National Center for Supercomputing Applications, University of Illinois, Urbana-Champaign."],"licenseIds":["Apache-1.1"],"keywords":["apache license 1","c 2000 the","2000 the apache","software foundation http","foundation http www","apache org alternately","name apache and","apache and apache","and apache software","software foundation must","foundation must not","called apache ex","apache ex jakarta","ex jakarta apache","jakarta apache or","apache or apache","or apache commons","apache commons nor","commons nor may","may apache ex","apache ex the","ex the names","the names appear","names appear in","software foundation this","foundation this software","software foundation for","foundation for more","software foundation please","foundation please see","apache org portions","org portions of","software are based","are based upon","based upon public","upon public domain","domain software originally","software originally written","originally written at","apache license 1 1","license 1 1 copyright","1 copyright c 2000","copyright c 2000 the","c 2000 the apache","2000 the apache software","apache software foundation all","by the apache software","apache software foundation http","software foundation http www","foundation http www apache","www apache org alternately","apache org alternately this","the name apache and","name apache and apache","apache and apache software","and apache software foundation","apache software foundation must","software foundation must not","foundation must not be","be called apache ex","called apache ex jakarta","apache ex jakarta apache","ex jakarta apache or","jakarta apache or apache","apache or apache commons","or apache commons nor","apache commons nor may","commons nor may apache","nor may apache ex","may apache ex the","apache ex the names","ex the names appear","the names appear in","names appear in their","apache software foundation this","software foundation this software","foundation this software is","shall the apache software","apache software foundation or","software foundation or its","apache software foundation for","software foundation for more","foundation for more information","on the apache software","apache software foundation please","software foundation please see","foundation please see http","www apache org portions","apache org portions of","org portions of this","this software are based","software are based upon","are based upon public","based upon public domain","upon public domain software","public domain software originally","domain software originally written","software originally written at","originally written at the","apache license 1 1 copyright","license 1 1 copyright c","1 1 copyright c 2000","1 copyright c 2000 the","copyright c 2000 the apache","c 2000 the apache software","2000 the apache software foundation","the apache software foundation all","apache software foundation all rights","foundation all rights reserved redistribution","developed by the apache software","by the apache software foundation","the apache software foundation http","apache software foundation http www","software foundation http www apache","foundation http www apache org","http www apache org alternately","www apache org alternately this","apache org alternately this acknowledgment","appear 4 the name apache","4 the name apache and","the name apache and apache","name apache and apache software","apache and apache software foundation","and apache software foundation must","apache software foundation must not","software foundation must not be","foundation must not be used","not be called apache ex","be called apache ex jakarta","called apache ex jakarta apache","apache ex jakarta apache or","ex jakarta apache or apache","jakarta apache or apache commons","apache or apache commons nor","or apache commons nor may","apache commons nor may apache","commons nor may apache ex","nor may apache ex the","may apache ex the names","apache ex the names appear","ex the names appear in","the names appear in their","names appear in their name","permission of the apache software","the apache software foundation this","apache software foundation this software","software foundation this software is","foundation this software is provided","event shall the apache software","shall the apache software foundation","the apache software foundation or","apache software foundation or its","software foundation or its contributors","behalf of the apache software","the apache software foundation for","apache software foundation for more","software foundation for more information","foundation for more information on","information on the apache software","on the apache software foundation","the apache software foundation please","apache software foundation please see","software foundation please see http","foundation please see http www","http www apache org portions","www apache org portions of","apache org portions of this","org portions of this software","of this software are based","this software are based upon","software are based upon public","are based upon public domain","based upon public domain software","upon public domain software originally","public domain software originally written","domain software originally written at","software originally written at the","originally written at the national"]},{"licenseTexts":["Apache License\n\nVersion 2.0, January 2004\n\nhttp://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n   1. Definitions.\n\n      \n\n      \"License\" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.\n\n      \n\n      \"Licensor\" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.\n\n      \n\n      \"Legal Entity\" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, \"control\" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.\n\n      \n\n      \"You\" (or \"Your\") shall mean an individual or Legal Entity exercising permissions granted by this License.\n\n      \n\n      \"Source\" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.\n\n      \n\n      \"Object\" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.\n\n      \n\n      \"Work\" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).\n\n      \n\n      \"Derivative Works\" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.\n\n      \n\n      \"Contribution\" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, \"submitted\" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as \"Not a Contribution.\"\n\n      \n\n      \"Contributor\" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.\n\n   2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.\n\n   3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.\n\n   4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:\n\n      (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and\n\n      (b) You must cause any modified files to carry prominent notices stating that You changed the files; and\n\n      (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and\n\n      (d) If the Work includes a \"NOTICE\" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.\n\n      You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.\n\n   5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.\n\n   6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.\n\n   7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.\n\n   8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.\n\n   9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS\n\nAPPENDIX: How to apply the Apache License to your work.\n\nTo apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets \"[]\" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same \"printed page\" as the copyright notice for easier identification within third-party archives.\n\nCopyright [yyyy] [name of copyright owner]\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\n\nyou may not use this file except in compliance with the License.\n\nYou may obtain a copy of the License at\n\nhttp://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\n\ndistributed under the License is distributed on an \"AS IS\" BASIS,\n\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n\nSee the License for the specific language governing permissions and\n\nlimitations under the License."],"licenseIds":["Apache-2.0"],"keywords":["2 0 january","0 january 2004","january 2004 http","2004 http www","org licenses terms","licenses terms and","version 2 0 january","2 0 january 2004","0 january 2004 http","january 2004 http www","2004 http www apache","apache org licenses terms","org licenses terms and","licenses terms and conditions","license 2 0 unless","license version 2 0 january","version 2 0 january 2004","2 0 january 2004 http","0 january 2004 http www","january 2004 http www apache","2004 http www apache org","www apache org licenses terms","apache org licenses terms and","org licenses terms and conditions","licenses terms and conditions for","how to apply the apache","work to apply the apache","owner licensed under the apache","license at http www apache","licenses license 2 0 unless","license 2 0 unless required"]},{"licenseTexts":["The \"Artistic License\"\n\nPreamble\n\nThe intent of this document is to state the conditions under which a Package may be copied, such that the Copyright Holder maintains some semblance of artistic control over the development of the package, while giving the users of the package the right to use and distribute the Package in a more-or-less customary fashion, plus the right to make reasonable modifications.\n\nDefinitions:\n\n\"Package\" refers to the collection of files distributed by the Copyright Holder, and derivatives of that collection of files created through textual modification.\n\n\"Standard Version\" refers to such a Package if it has not been modified, or has been modified in accordance with the wishes of the Copyright Holder as specified below.\n\n\"Copyright Holder\" is whoever is named in the copyright or copyrights for the package.\n\n\"You\" is you, if you're thinking about copying or distributing this Package.\n\n\"Reasonable copying fee\" is whatever you can justify on the basis of media cost, duplication charges, time of people involved, and so on. (You will not be required to justify it to the Copyright Holder, but only to the computing community at large as a market that must bear the fee.)\n\n\"Freely Available\" means that no fee is charged for the item itself, though there may be fees involved in handling the item. It also means that recipients of the item may redistribute it under the same conditions they received it.\n\n   1. You may make and give away verbatim copies of the source form of the Standard Version of this Package without restriction, provided that you duplicate all of the original copyright notices and associated disclaimers.\n\n   2. You may apply bug fixes, portability fixes and other modifications derived from the Public Domain or from the Copyright Holder. A Package modified in such a way shall still be considered the Standard Version.\n\n   3. You may otherwise modify your copy of this Package in any way, provided that you insert a prominent notice in each changed file stating how and when you changed that file, and provided that you do at least ONE of the following:\n\n      a) place your modifications in the Public Domain or otherwise make them Freely Available, such as by posting said modifications to Usenet or an equivalent medium, or placing the modifications on a major archive site such as uunet.uu.net, or by allowing the Copyright Holder to include your modifications in the Standard Version of the Package.\n\n      b) use the modified Package only within your corporation or organization.\n\n      c) rename any non-standard executables so the names do not conflict with standard executables, which must also be provided, and provide a separate manual page for each non-standard executable that clearly documents how it differs from the Standard Version.\n\n      d) make other distribution arrangements with the Copyright Holder.\n\n   4. You may distribute the programs of this Package in object code or executable form, provided that you do at least ONE of the following:\n\n      a) distribute a Standard Version of the executables and library files, together with instructions (in the manual page or equivalent) on where to get the Standard Version.\n\n      b) accompany the distribution with the machine-readable source of the Package with your modifications.\n\n      c) give non-standard executables non-standard names, and clearly document the differences in manual pages (or equivalent), together with instructions on where to get the Standard Version.\n\n      d) make other distribution arrangements with the Copyright Holder.\n\n   5. You may charge a reasonable copying fee for any distribution of this Package. You may charge any fee you choose for support of this Package. You may not charge a fee for this Package itself. However, you may distribute this Package in aggregate with other (possibly commercial) programs as part of a larger (possibly commercial) software distribution provided that you do not advertise this Package as a product of your own. You may embed this Package's interpreter within an executable of yours (by linking); this shall be construed as a mere form of aggregation, provided that the complete Standard Version of the interpreter is so embedded.\n\n   6. The scripts and library files supplied as input to or produced as output from the programs of this Package do not automatically fall under the copyright of this Package, but belong to whoever generated them, and may be sold commercially, and may be aggregated with this Package. If such scripts or library files are aggregated with this Package via the so-called \"undump\" or \"unexec\" methods of producing a binary executable image, then distribution of such an image shall neither be construed as a distribution of this Package nor shall it fall under the restrictions of Paragraphs 3 and 4, provided that you do not represent such an executable image as a Standard Version of this Package.\n\n   7. C subroutines (or comparably compiled subroutines in other languages) supplied by you and linked into this Package in order to emulate subroutines and variables of the language defined by this Package shall not be considered part of this Package, but are the equivalent of input as in Paragraph 6, provided these subroutines do not change the language in any way that would cause it to fail the regression tests for the language.\n\n   8. Aggregation of this Package with a commercial distribution is always permitted provided that the use of this Package is embedded; that is, when no overt attempt is made to make this Package's interfaces visible to the end user of the commercial distribution. Such use shall not be construed as a distribution of this Package.\n\n   9. The name of the Copyright Holder may not be used to endorse or promote products derived from this software without specific prior written permission.\n\n   10. THIS PACKAGE IS PROVIDED \"AS IS\" AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. The End"],"licenseIds":["Artistic-1.0-Perl"],"keywords":["your own you","own you may","of your own you","your own you may","own you may embed","product of your own you","of your own you may","your own you may embed","own you may embed this","language 8 aggregation of this"]},{"licenseTexts":["The Artistic License\n\nPreamble\n\nThe intent of this document is to state the conditions under which a Package may be copied, such that the Copyright Holder maintains some semblance of artistic control over the development of the package, while giving the users of the package the right to use and distribute the Package in a more-or-less customary fashion, plus the right to make reasonable modifications.\n\nDefinitions:\n\n\"Package\" refers to the collection of files distributed by the Copyright Holder, and derivatives of that collection of files created through textual modification.\n\n\"Standard Version\" refers to such a Package if it has not been modified, or has been modified in accordance with the wishes of the Copyright Holder.\n\n\"Copyright Holder\" is whoever is named in the copyright or copyrights for the package.\n\n\"You\" is you, if you're thinking about copying or distributing this Package.\n\n\"Reasonable copying fee\" is whatever you can justify on the basis of media cost, duplication charges, time of people involved, and so on. (You will not be required to justify it to the Copyright Holder, but only to the computing community at large as a market that must bear the fee.)\n\n\"Freely Available\" means that no fee is charged for the item itself, though there may be fees involved in handling the item. It also means that recipients of the item may redistribute it under the same conditions they received it.\n\n   1. You may make and give away verbatim copies of the source form of the Standard Version of this Package without restriction, provided that you duplicate all of the original copyright notices and associated disclaimers.\n\n   2. You may apply bug fixes, portability fixes and other modifications derived from the Public Domain or from the Copyright Holder. A Package modified in such a way shall still be considered the Standard Version.\n\n   3. You may otherwise modify your copy of this Package in any way, provided that you insert a prominent notice in each changed file stating how and when you changed that file, and provided that you do at least ONE of the following:\n\n      a) place your modifications in the Public Domain or otherwise make them Freely Available, such as by posting said modifications to Usenet or an equivalent medium, or placing the modifications on a major archive site such as ftp.uu.net, or by allowing the Copyright Holder to include your modifications in the Standard Version of the Package.\n\n      b) use the modified Package only within your corporation or organization.\n\n      c) rename any non-standard executables so the names do not conflict with standard executables, which must also be provided, and provide a separate manual page for each non-standard executable that clearly documents how it differs from the Standard Version.\n\n      d) make other distribution arrangements with the Copyright Holder.\n\n   4. You may distribute the programs of this Package in object code or executable form, provided that you do at least ONE of the following:\n\n      a) distribute a Standard Version of the executables and library files, together with instructions (in the manual page or equivalent) on where to get the Standard Version.\n\n      b) accompany the distribution with the machine-readable source of the Package with your modifications.\n\n      c) accompany any non-standard executables with their corresponding Standard Version executables, giving the non-standard executables non-standard names, and clearly documenting the differences in manual pages (or equivalent), together with instructions on where to get the Standard Version.\n\n      d) make other distribution arrangements with the Copyright Holder.\n\n   5. You may charge a reasonable copying fee for any distribution of this Package. You may charge any fee you choose for support of this Package. You may not charge a fee for this Package itself. However, you may distribute this Package in aggregate with other (possibly commercial) programs as part of a larger (possibly commercial) software distribution provided that you do not advertise this Package as a product of your own.\n\n   6. The scripts and library files supplied as input to or produced as output from the programs of this Package do not automatically fall under the copyright of this Package, but belong to whomever generated them, and may be sold commercially, and may be aggregated with this Package.\n\n   7. C or perl subroutines supplied by you and linked into this Package shall not be considered part of this Package.\n\n   8.Aggregation of this Package with a commercial distribution is always permitted provided that the use of this Package is embedded; that is, when no overt attempt is made to make this Package's interfaces visible to the end user of the commercial distribution. Such use shall not be construed as a distribution of this Package.\n\n   9. The name of the Copyright Holder may not be used to endorse or promote products derived from this software without specific prior written permission.\n\n   10. THIS PACKAGE IS PROVIDED \"AS IS\" AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. The End"],"licenseIds":["Artistic-1.0-cl8"],"keywords":["package 8 aggregation","this package 8 aggregation","package 8 aggregation of","of this package 8 aggregation","this package 8 aggregation of","package 8 aggregation of this"]},{"licenseTexts":["The Artistic License\n\nPreamble\n\nThe intent of this document is to state the conditions under which a Package may be copied, such that the Copyright Holder maintains some semblance of artistic control over the development of the package, while giving the users of the package the right to use and distribute the Package in a more-or-less customary fashion, plus the right to make reasonable modifications.\n\nDefinitions:\n\n\"Package\" refers to the collection of files distributed by the Copyright Holder, and derivatives of that collection of files created through textual modification.\n\n\"Standard Version\" refers to such a Package if it has not been modified, or has been modified in accordance with the wishes of the Copyright Holder.\n\n\"Copyright Holder\" is whoever is named in the copyright or copyrights for the package.\n\n\"You\" is you, if you're thinking about copying or distributing this Package.\n\n\"Reasonable copying fee\" is whatever you can justify on the basis of media cost, duplication charges, time of people involved, and so on. (You will not be required to justify it to the Copyright Holder, but only to the computing community at large as a market that must bear the fee.)\n\n\"Freely Available\" means that no fee is charged for the item itself, though there may be fees involved in handling the item. It also means that recipients of the item may redistribute it under the same conditions they received it.\n\n   1. You may make and give away verbatim copies of the source form of the Standard Version of this Package without restriction, provided that you duplicate all of the original copyright notices and associated disclaimers.\n\n   2. You may apply bug fixes, portability fixes and other modifications derived from the Public Domain or from the Copyright Holder. A Package modified in such a way shall still be considered the Standard Version.\n\n   3. You may otherwise modify your copy of this Package in any way, provided that you insert a prominent notice in each changed file stating how and when you changed that file, and provided that you do at least ONE of the following:\n\n      a) place your modifications in the Public Domain or otherwise make them Freely Available, such as by posting said modifications to Usenet or an equivalent medium, or placing the modifications on a major archive site such as ftp.uu.net, or by allowing the Copyright Holder to include your modifications in the Standard Version of the Package.\n\n      b) use the modified Package only within your corporation or organization.\n\n      c) rename any non-standard executables so the names do not conflict with standard executables, which must also be provided, and provide a separate manual page for each non-standard executable that clearly documents how it differs from the Standard Version.\n\n      d) make other distribution arrangements with the Copyright Holder.\n\n   4. You may distribute the programs of this Package in object code or executable form, provided that you do at least ONE of the following:\n\n      a) distribute a Standard Version of the executables and library files, together with instructions (in the manual page or equivalent) on where to get the Standard Version.\n\n      b) accompany the distribution with the machine-readable source of the Package with your modifications.\n\n      c) accompany any non-standard executables with their corresponding Standard Version executables, giving the non-standard executables non-standard names, and clearly documenting the differences in manual pages (or equivalent), together with instructions on where to get the Standard Version.\n\n      d) make other distribution arrangements with the Copyright Holder.\n\n   5. You may charge a reasonable copying fee for any distribution of this Package. You may charge any fee you choose for support of this Package. You may not charge a fee for this Package itself. However, you may distribute this Package in aggregate with other (possibly commercial) programs as part of a larger (possibly commercial) software distribution provided that you do not advertise this Package as a product of your own.\n\n   6. The scripts and library files supplied as input to or produced as output from the programs of this Package do not automatically fall under the copyright of this Package, but belong to whomever generated them, and may be sold commercially, and may be aggregated with this Package.\n\n   7. C or perl subroutines supplied by you and linked into this Package shall not be considered part of this Package.\n\n   8. The name of the Copyright Holder may not be used to endorse or promote products derived from this software without specific prior written permission.\n\n   9. THIS PACKAGE IS PROVIDED \"AS IS\" AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. The End"],"licenseIds":["Artistic-1.0"],"keywords":null},{"licenseTexts":["The Artistic License 2.0\n\nCopyright (c) 2000-2006, The Perl Foundation.\n\nEveryone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.\n\nPreamble\n\nThis license establishes the terms under which a given free software Package may be copied, modified, distributed, and/or redistributed. The intent is that the Copyright Holder maintains some artistic control over the development of that Package while still keeping the Package available as open source and free software.\n\nYou are always permitted to make arrangements wholly outside of this license directly with the Copyright Holder of a given Package. If the terms of this license do not permit the full use that you propose to make of the Package, you should contact the Copyright Holder and seek a different licensing arrangement.\n\nDefinitions\n\n   \n\n   \"Copyright Holder\" means the individual(s) or organization(s) named in the copyright notice for the entire Package.\n\n   \n\n   \"Contributor\" means any party that has contributed code or other material to the Package, in accordance with the Copyright Holder's procedures.\n\n   \n\n   \"You\" and \"your\" means any person who would like to copy, distribute, or modify the Package.\n\n   \n\n   \"Package\" means the collection of files distributed by the Copyright Holder, and derivatives of that collection and/or of those files. A given Package may consist of either the Standard Version, or a Modified Version.\n\n   \n\n   \"Distribute\" means providing a copy of the Package or making it accessible to anyone else, or in the case of a company or organization, to others outside of your company or organization.\n\n   \n\n   \"Distributor Fee\" means any fee that you charge for Distributing this Package or providing support for this Package to another party. It does not mean licensing fees.\n\n   \n\n   \"Standard Version\" refers to the Package if it has not been modified, or has been modified only in ways explicitly requested by the Copyright Holder.\n\n   \n\n   \"Modified Version\" means the Package, if it has been changed, and such changes were not explicitly requested by the Copyright Holder.\n\n   \n\n   \"Original License\" means this Artistic License as Distributed with the Standard Version of the Package, in its current version or as it may be modified by The Perl Foundation in the future.\n\n   \n\n   \"Source\" form means the source code, documentation source, and configuration files for the Package.\n\n   \n\n   \"Compiled\" form means the compiled bytecode, object code, binary, or any other form resulting from mechanical transformation or translation of the Source form.\n\nPermission for Use and Modification Without Distribution\n\n   (1) You are permitted to use the Standard Version and create and use Modified Versions for any purpose without restriction, provided that you do not Distribute the Modified Version.\n\nPermissions for Redistribution of the Standard Version\n\n   (2) You may Distribute verbatim copies of the Source form of the Standard Version of this Package in any medium without restriction, either gratis or for a Distributor Fee, provided that you duplicate all of the original copyright notices and associated disclaimers. At your discretion, such verbatim copies may or may not include a Compiled form of the Package.\n\n   (3) You may apply any bug fixes, portability changes, and other modifications made available from the Copyright Holder. The resulting Package will still be considered the Standard Version, and as such will be subject to the Original License.\n\nDistribution of Modified Versions of the Package as Source\n\n   (4) You may Distribute your Modified Version as Source (either gratis or for a Distributor Fee, and with or without a Compiled form of the Modified Version) provided that you clearly document how it differs from the Standard Version, including, but not limited to, documenting any non-standard features, executables, or modules, and provided that you do at least ONE of the following:\n\n      (a) make the Modified Version available to the Copyright Holder of the Standard Version, under the Original License, so that the Copyright Holder may include your modifications in the Standard Version.\n\n      (b) ensure that installation of your Modified Version does not prevent the user installing or running the Standard Version. In addition, the Modified Version must bear a name that is different from the name of the Standard Version.\n\n      (c) allow anyone who receives a copy of the Modified Version to make the Source form of the Modified Version available to others under\n\n         (i) the Original License or\n\n         (ii) a license that permits the licensee to freely copy, modify and redistribute the Modified Version using the same licensing terms that apply to the copy that the licensee received, and requires that the Source form of the Modified Version, and of any works derived from it, be made freely available in that license fees are prohibited but Distributor Fees are allowed.\n\nDistribution of Compiled Forms of the Standard Version or Modified Versions without the Source\n\n   (5) You may Distribute Compiled forms of the Standard Version without the Source, provided that you include complete instructions on how to get the Source of the Standard Version. Such instructions must be valid at the time of your distribution. If these instructions, at any time while you are carrying out such distribution, become invalid, you must provide new instructions on demand or cease further distribution. If you provide valid instructions or cease distribution within thirty days after you become aware that the instructions are invalid, then you do not forfeit any of your rights under this license.\n\n   (6) You may Distribute a Modified Version in Compiled form without the Source, provided that you comply with Section 4 with respect to the Source of the Modified Version.\n\nAggregating or Linking the Package\n\n   (7) You may aggregate the Package (either the Standard Version or Modified Version) with other packages and Distribute the resulting aggregation provided that you do not charge a licensing fee for the Package. Distributor Fees are permitted, and licensing fees for other components in the aggregation are permitted. The terms of this license apply to the use and Distribution of the Standard or Modified Versions as included in the aggregation.\n\n   (8) You are permitted to link Modified and Standard Versions with other works, to embed the Package in a larger work of your own, or to build stand-alone binary or bytecode versions of applications that include the Package, and Distribute the result without restriction, provided the result does not expose a direct interface to the Package.\n\nItems That are Not Considered Part of a Modified Version\n\n   (9) Works (including, but not limited to, modules and scripts) that merely extend or make use of the Package, do not, by themselves, cause the Package to be a Modified Version. In addition, such works are not considered parts of the Package itself, and are not subject to the terms of this license.\n\nGeneral Provisions\n\n   (10) Any use, modification, and distribution of the Standard or Modified Versions is governed by this Artistic License. By using, modifying or distributing the Package, you accept this license. Do not use, modify, or distribute the Package, if you do not accept this license.\n\n   (11) If your Modified Version has been derived from a Modified Version made by someone other than you, you are nevertheless required to ensure that your Modified Version complies with the requirements of this license.\n\n   (12) This license does not grant you the right to use any trademark, service mark, tradename, or logo of the Copyright Holder.\n\n   (13) This license includes the non-exclusive, worldwide, free-of-charge patent license to make, have made, use, offer to sell, sell, import and otherwise transfer the Package with respect to any patent claims licensable by the Copyright Holder that are necessarily infringed by the Package. If you institute patent litigation (including a cross-claim or counterclaim) against any party alleging that the Package constitutes direct or contributory patent infringement, then this Artistic License to you shall terminate on the date that such litigation is filed.\n\n   (14) Disclaimer of Warranty:\n\n   THE PACKAGE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS \"AS IS\" AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES. THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT ARE DISCLAIMED TO THE EXTENT PERMITTED BY YOUR LOCAL LAW. UNLESS REQUIRED BY LAW, NO COPYRIGHT HOLDER OR CONTRIBUTOR WILL BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING IN ANY WAY OUT OF THE USE OF THE PACKAGE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."],"licenseIds":["Artistic-2.0"],"keywords":["artistic license 2","c 2000 2006","2000 2006 the","2006 the perl","perl foundation everyone","foundation everyone is","allowed preamble this","this license establishes","license establishes the","establishes the terms","which a given","a given free","given free software","free software package","software package may","be copied modified","copied modified distributed","modified distributed and","and or redistributed","or redistributed the","redistributed the intent","intent is that","is that the","maintains some artistic","some artistic control","development of that","of that package","that package while","package while still","while still keeping","still keeping the","keeping the package","the package available","package available as","available as open","open source and","source and free","and free software","you are always","are always permitted","always permitted to","permitted to make","to make arrangements","make arrangements wholly","arrangements wholly outside","wholly outside of","outside of this","license directly with","holder of a","of a given","given package if","do not permit","not permit the","permit the full","the full use","full use that","use that you","that you propose","you propose to","propose to make","to make of","make of the","package you should","you should contact","should contact the","contact the copyright","holder and seek","and seek a","seek a different","a different licensing","different licensing arrangement","licensing arrangement definitions","arrangement definitions copyright","definitions copyright holder","copyright holder means","s or organization","or organization s","organization s named","s named in","entire package contributor","package contributor means","means any party","any party that","party that has","has contributed code","contributed code or","package in accordance","holder s procedures","s procedures you","procedures you and","person who would","who would like","like to copy","modify the package","the package package","package package means","package means the","means the collection","that collection and","collection and or","and or of","or of those","those files a","files a given","given package may","package may consist","may consist of","consist of either","version or a","modified version distribute","version distribute means","distribute means providing","means providing a","the package or","package or making","or making it","making it accessible","it accessible to","accessible to anyone","else or in","of a company","or organization to","organization to others","to others outside","others outside of","outside of your","your company or","or organization distributor","organization distributor fee","distributor fee means","fee means any","means any fee","any fee that","fee that you","that you charge","charge for distributing","for distributing this","this package or","package or providing","or providing support","providing support for","another party it","party it does","does not mean","not mean licensing","mean licensing fees","licensing fees standard","fees standard version","been modified only","modified only in","only in ways","in ways explicitly","ways explicitly requested","modified version means","means the package","been changed and","changed and such","and such changes","such changes were","changes were not","were not explicitly","not explicitly requested","copyright holder original","holder original license","original license means","means this artistic","with the standard","package in its","its current version","current version or","version or as","or as it","by the perl","perl foundation in","foundation in the","the future source","future source form","source form means","configuration files for","the package compiled","package compiled form","compiled form means","means the compiled","the compiled bytecode","compiled bytecode object","bytecode object code","object code binary","code binary or","binary or any","other form resulting","source form permission","form permission for","use and modification","and modification without","without distribution 1","distribution 1 you","version and create","and create and","and use modified","use modified versions"]},{"licenseTexts":["Copyright (c) \u003cyear\u003e \u003cowner\u003e All rights reserved.\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\nTHIS SOFTWARE IS PROVIDED BY Berkeley Software Design, Inc. \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Berkeley Software Design, Inc. BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."],"licenseIds":["BSD-1-Clause"],"keywords":["following disclaimer this","provided by berkeley","by berkeley software","design inc as","inc as is","event shall berkeley","shall berkeley software","design inc be","the following disclaimer this","following disclaimer this software","is provided by berkeley","provided by berkeley software","by berkeley software design","software design inc as","design inc as is","inc as is and","no event shall berkeley","event shall berkeley software","shall berkeley software design","software design inc be","design inc be liable","and the following disclaimer this","the following disclaimer this software","following disclaimer this software is","software is provided by berkeley","is provided by berkeley software","provided by berkeley software design","by berkeley software design inc","berkeley software design inc as","software design inc as is","design inc as is and","inc as is and any","in no event shall berkeley","no event shall berkeley software","event shall berkeley software design","shall berkeley software design inc","berkeley software design inc be","software design inc be liable","design inc be liable for"]},{"licenseTexts":["The FreeBSD Copyright Copyright 1992-2012 The FreeBSD Project. All rights reserved.\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n   2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\nTHIS SOFTWARE IS PROVIDED BY THE FREEBSD PROJECT ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FREEBSD PROJECT OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\nThe views and conclusions contained in the software and documentation are those of the authors and should not be interpreted as representing official policies, either expressed or implied, of the FreeBSD Project."],"licenseIds":["BSD-2-Clause-FreeBSD"],"keywords":["the freebsd copyright","freebsd copyright copyright","copyright copyright 1992","copyright 1992 2012","1992 2012 the","2012 the freebsd","freebsd project all","by the freebsd","freebsd project as","shall the freebsd","freebsd project or","project or contributors","of the freebsd","the freebsd copyright copyright","freebsd copyright copyright 1992","copyright copyright 1992 2012","copyright 1992 2012 the","1992 2012 the freebsd","2012 the freebsd project","the freebsd project all","freebsd project all rights","provided by the freebsd","by the freebsd project","the freebsd project as","freebsd project as is","event shall the freebsd","shall the freebsd project","the freebsd project or","freebsd project or contributors","project or contributors be","implied of the freebsd","of the freebsd project","the freebsd copyright copyright 1992","freebsd copyright copyright 1992 2012","copyright copyright 1992 2012 the","copyright 1992 2012 the freebsd","1992 2012 the freebsd project","2012 the freebsd project all","the freebsd project all rights","freebsd project all rights reserved","is provided by the freebsd","provided by the freebsd project","by the freebsd project as","the freebsd project as is","freebsd project as is and","no event shall the freebsd","event shall the freebsd project","shall the freebsd project or","the freebsd project or contributors","freebsd project or contributors be","project or contributors be liable","or implied of the freebsd","implied of the freebsd project"]},{"licenseTexts":["Copyright (c) 2008 The NetBSD Foundation, Inc. All rights reserved.\n\nThis code is derived from software contributed to The NetBSD Foundation by \n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n   2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\nTHIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."],"licenseIds":["BSD-2-Clause-NetBSD"],"keywords":["copyright c 2008","c 2008 the","2008 the netbsd","foundation inc all","reserved this code","derived from software","from software contributed","software contributed to","to the netbsd","netbsd foundation by","foundation by redistribution","by redistribution and","by the netbsd","foundation inc and","shall the foundation","the foundation or","foundation or contributors","copyright c 2008 the","c 2008 the netbsd","2008 the netbsd foundation","netbsd foundation inc all","foundation inc all rights","rights reserved this code","reserved this code is","this code is derived","code is derived from","is derived from software","derived from software contributed","from software contributed to","software contributed to the","contributed to the netbsd","to the netbsd foundation","the netbsd foundation by","netbsd foundation by redistribution","foundation by redistribution and","by redistribution and use","provided by the netbsd","by the netbsd foundation","netbsd foundation inc and","foundation inc and contributors","event shall the foundation","shall the foundation or","the foundation or contributors","foundation or contributors be","copyright c 2008 the netbsd","c 2008 the netbsd foundation","2008 the netbsd foundation inc","the netbsd foundation inc all","netbsd foundation inc all rights","foundation inc all rights reserved","all rights reserved this code","rights reserved this code is","reserved this code is derived","this code is derived from","code is derived from software","is derived from software contributed","derived from software contributed to","from software contributed to the","software contributed to the netbsd","contributed to the netbsd foundation","to the netbsd foundation by","the netbsd foundation by redistribution","netbsd foundation by redistribution and","foundation by redistribution and use","by redistribution and use in","is provided by the netbsd","provided by the netbsd foundation","by the netbsd foundation inc","the netbsd foundation inc and","netbsd foundation inc and contributors","foundation inc and contributors as","no event shall the foundation","event shall the foundation or","shall the foundation or contributors","the foundation or contributors be","foundation or contributors be liable"]},{"licenseTexts":["Copyright (c) \u003cYEAR\u003e \u003cCOPYRIGHT HOLDERS\u003e\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n   2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\nSubject to the terms and conditions of this license, each copyright holder and contributor hereby grants to those receiving rights under this license a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except for failure to satisfy the conditions of this license) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer this software, where such license applies only to those patent claims, already acquired or hereafter acquired, licensable by such copyright holder or contributor that are necessarily infringed by:\n\n   (a) their Contribution(s) (the licensed copyrights of copyright holders and non-copyrightable additions of contributors, in source or binary form) alone; or\n\n   (b) combination of their Contribution(s) with the work of authorship to which such Contribution(s) was added by such copyright holder or contributor, if, at the time the Contribution is added, such addition causes such combination to be necessarily infringed. The patent license shall not apply to any other combinations which include the Contribution.\n\nExcept as expressly stated above, no rights or licenses from any copyright holder or contributor is granted under this license, whether expressly, by implication, estoppel or otherwise.\n\nDISCLAIMER\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."],"licenseIds":["BSD-2-Clause-Patent"],"keywords":["copyright holders redistribution","holders redistribution and","the distribution subject","distribution subject to","license each copyright","holder and contributor","and contributor hereby","grants to those","to those receiving","those receiving rights","receiving rights under","license a perpetual","except for failure","for failure to","failure to satisfy","license patent license","otherwise transfer this","transfer this software","this software where","software where such","patent claims already","claims already acquired","hereafter acquired licensable","acquired licensable by","infringed by a","by a their","a their contribution","contribution s the","s the licensed","the licensed copyrights","licensed copyrights of","copyrights of copyright","holders and non","and non copyrightable","non copyrightable additions","copyrightable additions of","additions of contributors","of contributors in","contributors in source","binary form alone","form alone or","alone or b","or b combination","b combination of","of authorship to","authorship to which","s was added","added by such","or contributor if","contributor if at","such addition causes","addition causes such","to be necessarily","necessarily infringed the","infringed the patent","the contribution except","contribution except as","expressly stated above","stated above no","above no rights","or licenses from","licenses from any","from any copyright","or contributor is","contributor is granted","license whether expressly","or otherwise disclaimer","otherwise disclaimer this","year copyright holders redistribution","copyright holders redistribution and","holders redistribution and use","with the distribution subject","the distribution subject to","distribution subject to the","this license each copyright","license each copyright holder","each copyright holder and","copyright holder and contributor","holder and contributor hereby","and contributor hereby grants","hereby grants to those","grants to those receiving","to those receiving rights","those receiving rights under","receiving rights under this","this license a perpetual","license a perpetual worldwide","free irrevocable except for","irrevocable except for failure","except for failure to","for failure to satisfy","failure to satisfy the","of this license patent","this license patent license","license patent license to","and otherwise transfer this","otherwise transfer this software","transfer this software where","this software where such","software where such license","those patent claims already","patent claims already acquired","claims already acquired or","or hereafter acquired licensable","hereafter acquired licensable by","acquired licensable by such","licensable by such copyright","holder or contributor that","or contributor that are","necessarily infringed by a","infringed by a their","by a their contribution","a their contribution s","their contribution s the","contribution s the licensed","s the licensed copyrights","the licensed copyrights of","licensed copyrights of copyright","copyrights of copyright holders","of copyright holders and","copyright holders and non","holders and non copyrightable","and non copyrightable additions","non copyrightable additions of","copyrightable additions of contributors","additions of contributors in","of contributors in source","contributors in source or","or binary form alone","binary form alone or","form alone or b","alone or b combination","or b combination of","b combination of their","with the work of","work of authorship to","of authorship to which","authorship to which such","contribution s was added","s was added by","was added by such","added by such copyright","holder or contributor if","or contributor if at","contributor if at the","contribution is added such","added such addition causes","such addition causes such","addition causes such combination","combination to be necessarily","to be necessarily infringed","be necessarily infringed the","necessarily infringed the patent","infringed the patent license","include the contribution except","the contribution except as","contribution except as expressly","as expressly stated above","expressly stated above no","stated above no rights","above no rights or","rights or licenses from","or licenses from any","licenses from any copyright","from any copyright holder","holder or contributor is","or contributor is granted","contributor is granted under","this license whether expressly","license whether expressly by","estoppel or otherwise disclaimer","or otherwise disclaimer this","otherwise disclaimer this software","c year copyright holders redistribution","year copyright holders redistribution and","copyright holders redistribution and use","holders redistribution and use in","provided with the distribution subject","with the distribution subject to","the distribution subject to the","distribution subject to the terms","of this license each copyright","this license each copyright holder","license each copyright holder and","each copyright holder and contributor","copyright holder and contributor hereby","holder and contributor hereby grants","and contributor hereby grants to","contributor hereby grants to those","hereby grants to those receiving","grants to those receiving rights","to those receiving rights under","those receiving rights under this","receiving rights under this license","rights under this license a","under this license a perpetual","this license a perpetual worldwide","license a perpetual worldwide non","royalty free irrevocable except for","free irrevocable except for failure"]},{"licenseTexts":["Copyright (c) \u003cyear\u003e \u003cowner\u003e. All rights reserved.\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n   2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."],"licenseIds":["BSD-2-Clause"],"keywords":null},{"licenseTexts":["Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n   2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.\n\n   4. Redistributions of any form whatsoever must retain the following acknowledgment: 'This product includes software developed by the \"Universidad de Palermo, Argentina\" (http://www.palermo.edu/).'\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."],"licenseIds":["BSD-3-Clause-Attribution"],"keywords":["permission 4 redistributions","4 redistributions of","by the universidad","the universidad de","universidad de palermo","de palermo argentina","palermo argentina http","argentina http www","http www palermo","www palermo edu","palermo edu this","written permission 4 redistributions","permission 4 redistributions of","4 redistributions of any","developed by the universidad","by the universidad de","the universidad de palermo","universidad de palermo argentina","de palermo argentina http","palermo argentina http www","argentina http www palermo","http www palermo edu","www palermo edu this","palermo edu this software","edu this software is","prior written permission 4 redistributions","written permission 4 redistributions of","permission 4 redistributions of any","4 redistributions of any form","software developed by the universidad","developed by the universidad de","by the universidad de palermo","the universidad de palermo argentina","universidad de palermo argentina http","de palermo argentina http www","palermo argentina http www palermo","argentina http www palermo edu","http www palermo edu this","www palermo edu this software","palermo edu this software is","edu this software is provided"]},{"licenseTexts":["The Clear BSD License Copyright (c) [xxxx]-[xxxx] [Owner Organization]\n\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or without modification, are permitted (subject to the limitations in the disclaimer below) provided that the following conditions are met:\n\n      * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n      * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n      * Neither the name of [Owner Organization] nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.\n\nNO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."],"licenseIds":["BSD-3-Clause-Clear"],"keywords":["the clear bsd","clear bsd license","bsd license copyright","copyright c xxxx","c xxxx xxxx","xxxx xxxx owner","xxxx owner organization","owner organization all","organization all rights","are permitted subject","permitted subject to","limitations in the","in the disclaimer","disclaimer below provided","below provided that","name of owner","of owner organization","owner organization nor","organization nor the","written permission no","permission no express","implied licenses to","party s patent","s patent rights","patent rights are","the clear bsd license","clear bsd license copyright","bsd license copyright c","license copyright c xxxx","copyright c xxxx xxxx","c xxxx xxxx owner","xxxx xxxx owner organization","xxxx owner organization all","owner organization all rights","organization all rights reserved","modification are permitted subject","are permitted subject to","permitted subject to the","the limitations in the","limitations in the disclaimer","in the disclaimer below","the disclaimer below provided","disclaimer below provided that","below provided that the","the name of owner","name of owner organization","of owner organization nor","owner organization nor the","organization nor the names","prior written permission no","written permission no express","permission no express or","or implied licenses to","implied licenses to any","licenses to any party","to any party s","any party s patent","party s patent rights","s patent rights are","patent rights are granted","rights are granted by","are granted by this","by this license this","this license this software","the clear bsd license copyright","clear bsd license copyright c","bsd license copyright c xxxx","license copyright c xxxx xxxx","copyright c xxxx xxxx owner","c xxxx xxxx owner organization","xxxx xxxx owner organization all","xxxx owner organization all rights","owner organization all rights reserved","organization all rights reserved redistribution","without modification are permitted subject","modification are permitted subject to","are permitted subject to the","permitted subject to the limitations","to the limitations in the","the limitations in the disclaimer","limitations in the disclaimer below","in the disclaimer below provided","the disclaimer below provided that","disclaimer below provided that the","below provided that the following","neither the name of owner","the name of owner organization","name of owner organization nor","of owner organization nor the","owner organization nor the names","organization nor the names of","specific prior written permission no","prior written permission no express","written permission no express or","permission no express or implied","no express or implied licenses","express or implied licenses to","or implied licenses to any","implied licenses to any party","licenses to any party s","to any party s patent","any party s patent rights","party s patent rights are","s patent rights are granted","patent rights are granted by","rights are granted by this","are granted by this license","granted by this license this","by this license this software","this license this software is"]},{"licenseTexts":["Copyright (c) 2003, The Regents of the University of California, through Lawrence Berkeley National Laboratory (subject to receipt of any required approvals from the U.S. Dept. of Energy). All rights reserved.\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   (1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n   (2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   (3) Neither the name of the University of California, Lawrence Berkeley National Laboratory, U.S. Dept. of Energy nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER , THE UNITED STATES GOVERNMENT, OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\nYou are under no obligation whatsoever to provide any bug fixes, patches, or upgrades to the features, functionality or performance of the source code (\"Enhancements\") to anyone; however, if you choose to make your Enhancements available either publicly, or directly to Lawrence Berkeley National Laboratory , without imposing a separate written license agreement for such Enhancements, then you hereby grant the following license: a non-exclusive, royalty-free perpetual license to install, use, modify, prepare derivative works, incorporate into other computer software, distribute, and sublicense such Enhancements or derivative works thereof, in binary and source code form."],"licenseIds":["BSD-3-Clause-LBNL"],"keywords":["c 2003 the","2003 the regents","of california through","california through lawrence","through lawrence berkeley","national laboratory subject","laboratory subject to","subject to receipt","to receipt of","receipt of any","of any required","any required approvals","required approvals from","approvals from the","of energy all","energy all rights","of california lawrence","california lawrence berkeley","national laboratory u","laboratory u s","of energy nor","energy nor the","copyright owner the","owner the united","government or contributors","damage you are","no obligation whatsoever","obligation whatsoever to","whatsoever to provide","provide any bug","fixes patches or","patches or upgrades","upgrades to the","to the features","source code enhancements","code enhancements to","enhancements to anyone","to anyone however","anyone however if","choose to make","make your enhancements","your enhancements available","enhancements available either","available either publicly","either publicly or","publicly or directly","or directly to","directly to lawrence","to lawrence berkeley","national laboratory without","laboratory without imposing","without imposing a","imposing a separate","agreement for such","for such enhancements","such enhancements then","enhancements then you","then you hereby","hereby grant the","grant the following","following license a","install use modify","use modify prepare","modify prepare derivative","derivative works incorporate","works incorporate into","incorporate into other","into other computer","other computer software","computer software distribute","software distribute and","and sublicense such","sublicense such enhancements","such enhancements or","thereof in binary","in binary and","binary and source","copyright c 2003 the","c 2003 the regents","2003 the regents of","university of california through","of california through lawrence","california through lawrence berkeley","through lawrence berkeley national","berkeley national laboratory subject","national laboratory subject to","laboratory subject to receipt","subject to receipt of","to receipt of any","receipt of any required","of any required approvals","any required approvals from","required approvals from the","approvals from the u","the u s dept","dept of energy all","of energy all rights","energy all rights reserved","university of california lawrence","of california lawrence berkeley","california lawrence berkeley national","berkeley national laboratory u","national laboratory u s","laboratory u s dept","dept of energy nor","of energy nor the","energy nor the names","the copyright owner the","copyright owner the united","owner the united states","states government or contributors","government or contributors be","such damage you are","damage you are under","under no obligation whatsoever","no obligation whatsoever to","obligation whatsoever to provide","whatsoever to provide any","to provide any bug","provide any bug fixes","bug fixes patches or","fixes patches or upgrades","patches or upgrades to","or upgrades to the","upgrades to the features","to the features functionality","performance of the source","the source code enhancements","source code enhancements to","code enhancements to anyone","enhancements to anyone however","to anyone however if","anyone however if you","however if you choose","you choose to make","choose to make your","to make your enhancements","make your enhancements available","your enhancements available either","enhancements available either publicly","available either publicly or","either publicly or directly","publicly or directly to","or directly to lawrence","directly to lawrence berkeley","to lawrence berkeley national","berkeley national laboratory without","national laboratory without imposing","laboratory without imposing a","without imposing a separate","imposing a separate written","written license agreement for","license agreement for such","agreement for such enhancements","for such enhancements then","such enhancements then you","enhancements then you hereby","then you hereby grant","you hereby grant the","hereby grant the following","grant the following license","the following license a","following license a non","to install use modify","install use modify prepare","use modify prepare derivative","modify prepare derivative works","prepare derivative works incorporate","derivative works incorporate into","works incorporate into other","incorporate into other computer","into other computer software","other computer software distribute","computer software distribute and","software distribute and sublicense","distribute and sublicense such","and sublicense such enhancements","sublicense such enhancements or","such enhancements or derivative","works thereof in binary","thereof in binary and","in binary and source","binary and source code","copyright c 2003 the regents","c 2003 the regents of","2003 the regents of the","the university of california through","university of california through lawrence","of california through lawrence berkeley","california through lawrence berkeley national","through lawrence berkeley national laboratory","lawrence berkeley national laboratory subject","berkeley national laboratory subject to","national laboratory subject to receipt","laboratory subject to receipt of","subject to receipt of any","to receipt of any required","receipt of any required approvals","of any required approvals from","any required approvals from the"]},{"licenseTexts":["Copyright © 2008, 2014 Oracle and/or its affiliates. All rights reserved.\n\nUse is subject to license terms.\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n   * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   * Neither the name of Oracle Corporation nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\nYou acknowledge that this software is not designed, licensed or intended for use in the design, construction, operation or maintenance of any nuclear facility."],"licenseIds":["BSD-3-Clause-No-Nuclear-License-2014"],"keywords":["copyright 2008 2014","2008 2014 oracle","2014 oracle and","oracle and or","its affiliates all","affiliates all rights","license terms redistribution","terms redistribution and","name of oracle","of oracle corporation","oracle corporation nor","copyright 2008 2014 oracle","2008 2014 oracle and","2014 oracle and or","oracle and or its","and or its affiliates","or its affiliates all","its affiliates all rights","affiliates all rights reserved","to license terms redistribution","license terms redistribution and","terms redistribution and use","the name of oracle","name of oracle corporation","of oracle corporation nor","oracle corporation nor the","copyright 2008 2014 oracle and","2008 2014 oracle and or","2014 oracle and or its","oracle and or its affiliates","and or its affiliates all","or its affiliates all rights","its affiliates all rights reserved","affiliates all rights reserved use","subject to license terms redistribution","to license terms redistribution and","license terms redistribution and use","terms redistribution and use in","neither the name of oracle","the name of oracle corporation","name of oracle corporation nor","of oracle corporation nor the","oracle corporation nor the names"]},{"licenseTexts":["Copyright 1994-2009 Sun Microsystems, Inc. All Rights Reserved.\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   * Redistribution of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n   * Redistribution in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   * Neither the name of Sun Microsystems, Inc. or the names of contributors may be used to endorse or promote products derived from this software without specific prior written permission.\n\nThis software is provided \"AS IS,\" without a warranty of any kind. ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN MICROSYSTEMS, INC. (\"SUN\") AND ITS LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\nYou acknowledge that this software is not designed, licensed or intended for use in the design, construction, operation or maintenance of any nuclear facility."],"licenseIds":["BSD-3-Clause-No-Nuclear-License"],"keywords":["copyright 1994 2009","1994 2009 sun","2009 sun microsystems","copyright 1994 2009 sun","1994 2009 sun microsystems","2009 sun microsystems inc","copyright 1994 2009 sun microsystems","1994 2009 sun microsystems inc","2009 sun microsystems inc all"]},{"licenseTexts":["Copyright (c) 2003-2005 Sun Microsystems, Inc. All Rights Reserved.\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   - Redistribution of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n   - Redistribution in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   - Neither the name of Sun Microsystems, Inc. or the names of contributors may be used to endorse or promote products derived from this software without specific prior written permission.\n\nThis software is provided \"AS IS,\" without a warranty of any kind. ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN MICROSYSTEMS, INC. (\"SUN\") AND ITS LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\nYou acknowledge that this software is not designed or intended for use in the design, construction, operation or maintenance of any nuclear facility."],"licenseIds":["BSD-3-Clause-No-Nuclear-Warranty"],"keywords":["c 2003 2005","2003 2005 sun","2005 sun microsystems","not designed or","designed or intended","copyright c 2003 2005","c 2003 2005 sun","2003 2005 sun microsystems","2005 sun microsystems inc","is not designed or","not designed or intended","designed or intended for","copyright c 2003 2005 sun","c 2003 2005 sun microsystems","2003 2005 sun microsystems inc","2005 sun microsystems inc all","software is not designed or","is not designed or intended","not designed or intended for","designed or intended for use"]},{"licenseTexts":["Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n   - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer listed in this license in the documentation and/or other materials provided with the distribution.\n\n   - Neither the name of the copyright holders nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.\n\nThe copyright holders provide no reassurances that the source code provided does not infringe any patent, copyright, or any other intellectual property rights of third parties. The copyright holders disclaim any liability to any recipient for claims brought against recipient by any third party for infringement of that parties intellectual property rights.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."],"licenseIds":["BSD-3-Clause-Open-MPI"],"keywords":["following disclaimer listed","copyright holders nor","holders nor the","copyright holders provide","holders provide no","copyright or any","parties the copyright","copyright holders disclaim","holders disclaim any","claims brought against","brought against recipient","against recipient by","recipient by any","party for infringement","for infringement of","infringement of that","of that parties","that parties intellectual","parties intellectual property","property rights this","rights this software","the following disclaimer listed","following disclaimer listed in","the copyright holders nor","copyright holders nor the","holders nor the names","permission the copyright holders","the copyright holders provide","copyright holders provide no","holders provide no reassurances","any patent copyright or","patent copyright or any","copyright or any other","property rights of third","of third parties the","third parties the copyright","parties the copyright holders","the copyright holders disclaim","copyright holders disclaim any","holders disclaim any liability","for claims brought against","claims brought against recipient","brought against recipient by","against recipient by any","recipient by any third","third party for infringement","party for infringement of","for infringement of that","infringement of that parties","of that parties intellectual","that parties intellectual property","parties intellectual property rights","intellectual property rights this","property rights this software","rights this software is","and the following disclaimer listed","the following disclaimer listed in","following disclaimer listed in this","name of the copyright holders","of the copyright holders nor","the copyright holders nor the","copyright holders nor the names","holders nor the names of","prior written permission the copyright","written permission the copyright holders","permission the copyright holders provide","the copyright holders provide no","copyright holders provide no reassurances","holders provide no reassurances that","provided does not infringe any","does not infringe any patent","infringe any patent copyright or","any patent copyright or any","patent copyright or any other","copyright or any other intellectual","intellectual property rights of third","property rights of third parties","rights of third parties the","of third parties the copyright","third parties the copyright holders","parties the copyright holders disclaim","the copyright holders disclaim any","copyright holders disclaim any liability","holders disclaim any liability to","recipient for claims brought against","for claims brought against recipient","claims brought against recipient by","brought against recipient by any","against recipient by any third","recipient by any third party","by any third party for","any third party for infringement","third party for infringement of","party for infringement of that","for infringement of that parties","infringement of that parties intellectual","of that parties intellectual property","that parties intellectual property rights","parties intellectual property rights this","intellectual property rights this software","property rights this software is","rights this software is provided"]},{"licenseTexts":["Copyright (c) \u003cyear\u003e \u003cowner\u003e. All rights reserved.\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n   2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.","Copyright (c) 2012 Jesse van den Kieboom. All rights reserved.\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are\nmet:\n\n  * Redistributions of source code must retain the above copyright\n    notice, this list of conditions and the following disclaimer.\n  * Redistributions in binary form must reproduce the above\n    copyright notice, this list of conditions and the following disclaimer\n    in the documentation and/or other materials provided with the\n    distribution.\n  * Neither the name of Google Inc. nor the names of its\n    contributors may be used to endorse or promote products derived from\n    this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\nLIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\nA PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\nOWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\nSPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\nLIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\nDATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\nTHEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\nOF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."],"licenseIds":["BSD-3-Clause"],"keywords":["copyright c 2012","c 2012 jesse","2012 jesse van","jesse van den","van den kieboom","den kieboom all","kieboom all rights","name of google","of google inc","google inc nor","copyright c 2012 jesse","c 2012 jesse van","2012 jesse van den","jesse van den kieboom","van den kieboom all","den kieboom all rights","kieboom all rights reserved","the name of google","name of google inc","of google inc nor","google inc nor the","copyright c 2012 jesse van","c 2012 jesse van den","2012 jesse van den kieboom","jesse van den kieboom all","van den kieboom all rights","den kieboom all rights reserved","kieboom all rights reserved redistribution","neither the name of google","the name of google inc","name of google inc nor","of google inc nor the","google inc nor the names"]},{"licenseTexts":["BSD-4-Clause (University of California-Specific)\n\nCopyright [various years] The Regents of the University of California. All rights reserved.\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n   2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   3. All advertising materials mentioning features or use of this software must display the following acknowledgement: This product includes software developed by the University of California, Berkeley and its contributors.\n\n   4. Neither the name of the University nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ''AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."],"licenseIds":["BSD-4-Clause-UC"],"keywords":["bsd 4 clause","4 clause university","clause university of","of california specific","california specific copyright","specific copyright various","copyright various years","various years the","years the regents","contributors 4 neither","bsd 4 clause university","4 clause university of","clause university of california","university of california specific","of california specific copyright","california specific copyright various","specific copyright various years","copyright various years the","various years the regents","years the regents of","and its contributors 4","its contributors 4 neither","contributors 4 neither the","bsd 4 clause university of","4 clause university of california","clause university of california specific","university of california specific copyright","of california specific copyright various","california specific copyright various years","specific copyright various years the","copyright various years the regents","various years the regents of","years the regents of the","berkeley and its contributors 4","and its contributors 4 neither","its contributors 4 neither the","contributors 4 neither the name"]},{"licenseTexts":["Copyright (c) \u003cyear\u003e \u003cowner\u003e. All rights reserved.\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n   2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   3. All advertising materials mentioning features or use of this software must display the following acknowledgement:\n\n   This product includes software developed by the organization .\n\n   4. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY COPYRIGHT HOLDER \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."],"licenseIds":["BSD-4-Clause"],"keywords":["by the organization","the organization 4","organization 4 neither","by copyright holder","developed by the organization","by the organization 4","the organization 4 neither","organization 4 neither the","is provided by copyright","provided by copyright holder","by copyright holder as","software developed by the organization","developed by the organization 4","by the organization 4 neither","the organization 4 neither the","organization 4 neither the name","software is provided by copyright","is provided by copyright holder","provided by copyright holder as","by copyright holder as is"]},{"licenseTexts":["BSD Protection License\n\nFebruary 2002 Preamble\n\n--------\n\nThe Berkeley Software Distribution (\"BSD\") license has proven very effective over the years at allowing for a wide spread of work throughout both commercial and non-commercial products. For programmers whose primary intention is to improve the general quality of available software, it is arguable that there is no better license than the BSD license, as it permits improvements to be used wherever they will help, without idealogical or metallic constraint.\n\nThis is of particular value to those who produce reference implementations of proposed standards: The case of TCP/IP clearly illustrates that freely and universally available implementations leads the rapid acceptance of standards -- often even being used instead of a de jure standard (eg, OSI network models).\n\nWith the rapid proliferation of software licensed under the GNU General Public License, however, the continued success of this role is called into question. Given that the inclusion of a few lines of \"GPL-tainted\" work into a larger body of work will result in restricted distribution -- and given that further work will likely build upon the \"tainted\" portions, making them difficult to remove at a future date -- there are inevitable circumstances where authors would, in order to protect their goal of providing for the widespread usage of their work, wish to guard against such \"GPL-taint\".\n\nIn addition, one can imagine that companies which operate by producing and selling (possibly closed-source) code would wish to protect themselves against the rise of a GPL-licensed competitor. While under existing licenses this would mean not releasing their code under any form of open license, if a license existed under which they could incorporate any improvements back into their own (commercial) products then they might be far more willing to provide for non-closed distribution.\n\nFor the above reasons, we put forth this \"BSD Protection License\": A license designed to retain the freedom granted by the BSD license to use licensed works in a wide variety of settings, both non-commercial and commercial, while protecting the work from having future contributors restrict that freedom.\n\nThe precise terms and conditions for copying, distribution, and modification follow.\n\nBSD PROTECTION LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION, AND MODIFICATION ----------------------------------------------------------------\n\n   0. Definitions.\n\n      a) \"Program\", below, refers to any program or work distributed under the terms of this license.\n\n      b) A \"work based on the Program\", below, refers to either the Program or any derivative work under copyright law.\n\n      c) \"Modification\", below, refers to the act of creating derivative works.\n\n      d) \"You\", below, refers to each licensee.\n\n   1. Scope.\n\n   This license governs the copying, distribution, and modification of the Program. Other activities are outside the scope of this license; The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program.\n\n   2. Verbatim copies.\n\n   You may copy and distribute verbatim copies of the Program as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program.\n\n   3. Modification and redistribution under closed license.\n\n   You may modify your copy or copies of the Program, and distribute the resulting derivative works, provided that you meet the following conditions:\n\n      a) The copyright notice and disclaimer on the Program must be reproduced and included in the source code, documentation, and/or other materials provided in a manner in which such notices are normally distributed.\n\n      b) The derivative work must be clearly identified as such, in order that it may not be confused with the original work.\n\n      c) The license under which the derivative work is distributed must expressly prohibit the distribution of further derivative works.\n\n   4. Modification and redistribution under open license.\n\n   You may modify your copy or copies of the Program, and distribute the resulting derivative works, provided that you meet the following conditions:\n\n      a) The copyright notice and disclaimer on the Program must be reproduced and included in the source code, documentation, and/or other materials provided in a manner in which such notices are normally distributed.\n\n      b) You must clearly indicate the nature and date of any changes made to the Program. The full details need not necessarily be included in the individual modified files, provided that each modified file is clearly marked as such and instructions are included on where the full details of the modifications may be found.\n\n      c) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License.\n\n   5. Implied acceptance.\n\n   You may not copy or distribute the Program or any derivative works except as expressly provided under this license. Consequently, any such action will be taken as implied acceptance of the terms of this license.\n\n   6. NO WARRANTY.\n\nTHIS SOFTWARE IS PROVIDED \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT, EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES."],"licenseIds":["BSD-Protection"],"keywords":["protection license february","license february 2002","february 2002 preamble","2002 preamble the","preamble the berkeley","the berkeley software","berkeley software distribution","software distribution bsd","distribution bsd license","bsd license has","license has proven","has proven very","proven very effective","very effective over","effective over the","over the years","the years at","years at allowing","at allowing for","allowing for a","for a wide","a wide spread","wide spread of","spread of work","of work throughout","work throughout both","throughout both commercial","non commercial products","commercial products for","products for programmers","for programmers whose","programmers whose primary","whose primary intention","primary intention is","intention is to","is to improve","to improve the","improve the general","the general quality","general quality of","quality of available","of available software","available software it","it is arguable","is arguable that","arguable that there","is no better","no better license","better license than","license than the","than the bsd","bsd license as","license as it","as it permits","it permits improvements","permits improvements to","improvements to be","be used wherever","used wherever they","wherever they will","they will help","will help without","help without idealogical","without idealogical or","idealogical or metallic","or metallic constraint","metallic constraint this","constraint this is","this is of","is of particular","of particular value","particular value to","value to those","those who produce","who produce reference","produce reference implementations","reference implementations of","implementations of proposed","of proposed standards","proposed standards the","standards the case","case of tcp","of tcp ip","tcp ip clearly","ip clearly illustrates","clearly illustrates that","illustrates that freely","that freely and","freely and universally","and universally available","universally available implementations","available implementations leads","implementations leads the","leads the rapid","the rapid acceptance","rapid acceptance of","acceptance of standards","of standards often","standards often even","often even being","even being used","being used instead","used instead of","instead of a","of a de","a de jure","de jure standard","jure standard eg","standard eg osi","eg osi network","osi network models","network models with","models with the","with the rapid","the rapid proliferation","rapid proliferation of","proliferation of software","of software licensed","software licensed under","however the continued","the continued success","continued success of","success of this","of this role","this role is","role is called","is called into","called into question","into question given","question given that","given that the","that the inclusion","of a few","lines of gpl","of gpl tainted","gpl tainted work","tainted work into","work into a","a larger body","larger body of","body of work","of work will","work will result","will result in","result in restricted","in restricted distribution","restricted distribution and","distribution and given","and given that","given that further","that further work","further work will","work will likely","will likely build","likely build upon","build upon the","upon the tainted","the tainted portions","tainted portions making","portions making them","making them difficult","them difficult to","difficult to remove","to remove at","remove at a","at a future","a future date","future date there","date there are","there are inevitable","are inevitable circumstances","inevitable circumstances where","circumstances where authors","where authors would","authors would in","would in order","order to protect","to protect their","protect their goal","their goal of","goal of providing","of providing for","for the widespread","the widespread usage","widespread usage of","usage of their","of their work","their work wish","work wish to","wish to guard","to guard against","guard against such","against such gpl","such gpl taint","gpl taint in","taint in addition","in addition one","addition one can","one can imagine","can imagine that"]},{"licenseTexts":["Copyright (c) 2011, Deusty, LLC\n\nAll rights reserved.\n\nRedistribution and use of this software in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n   * Neither the name of Deusty nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission of Deusty, LLC.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."],"licenseIds":["BSD-Source-Code"],"keywords":["copyright c 2011","c 2011 deusty","2011 deusty llc","deusty llc all","following disclaimer neither","disclaimer neither the","name of deusty","of deusty nor","deusty nor the","permission of deusty","of deusty llc","deusty llc this","llc this software","copyright c 2011 deusty","c 2011 deusty llc","2011 deusty llc all","deusty llc all rights","software in source and","the following disclaimer neither","following disclaimer neither the","disclaimer neither the name","the name of deusty","name of deusty nor","of deusty nor the","deusty nor the names","written permission of deusty","permission of deusty llc","of deusty llc this","deusty llc this software","llc this software is","copyright c 2011 deusty llc","c 2011 deusty llc all","2011 deusty llc all rights","deusty llc all rights reserved","of this software in source","this software in source and","software in source and binary","and the following disclaimer neither","the following disclaimer neither the","following disclaimer neither the name","disclaimer neither the name of","neither the name of deusty","the name of deusty nor","name of deusty nor the","of deusty nor the names","deusty nor the names of","prior written permission of deusty","written permission of deusty llc","permission of deusty llc this","of deusty llc this software","deusty llc this software is","llc this software is provided"]},{"licenseTexts":["Boost Software License - Version 1.0 - August 17th, 2003\n\nPermission is hereby granted, free of charge, to any person or organization obtaining a copy of the software and accompanying documentation covered by this license (the \"Software\") to use, reproduce, display, distribute, execute, and transmit the Software, and to prepare derivative works of the Software, and to permit third-parties to whom the Software is furnished to do so, all subject to the following:\n\nThe copyright notices in the Software and this entire statement, including the above license grant, this restriction and the following disclaimer, must be included in all copies of the Software, in whole or in part, and all derivative works of the Software, unless such copies or derivative works are solely in the form of machine-executable object code generated by a source language processor.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE."],"licenseIds":["BSL-1.0"],"keywords":["boost software license","1 0 august","0 august 17th","august 17th 2003","17th 2003 permission","2003 permission is","or organization obtaining","organization obtaining a","accompanying documentation covered","documentation covered by","reproduce display distribute","display distribute execute","distribute execute and","execute and transmit","transmit the software","and to prepare","to permit third","permit third parties","parties to whom","do so all","so all subject","all subject to","the following the","and this entire","this entire statement","entire statement including","statement including the","above license grant","license grant this","grant this restriction","this restriction and","restriction and the","following disclaimer must","disclaimer must be","part and all","all derivative works","software unless such","unless such copies","such copies or","copies or derivative","works are solely","are solely in","form of machine","machine executable object","by a source","a source language","source language processor","language processor the","processor the software","boost software license version","version 1 0 august","1 0 august 17th","0 august 17th 2003","august 17th 2003 permission","17th 2003 permission is","2003 permission is hereby","any person or organization","person or organization obtaining","or organization obtaining a","organization obtaining a copy","and accompanying documentation covered","accompanying documentation covered by","documentation covered by this","this license the software","license the software to","the software to use","use reproduce display distribute","reproduce display distribute execute","display distribute execute and","distribute execute and transmit","execute and transmit the","and transmit the software","transmit the software and","software and to prepare","and to prepare derivative","and to permit third","to permit third parties","permit third parties to","third parties to whom","parties to whom the","to do so all","do so all subject","so all subject to","all subject to the","to the following the","the following the copyright","following the copyright notices","the copyright notices in","software and this entire","and this entire statement","this entire statement including","entire statement including the","statement including the above","including the above license","the above license grant","above license grant this","license grant this restriction","grant this restriction and","this restriction and the","restriction and the following","the following disclaimer must","following disclaimer must be","disclaimer must be included","in part and all","part and all derivative","and all derivative works","all derivative works of","of the software unless","the software unless such","software unless such copies","unless such copies or","such copies or derivative","copies or derivative works","derivative works are solely","works are solely in","are solely in the","solely in the form","the form of machine","form of machine executable","of machine executable object","machine executable object code","executable object code generated","object code generated by","code generated by a","generated by a source","by a source language","a source language processor","source language processor the","language processor the software","processor the software is","boost software license version 1","license version 1 0 august","version 1 0 august 17th","1 0 august 17th 2003","0 august 17th 2003 permission","august 17th 2003 permission is","17th 2003 permission is hereby","2003 permission is hereby granted","charge to any person or","to any person or organization","any person or organization obtaining","person or organization obtaining a","or organization obtaining a copy","organization obtaining a copy of","a copy of the software","copy of the software and","of the software and accompanying","software and accompanying documentation covered","and accompanying documentation covered by","accompanying documentation covered by this","documentation covered by this license","by this license the software","this license the software to","license the software to use","the software to use reproduce","software to use reproduce display","to use reproduce display distribute","use reproduce display distribute execute","reproduce display distribute execute and","display distribute execute and transmit","distribute execute and transmit the","execute and transmit the software","and transmit the software and","transmit the software and to","the software and to prepare","software and to prepare derivative","and to prepare derivative works","to prepare derivative works of","prepare derivative works of the","works of the software and","software and to permit third","and to permit third parties","to permit third parties to","permit third parties to whom","third parties to whom the","parties to whom the software","furnished to do so all","to do so all subject","do so all subject to","so all subject to the","all subject to the following","subject to the following the","to the following the copyright","the following the copyright notices","following the copyright notices in","the copyright notices in the","notices in the software and","in the software and this","the software and this entire","software and this entire statement","and this entire statement including","this entire statement including the","entire statement including the above","statement including the above license","including the above license grant","the above license grant this","above license grant this restriction","license grant this restriction and","grant this restriction and the","this restriction and the following"]},{"licenseTexts":["COPYRIGHT NOTICE\n\nThese patterns and the generating sh script are Copyright (c) GMV 1991\n\nThese patterns were developed for internal GMV use and are made public in the hope that they will benefit others. Also, spreading these patterns throughout the Spanish-language TeX community is expected to provide back-benefits to GMV in that it can help keeping GMV in the mainstream of spanish users.\n\nHowever, this is given for free and WITHOUT ANY WARRANTY. Under no circumstances can Julio Sanchez, GMV, Jos'e A. Ma~nas or any agents or representatives thereof be held responsible for any errors in this software nor for any damages derived from its use, even in case any of the above has been notified of the possibility of such damages. If any such situation arises, you responsible for repair. Use of this software is an explicit acceptance of these conditions.\n\nYou can use this software for any purpose. You cannot delete this copyright notice. If you change this software, you must include comments explaining who, when and why. You are kindly requested to send any changes to tex@gmv.es. If you change the generating script, you must include code in it such that any output is clearly labeled as generated by a modified script. Despite the lack of warranty, we would like to hear about any problem you find. Please report problems to tex@gmv.es. END OF COPYRIGHT NOTICE"],"licenseIds":["Bahyph"],"keywords":["notice these patterns","these patterns and","patterns and the","and the generating","the generating sh","generating sh script","sh script are","script are copyright","copyright c gmv","c gmv 1991","gmv 1991 these","1991 these patterns","these patterns were","patterns were developed","were developed for","developed for internal","for internal gmv","internal gmv use","gmv use and","use and are","and are made","are made public","made public in","public in the","hope that they","that they will","they will benefit","will benefit others","benefit others also","others also spreading","also spreading these","spreading these patterns","these patterns throughout","patterns throughout the","throughout the spanish","the spanish language","spanish language tex","language tex community","tex community is","community is expected","expected to provide","to provide back","provide back benefits","back benefits to","benefits to gmv","to gmv in","gmv in that","it can help","can help keeping","help keeping gmv","keeping gmv in","gmv in the","in the mainstream","the mainstream of","mainstream of spanish","of spanish users","spanish users however","users however this","however this is","this is given","is given for","given for free","free and without","any warranty under","warranty under no","no circumstances can","circumstances can julio","can julio sanchez","julio sanchez gmv","sanchez gmv jos","gmv jos e","jos e a","e a ma","a ma nas","ma nas or","nas or any","or any agents","any agents or","agents or representatives","or representatives thereof","representatives thereof be","thereof be held","be held responsible","any errors in","errors in this","software nor for","any damages derived","damages derived from","derived from its","its use even","use even in","even in case","in case any","case any of","the above has","above has been","has been notified","been notified of","such damages if","damages if any","if any such","any such situation","such situation arises","situation arises you","arises you responsible","you responsible for","responsible for repair","for repair use","repair use of","software is an","is an explicit","an explicit acceptance","explicit acceptance of","these conditions you","conditions you can","any purpose you","purpose you cannot","you cannot delete","cannot delete this","delete this copyright","copyright notice if","must include comments","include comments explaining","comments explaining who","explaining who when","who when and","when and why","and why you","why you are","you are kindly","are kindly requested","kindly requested to","requested to send","to send any","send any changes","changes to tex","gmv es if","es if you","change the generating","the generating script","generating script you","script you must","must include code","include code in","code in it","in it such","it such that","such that any","that any output","any output is","output is clearly","is clearly labeled","labeled as generated","as generated by","by a modified","a modified script","modified script despite","script despite the","despite the lack","the lack of","lack of warranty","of warranty we","warranty we would","we would like","like to hear","to hear about","hear about any","about any problem","any problem you","problem you find","you find please","find please report","please report problems","report problems to","problems to tex","gmv es end","es end of","end of copyright","of copyright notice","copyright notice these patterns","notice these patterns and","these patterns and the","patterns and the generating","and the generating sh","the generating sh script","generating sh script are","sh script are copyright","script are copyright c","are copyright c gmv","copyright c gmv 1991","c gmv 1991 these","gmv 1991 these patterns","1991 these patterns were","these patterns were developed","patterns were developed for","were developed for internal","developed for internal gmv","for internal gmv use","internal gmv use and","gmv use and are"]},{"licenseTexts":["This is a package of commutative diagram macros built on top of Xy-pic by Michael Barr (email: barr@barrs.org). Its use is unrestricted. It may be freely distributed, unchanged, for non-commercial or commercial use. If changed, it must be renamed. Inclusion in a commercial software package is also permitted, but I would appreciate receiving a free copy for my personal examination and use. There are no guarantees that this package is good for anything. I have tested it with LaTeX 2e, LaTeX 2.09 and Plain TeX. Although I know of no reason it will not work with AMSTeX, I have not tested it."],"licenseIds":["Barr"],"keywords":["is a package","a package of","package of commutative","of commutative diagram","commutative diagram macros","diagram macros built","macros built on","built on top","on top of","top of xy","of xy pic","xy pic by","pic by michael","by michael barr","michael barr email","barr email barr","email barr barrs","barr barrs org","barrs org its","org its use","use is unrestricted","is unrestricted it","unrestricted it may","be freely distributed","freely distributed unchanged","distributed unchanged for","unchanged for non","non commercial or","commercial or commercial","or commercial use","commercial use if","use if changed","if changed it","changed it must","be renamed inclusion","renamed inclusion in","inclusion in a","a commercial software","commercial software package","software package is","package is also","is also permitted","permitted but i","but i would","i would appreciate","would appreciate receiving","appreciate receiving a","receiving a free","a free copy","free copy for","copy for my","for my personal","my personal examination","personal examination and","examination and use","and use there","use there are","are no guarantees","no guarantees that","guarantees that this","that this package","package is good","is good for","good for anything","for anything i","anything i have","i have tested","have tested it","tested it with","it with latex","with latex 2e","latex 2e latex","2e latex 2","latex 2 09","2 09 and","09 and plain","and plain tex","plain tex although","tex although i","although i know","i know of","know of no","of no reason","no reason it","reason it will","will not work","not work with","work with amstex","with amstex i","amstex i have","i have not","have not tested","not tested it","this is a package","is a package of","a package of commutative","package of commutative diagram","of commutative diagram macros","commutative diagram macros built","diagram macros built on","macros built on top","built on top of","on top of xy","top of xy pic","of xy pic by","xy pic by michael","pic by michael barr","by michael barr email","michael barr email barr","barr email barr barrs","email barr barrs org","barr barrs org its","barrs org its use","org its use is","its use is unrestricted","use is unrestricted it","is unrestricted it may","unrestricted it may be","may be freely distributed","be freely distributed unchanged","freely distributed unchanged for","distributed unchanged for non","unchanged for non commercial","for non commercial or","non commercial or commercial","commercial or commercial use","or commercial use if","commercial use if changed","use if changed it","if changed it must","changed it must be","it must be renamed","must be renamed inclusion","be renamed inclusion in","renamed inclusion in a","inclusion in a commercial","in a commercial software","a commercial software package","commercial software package is","software package is also","package is also permitted","is also permitted but","also permitted but i","permitted but i would","but i would appreciate","i would appreciate receiving","would appreciate receiving a","appreciate receiving a free","receiving a free copy","a free copy for","free copy for my","copy for my personal","for my personal examination","my personal examination and","personal examination and use","examination and use there","and use there are","use there are no","there are no guarantees","are no guarantees that","no guarantees that this","guarantees that this package","that this package is","this package is good","package is good for","is good for anything","good for anything i","for anything i have","anything i have tested","i have tested it","have tested it with","tested it with latex","it with latex 2e","with latex 2e latex","latex 2e latex 2","2e latex 2 09","latex 2 09 and","2 09 and plain","09 and plain tex","and plain tex although","plain tex although i","tex although i know","although i know of","i know of no","know of no reason","of no reason it","no reason it will","reason it will not","it will not work","will not work with","not work with amstex","work with amstex i","with amstex i have","amstex i have not","i have not tested","have not tested it","this is a package of","is a package of commutative","a package of commutative diagram","package of commutative diagram macros"]},{"licenseTexts":["\"THE BEER-WARE LICENSE\" (Revision 42):\n\n\u003cphk@FreeBSD.ORG\u003e wrote this file. As long as you retain this notice you can do whatever you want with this stuff. If we meet some day, and you think this stuff is worth it, you can buy me a beer in return Poul-Henning Kamp"],"licenseIds":["Beerware"],"keywords":["the beer ware","beer ware license","ware license revision","license revision 42","revision 42 phk","42 phk freebsd","phk freebsd org","freebsd org wrote","org wrote this","wrote this file","file as long","this notice you","notice you can","can do whatever","do whatever you","want with this","with this stuff","this stuff if","stuff if we","if we meet","we meet some","meet some day","some day and","day and you","and you think","you think this","think this stuff","this stuff is","stuff is worth","is worth it","worth it you","you can buy","can buy me","buy me a","me a beer","a beer in","beer in return","in return poul","return poul henning","poul henning kamp","the beer ware license","beer ware license revision","ware license revision 42","license revision 42 phk","revision 42 phk freebsd","42 phk freebsd org","phk freebsd org wrote","freebsd org wrote this","org wrote this file","wrote this file as","this file as long","file as long as","as you retain this","you retain this notice","retain this notice you","this notice you can","notice you can do","you can do whatever","can do whatever you","do whatever you want","whatever you want with","you want with this","want with this stuff","with this stuff if","this stuff if we","stuff if we meet","if we meet some","we meet some day","meet some day and","some day and you","day and you think","and you think this","you think this stuff","think this stuff is","this stuff is worth","stuff is worth it","is worth it you","worth it you can","it you can buy","you can buy me","can buy me a","buy me a beer","me a beer in","a beer in return","beer in return poul","in return poul henning","return poul henning kamp","the beer ware license revision","beer ware license revision 42","ware license revision 42 phk","license revision 42 phk freebsd","revision 42 phk freebsd org","42 phk freebsd org wrote","phk freebsd org wrote this","freebsd org wrote this file","org wrote this file as","wrote this file as long","this file as long as","file as long as you","long as you retain this","as you retain this notice","you retain this notice you","retain this notice you can","this notice you can do","notice you can do whatever","you can do whatever you","can do whatever you want","do whatever you want with","whatever you want with this","you want with this stuff","want with this stuff if","with this stuff if we","this stuff if we meet","stuff if we meet some","if we meet some day","we meet some day and","meet some day and you","some day and you think","day and you think this","and you think this stuff","you think this stuff is","think this stuff is worth","this stuff is worth it","stuff is worth it you","is worth it you can","worth it you can buy","it you can buy me","you can buy me a","can buy me a beer","buy me a beer in","me a beer in return","a beer in return poul","beer in return poul henning","in return poul henning kamp"]},{"licenseTexts":["BitTorrent Open Source License\n\nVersion 1.0\n\nThis BitTorrent Open Source License (the \"License\") applies to the BitTorrent client and related software products as well as any updates or maintenance releases of that software (\"BitTorrent Products\") that are distributed by BitTorrent, Inc. (\"Licensor\"). Any BitTorrent Product licensed pursuant to this License is a Licensed Product. Licensed Product, in its entirety, is protected by U.S. copyright law. This License identifies the terms under which you may use, copy, distribute or modify Licensed Product.\n\nPreamble\n\nThis Preamble is intended to describe, in plain English, the nature and scope of this License. However, this Preamble is not a part of this license. The legal effect of this License is dependent only upon the terms of the License and not this Preamble.\n\nThis License complies with the Open Source Definition and is derived from the Jabber Open Source License 1.0 (the \"JOSL\"), which has been approved by Open Source Initiative. Sections 4(c) and 4(f)(iii) from the JOSL have been dropped.\n\nThis License provides that:\n\n   1. You may use, sell or give away the Licensed Product, alone or as a component of an aggregate software distribution containing programs from several different sources. No royalty or other fee is required.\n\n   2. Both Source Code and executable versions of the Licensed Product, including Modifications made by previous Contributors, are available for your use. (The terms \"Licensed Product,\" \"Modifications,\" \"Contributors\" and \"Source Code\" are defined in the License.)\n\n   3. You are allowed to make Modifications to the Licensed Product, and you can create Derivative Works from it. (The term \"Derivative Works\" is defined in the License.)\n\n   4. By accepting the Licensed Product under the provisions of this License, you agree that any Modifications you make to the Licensed Product and then distribute are governed by the provisions of this License. In particular, you must make the Source Code of your Modifications available to others.\n\n   5. You may use the Licensed Product for any purpose, but the Licensor is not providing you any warranty whatsoever, nor is the Licensor accepting any liability in the event that the Licensed Product doesn't work properly or causes you any injury or damages.\n\n   6. If you sublicense the Licensed Product or Derivative Works, you may charge fees for warranty or support, or for accepting indemnity or liability obligations to your customers. You cannot charge for the Source Code.\n\n   7. If you assert any patent claims against the Licensor relating to the Licensed Product, or if you breach any terms of the License, your rights to the Licensed Product under this License automatically terminate.\n\nYou may use this License to distribute your own Derivative Works, in which case the provisions of this License will apply to your Derivative Works just as they do to the original Licensed Product.\n\nAlternatively, you may distribute your Derivative Works under any other OSI-approved Open Source license, or under a proprietary license of your choice. If you use any license other than this License, however, you must continue to fulfill the requirements of this License (including the provisions relating to publishing the Source Code) for those portions of your Derivative Works that consist of the Licensed Product, including the files containing Modifications.\n\nNew versions of this License may be published from time to time. You may choose to continue to use the license terms in this version of the License or those from the new version. However, only the Licensor has the right to change the License terms as they apply to the Licensed Product.\n\nThis License relies on precise definitions for certain terms. Those terms are defined when they are first used, and the definitions are repeated for your convenience in a Glossary at the end of the License.\n\nLicense Terms\n\n   1. Grant of License From Licensor. Licensor hereby grants you a world-wide, royalty-free, non-exclusive license, subject to third party intellectual property claims, to do the following:\n\n      a. Use, reproduce, modify, display, perform, sublicense and distribute any Modifications created by such Contributor or portions thereof, in both Source Code or as an executable program, either on an unmodified basis or as part of Derivative Works.\n\n      b. Under claims of patents now or hereafter owned or controlled by Contributor, to make, use, sell, offer for sale, have made, and/or otherwise dispose of Modifications or portions thereof, but solely to the extent that any such claim is necessary to enable you to make, use, sell, offer for sale, have made, and/or otherwise dispose of Modifications or portions thereof or Derivative Works thereof.\n\n   2. Grant of License to Modifications From Contributor. \"Modifications\" means any additions to or deletions from the substance or structure of (i) a file containing Licensed Product, or (ii) any new file that contains any part of Licensed Product. Hereinafter in this License, the term \"Licensed Product\" shall include all previous Modifications that you receive from any Contributor. By application of the provisions in Section 4(a) below, each person or entity who created or contributed to the creation of, and distributed, a Modification (a \"Contributor\") hereby grants you a world-wide, royalty-free, non-exclusive license, subject to third party intellectual property claims, to do the following:\n\n      a. Use, reproduce, modify, display, perform, sublicense and distribute any Modifications created by such Contributor or portions thereof, in both Source Code or as an executable program, either on an unmodified basis or as part of Derivative Works.\n\n      b. Under claims of patents now or hereafter owned or controlled by Contributor, to make, use, sell, offer for sale, have made, and/or otherwise dispose of Modifications or portions thereof, but solely to the extent that any such claim is necessary to enable you to make, use, sell, offer for sale, have made, and/or otherwise dispose of Modifications or portions thereof or Derivative Works thereof.\n\n   3. Exclusions From License Grant. Nothing in this License shall be deemed to grant any rights to trademarks, copyrights, patents, trade secrets or any other intellectual property of Licensor or any Contributor except as expressly stated herein. No patent license is granted separate from the Licensed Product, for code that you delete from the Licensed Product, or for combinations of the Licensed Product with other software or hardware. No right is granted to the trademarks of Licensor or any Contributor even if such marks are included in the Licensed Product. Nothing in this License shall be interpreted to prohibit Licensor from licensing under different terms from this License any code that Licensor otherwise would have a right to license.\n\n   4. Your Obligations Regarding Distribution.\n\n      a. Application of This License to Your Modifications. As an express condition for your use of the Licensed Product, you hereby agree that any Modifications that you create or to which you contribute, and which you distribute, are governed by the terms of this License including, without limitation, Section 2. Any Modifications that you create or to which you contribute may be distributed only under the terms of this License or a future version of this License released under Section 7. You must include a copy of this License with every copy of the Modifications you distribute. You agree not to offer or impose any terms on any Source Code or executable version of the Licensed Product or Modifications that alter or restrict the applicable version of this License or the recipients' rights hereunder. However, you may include an additional document offering the additional rights described in Section 4(d).\n\n      b. Availability of Source Code. You must make available, under the terms of this License, the Source Code of the Licensed Product and any Modifications that you distribute, either on the same media as you distribute any executable or other form of the Licensed Product, or via a mechanism generally accepted in the software development community for the electronic transfer of data (an \"Electronic Distribution Mechanism\"). The Source Code for any version of Licensed Product or Modifications that you distribute must remain available for at least twelve (12) months after the date it initially became available, or at least six (6) months after a subsequent version of said Licensed Product or Modifications has been made available. You are responsible for ensuring that the Source Code version remains available even if the Electronic Distribution Mechanism is maintained by a third party.\n\n      c. Intellectual Property Matters.\n\n         i. Third Party Claims. If you have knowledge that a license to a third party's intellectual property right is required to exercise the rights granted by this License, you must include a text file with the Source Code distribution titled \"LEGAL\" that describes the claim and the party making the claim in sufficient detail that a recipient will know whom to contact. If you obtain such knowledge after you make any Modifications available as described in Section 4(b), you shall promptly modify the LEGAL file in all copies you make available thereafter and shall take other steps (such as notifying appropriate mailing lists or newsgroups) reasonably calculated to inform those who received the Licensed Product from you that new knowledge has been obtained.\n\n         ii. Contributor APIs. If your Modifications include an application programming interface (\"API\") and you have knowledge of patent licenses that are reasonably necessary to implement that API, you must also include this information in the LEGAL file.\n\n         iii. Representations. You represent that, except as disclosed pursuant to 4(c)(i) above, you believe that any Modifications you distribute are your original creations and that you have sufficient rights to grant the rights conveyed by this License.\n\n      d. Required Notices. You must duplicate this License in any documentation you provide along with the Source Code of any Modifications you create or to which you contribute, and which you distribute, wherever you describe recipients' rights relating to Licensed Product. You must duplicate the notice contained in Exhibit A (the \"Notice\") in each file of the Source Code of any copy you distribute of the Licensed Product. If you created a Modification, you may add your name as a Contributor to the Notice. If it is not possible to put the Notice in a particular Source Code file due to its structure, then you must include such Notice in a location (such as a relevant directory file) where a user would be likely to look for such a notice. You may choose to offer, and charge a fee for, warranty, support, indemnity or liability obligations to one or more recipients of Licensed Product. However, you may do so only on your own behalf, and not on behalf of the Licensor or any Contributor. You must make it clear that any such warranty, support, indemnity or liability obligation is offered by you alone, and you hereby agree to indemnify the Licensor and every Contributor for any liability incurred by the Licensor or such Contributor as a result of warranty, support, indemnity or liability terms you offer.\n\n      e. Distribution of Executable Versions. You may distribute Licensed Product as an executable program under a license of your choice that may contain terms different from this License provided (i) you have satisfied the requirements of Sections 4(a) through 4(d) for that distribution, (ii) you include a conspicuous notice in the executable version, related documentation and collateral materials stating that the Source Code version of the Licensed Product is available under the terms of this License, including a description of how and where you have fulfilled the obligations of Section 4(b), and (iii) you make it clear that any terms that differ from this License are offered by you alone, not by Licensor or any Contributor. You hereby agree to indemnify the Licensor and every Contributor for any liability incurred by Licensor or such Contributor as a result of any terms you offer.\n\n      f. Distribution of Derivative Works. You may create Derivative Works (e.g., combinations of some or all of the Licensed Product with other code) and distribute the Derivative Works as products under any other license you select, with the proviso that the requirements of this License are fulfilled for those portions of the Derivative Works that consist of the Licensed Product or any Modifications thereto.\n\n   5. Inability to Comply Due to Statute or Regulation. If it is impossible for you to comply with any of the terms of this License with respect to some or all of the Licensed Product due to statute, judicial order, or regulation, then you must (i) comply with the terms of this License to the maximum extent possible, (ii) cite the statute or regulation that prohibits you from adhering to the License, and (iii) describe the limitations and the code they affect. Such description must be included in the LEGAL file described in Section 4(d), and must be included with all distributions of the Source Code. Except to the extent prohibited by statute or regulation, such description must be sufficiently detailed for a recipient of ordinary skill at computer programming to be able to understand it.\n\n   6. Application of This License. This License applies to code to which Licensor or Contributor has attached the Notice in Exhibit A, which is incorporated herein by this reference.\n\n   7. Versions of This License.\n\n      a. New Versions. Licensor may publish from time to time revised and/or new versions of the License.\n\n      b. Effect of New Versions. Once Licensed Product has been published under a particular version of the License, you may always continue to use it under the terms of that version. You may also choose to use such Licensed Product under the terms of any subsequent version of the License published by Licensor. No one other than Licensor has the right to modify the terms applicable to Licensed Product created under this License.\n\n      c. Derivative Works of this License. If you create or use a modified version of this License, which you may do only in order to apply it to software that is not already a Licensed Product under this License, you must rename your license so that it is not confusingly similar to this License, and must make it clear that your license contains terms that differ from this License. In so naming your license, you may not use any trademark of Licensor or any Contributor.\n\n   8. Disclaimer of Warranty. LICENSED PRODUCT IS PROVIDED UNDER THIS LICENSE ON AN AS IS BASIS, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES THAT THE LICENSED PRODUCT IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE LICENSED PRODUCT IS WITH YOU. SHOULD LICENSED PRODUCT PROVE DEFECTIVE IN ANY RESPECT, YOU (AND NOT THE LICENSOR OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. NO USE OF LICENSED PRODUCT IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER.\n\n   9. Termination.\n\n      a. Automatic Termination Upon Breach. This license and the rights granted hereunder will terminate automatically if you fail to comply with the terms herein and fail to cure such breach within thirty (30) days of becoming aware of the breach. All sublicenses to the Licensed Product that are properly granted shall survive any termination of this license. Provisions that, by their nature, must remain in effect beyond the termination of this License, shall survive.\n\n      b. Termination Upon Assertion of Patent Infringement. If you initiate litigation by asserting a patent infringement claim (excluding declaratory judgment actions) against Licensor or a Contributor (Licensor or Contributor against whom you file such an action is referred to herein as Respondent) alleging that Licensed Product directly or indirectly infringes any patent, then any and all rights granted by such Respondent to you under Sections 1 or 2 of this License shall terminate prospectively upon sixty (60) days notice from Respondent (the \"Notice Period\") unless within that Notice Period you either agree in writing (i) to pay Respondent a mutually agreeable reasonably royalty for your past or future use of Licensed Product made by such Respondent, or (ii) withdraw your litigation claim with respect to Licensed Product against such Respondent. If within said Notice Period a reasonable royalty and payment arrangement are not mutually agreed upon in writing by the parties or the litigation claim is not withdrawn, the rights granted by Licensor to you under Sections 1 and 2 automatically terminate at the expiration of said Notice Period.\n\n      c. Reasonable Value of This License. If you assert a patent infringement claim against Respondent alleging that Licensed Product directly or indirectly infringes any patent where such claim is resolved (such as by license or settlement) prior to the initiation of patent infringement litigation, then the reasonable value of the licenses granted by said Respondent under Sections 1 and 2 shall be taken into account in determining the amount or value of any payment or license.\n\n      d. No Retroactive Effect of Termination. In the event of termination under Sections 9(a) or 9(b) above, all end user license agreements (excluding licenses to distributors and resellers) that have been validly granted by you or any distributor hereunder prior to termination shall survive termination.\n\n   10. Limitation of Liability. UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER TORT (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL THE LICENSOR, ANY CONTRIBUTOR, OR ANY DISTRIBUTOR OF LICENSED PRODUCT, OR ANY SUPPLIER OF ANY OF SUCH PARTIES, BE LIABLE TO ANY PERSON FOR ANY INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, COMPUTER FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER COMMERCIAL DAMAGES OR LOSSES, EVEN IF SUCH PARTY SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF LIABILITY SHALL NOT APPLY TO LIABILITY FOR DEATH OR PERSONAL INJURY\n\n   RESULTING FROM SUCH PARTYS NEGLIGENCE TO THE EXTENT APPLICABLE LAW PROHIBITS SUCH LIMITATION. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OR LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THIS EXCLUSION AND LIMITATION MAY NOT APPLY TO YOU.\n\n   11. Responsibility for Claims. As between Licensor and Contributors, each party is responsible for claims and damages arising, directly or indirectly, out of its utilization of rights under this License. You agree to work with Licensor and Contributors to distribute such responsibility on an equitable basis. Nothing herein is intended or\n\n   shall be deemed to constitute any admission of liability.\n\n   12. U.S. Government End Users. The Licensed Product is a commercial item, as that term is defined in 48 C.F.R. 2.101 (Oct. 1995), consisting of commercial computer software and commercial computer software documentation, as such terms are used in 48 C.F.R. 12.212 (Sept. 1995). Consistent with 48 C.F.R. 12.212 and 48 C.F.R. 227.7202-1 through 227.7202-4 (June 1995), all U.S. Government End Users acquire Licensed Product with only those rights set forth herein.\n\n   13. Miscellaneous. This License represents the complete agreement concerning the subject matter hereof. If any provision of this License is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable. This License shall be governed by California law provisions (except to the extent applicable law, if any, provides otherwise), excluding its conflict-of-law provisions. You expressly agree that any litigation relating to this license shall be subject to the jurisdiction of the Federal Courts of the Northern District of California or the Superior Court of the County of Santa Clara, California (as appropriate), with venue lying in Santa Clara County, California, with the losing party responsible for costs including, without limitation, court costs and reasonable attorneys fees and expenses. The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded. You and Licensor expressly waive any rights to a jury trial in any litigation concerning Licensed Product or this License. Any law or regulation that provides that the language of a contract shall be construed against the drafter shall not apply to this License.\n\n   14. Definition of You in This License. You throughout this License, whether in upper or lower case, means an individual or a legal entity exercising rights under, and complying with all of the terms of, this License or a future version of this License issued under Section 7. For legal entities, you includes any entity that controls, is controlled by, or is under common control with you. For purposes of this definition, control means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.\n\n   15. Glossary. All defined terms in this License that are used in more than one Section of this License are repeated here, in alphabetical order, for the convenience of the reader. The Section of this License in which each defined term is first used is shown in parentheses.\n\n   Contributor: Each person or entity who created or contributed to the creation of, and distributed, a Modification. (See Section 2)\n\n   Derivative Works: That term as used in this License is defined under U.S. copyright law. (See Section 1(b))\n\n   License: This BitTorrent Open Source License. (See first paragraph of License)\n\n   Licensed Product: Any BitTorrent Product licensed pursuant to this License. The term \"Licensed Product\" includes all previous Modifications from any Contributor that you receive. (See first paragraph of License and Section 2)\n\n   Licensor: BitTorrent, Inc. (See first paragraph of License)\n\n   Modifications: Any additions to or deletions from the substance or structure of (i) a file containing Licensed Product, or (ii) any new file that contains any part of Licensed Product. (See Section 2)\n\n   Notice: The notice contained in Exhibit A. (See Section 4(e))\n\n   Source Code: The preferred form for making modifications to the Licensed Product, including all modules contained therein, plus any associated interface definition files, scripts used to control compilation and installation of an executable program, or a list of differential comparisons against the Source Code of the Licensed Product. (See\n\n   Section 1(a))\n\n   You: This term is defined in Section 14 of this License. EXHIBIT A\n\nThe Notice below must appear in each file of the Source Code of any copy you distribute of the Licensed Product or any hereto. Contributors to any Modifications may add their own copyright notices to identify their own contributions.\n\nLicense:\n\nThe contents of this file are subject to the BitTorrent Open Source License Version 1.0 (the License). You may not copy or use this file, in either source code or executable form, except in compliance with the License. You may obtain a copy of the License at http://www.bittorrent.com/license/.\n\nSoftware distributed under the License is distributed on an AS IS basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the specific language governing rights and limitations under the License."],"licenseIds":["BitTorrent-1.0"],"keywords":["0 this bittorrent","have been dropped","been dropped this","dropped this license","that any litigation","or the superior","county of santa","of santa clara","clara california as","california as appropriate","as appropriate with","appropriate with venue","concerning licensed product","product or this","entity 15 glossary","1 0 this bittorrent","0 this bittorrent open","josl have been dropped","have been dropped this","been dropped this license","dropped this license provides","agree that any litigation","that any litigation relating","california or the superior","or the superior court","the county of santa","county of santa clara","of santa clara california","santa clara california as","clara california as appropriate","california as appropriate with","as appropriate with venue","appropriate with venue lying","litigation concerning licensed product","concerning licensed product or","licensed product or this","product or this license","such entity 15 glossary","entity 15 glossary all","version 1 0 this bittorrent","1 0 this bittorrent open","0 this bittorrent open source","the josl have been dropped","josl have been dropped this","have been dropped this license","been dropped this license provides","dropped this license provides that","expressly agree that any litigation","agree that any litigation relating","that any litigation relating to","district of california or the","of california or the superior","california or the superior court","or the superior court of","of the county of santa","the county of santa clara","county of santa clara california","of santa clara california as","santa clara california as appropriate","clara california as appropriate with","california as appropriate with venue","as appropriate with venue lying","appropriate with venue lying in","any litigation concerning licensed product","litigation concerning licensed product or","concerning licensed product or this","licensed product or this license","product or this license any","of such entity 15 glossary","such entity 15 glossary all","entity 15 glossary all defined"]},{"licenseTexts":["BitTorrent Open Source License\n\nVersion 1.1\n\nThis BitTorrent Open Source License (the \"License\") applies to the BitTorrent client and related software products as well as any updates or maintenance releases of that software (\"BitTorrent Products\") that are distributed by BitTorrent, Inc. (\"Licensor\"). Any BitTorrent Product licensed pursuant to this License is a Licensed Product. Licensed Product, in its entirety, is protected by U.S. copyright law. This License identifies the terms under which you may use, copy, distribute or modify Licensed Product.\n\nPreamble\n\nThis Preamble is intended to describe, in plain English, the nature and scope of this License. However, this Preamble is not a part of this license. The legal effect of this License is dependent only upon the terms of the License and not this Preamble.\n\nThis License complies with the Open Source Definition and is derived from the Jabber Open Source License 1.0 (the \"JOSL\"), which has been approved by Open Source Initiative. Sections 4(c) and 4(f)(iii) from the JOSL have been deleted.\n\nThis License provides that:\n\n   1. You may use or give away the Licensed Product, alone or as a component of an aggregate software distribution containing programs from several different sources. No royalty or other fee is required.\n\n   2. Both Source Code and executable versions of the Licensed Product, including Modifications made by previous Contributors, are available for your use. (The terms \"Licensed Product,\" \"Modifications,\" \"Contributors\" and \"Source Code\" are defined in the License.)\n\n   3. You are allowed to make Modifications to the Licensed Product, and you can create Derivative Works from it. (The term \"Derivative Works\" is defined in the License.)\n\n   4. By accepting the Licensed Product under the provisions of this License, you agree that any Modifications you make to the Licensed Product and then distribute are governed by the provisions of this License. In particular, you must make the Source Code of your Modifications available to others free of charge and without a royalty.\n\n   5. You may sell, accept donations or otherwise receive compensation for executable versions of a Licensed Product, without paying a royalty or other fee to the Licensor or any Contributor, provided that such executable versions contain your or another Contributor's material Modifications. For the avoidance of doubt, to the extent your executable version of a Licensed Product does not contain your or another Contributor's material Modifications, you may not sell, accept donations or otherwise receive compensation for such executable.\n\n   You may use the Licensed Product for any purpose, but the Licensor is not providing you any warranty whatsoever, nor is the Licensor accepting any liability in the event that the Licensed Product doesn't work properly or causes you any injury or damages.\n\n   6. If you sublicense the Licensed Product or Derivative Works, you may charge fees for warranty or support, or for accepting indemnity or liability obligations to your customers. You cannot charge for, sell, accept donations or otherwise receive compensation for the Source Code.\n\n   7. If you assert any patent claims against the Licensor relating to the Licensed Product, or if you breach any terms of the License, your rights to the Licensed Product under this License automatically terminate.\n\nYou may use this License to distribute your own Derivative Works, in which case the provisions of this License will apply to your Derivative Works just as they do to the original Licensed Product.\n\nAlternatively, you may distribute your Derivative Works under any other OSI-approved Open Source license, or under a proprietary license of your choice. If you use any license other than this License, however, you must continue to fulfill the requirements of this License (including the provisions relating to publishing the Source Code) for those portions of your Derivative Works that consist of the Licensed Product, including the files containing\n\nModifications.\n\nNew versions of this License may be published from time to time in connection with new versions of a Licensed Product or otherwise. You may choose to continue to use the license terms in this version of the License for the Licensed Product that was originally licensed hereunder, however, the new versions of this License will at all times apply to new versions of the Licensed Product released by Licensor after the release of the new version of this License. Only the Licensor has the right to change the License terms as they apply to the Licensed Product.\n\nThis License relies on precise definitions for certain terms. Those terms are defined when they are first used, and the definitions are repeated for your convenience in a Glossary at the end of the License.\n\nLicense Terms\n\n   1. Grant of License From Licensor. Subject to the terms and conditions of this License, Licensor hereby grants you a world-wide, royalty-free, non-exclusive license, subject to third party intellectual property claims, to do the following:\n\n      a. Use, reproduce, modify, display, perform, sublicense and distribute any Modifications created by a Contributor or portions thereof, in both Source Code or as an executable program, either on an unmodified basis or as part of Derivative Works.\n\n      b. Under claims of patents now or hereafter owned or controlled by Contributor, to make, use, sell, offer for sale, have made, and/or otherwise dispose of Modifications or portions thereof, but solely to the extent that any such claim is necessary to enable you to make, use, sell, offer for sale, have made, and/or otherwise dispose of Modifications or portions thereof or Derivative Works thereof.\n\n   2. Grant of License to Modifications From Contributor. \"Modifications\" means any additions to or deletions from the substance or structure of (i) a file containing a Licensed Product, or (ii) any new file that contains any part of a Licensed Product. Hereinafter in this License, the term \"Licensed Product\" shall include all previous Modifications that you receive from any Contributor. Subject to the terms and conditions of this License, By application of the provisions in Section 4(a) below, each person or entity who created or contributed to the creation of, and distributed, a Modification (a \"Contributor\") hereby grants you a world-wide, royalty-free, non-exclusive license, subject to third party intellectual property claims, to do the following:\n\n      a. Use, reproduce, modify, display, perform, sublicense and distribute any Modifications created by such Contributor or portions thereof, in both Source Code or as an executable program, either on an unmodified basis or as part of Derivative Works.\n\n      b. Under claims of patents now or hereafter owned or controlled by Contributor, to make, use, sell, offer for sale, have made, and/or otherwise dispose of Modifications or portions thereof, but solely to the extent that any such claim is necessary to enable you to make, use, sell, offer for sale, have made, and/or otherwise dispose of Modifications or portions thereof or Derivative Works thereof.\n\n   3. Exclusions From License Grant. Nothing in this License shall be deemed to grant any rights to trademarks, copyrights, patents, trade secrets or any other intellectual property of Licensor or any Contributor except as expressly stated herein. No patent license is granted separate from the Licensed Product, for code that you delete from the Licensed Product, or for combinations of the Licensed Product with other software or hardware. No right is granted to the trademarks of Licensor or any Contributor even if such marks are included in the Licensed Product. Nothing in this License shall be interpreted to prohibit Licensor from licensing under different terms from this License any code that Licensor otherwise would have a right to license. As an express condition for your use of the Licensed Product, you hereby agree that you will not, without the prior written consent of Licensor, use any trademarks, copyrights, patents, trade secrets or any other intellectual property of Licensor or any Contributor except as expressly stated herein. For the avoidance of doubt and without limiting the foregoing, you hereby agree that you will not use or display any trademark of Licensor or any Contributor in any domain name, directory filepath, advertisement, link or other reference to you in any manner or in any media.\n\n   4. Your Obligations Regarding Distribution.\n\n      a. Application of This License to Your Modifications. As an express condition for your use of the Licensed Product, you hereby agree that any Modifications that you create or to which you contribute, and which you distribute, are governed by the terms of this License including, without limitation, Section 2. Any Modifications that you create or to which you contribute may be distributed only under the terms of this License or a future version of this License released under Section 7. You must include a copy of this License with every copy of the Modifications you distribute. You agree not to offer or impose any terms on any Source Code or executable version of the Licensed Product or Modifications that alter or restrict the applicable version of this License or the recipients' rights hereunder. However, you may include an additional document offering the additional rights described in Section 4(d).\n\n      b. Availability of Source Code. You must make available, without charge, under the terms of this License, the Source Code of the Licensed Product and any Modifications that you distribute, either on the same media as you distribute any executable or other form of the Licensed Product, or via a mechanism generally accepted in the software development community for the electronic transfer of data (an \"Electronic Distribution Mechanism\"). The Source Code for any version of Licensed Product or Modifications that you distribute must remain available for as long as any executable or other form of the Licensed Product is distributed by you. You are responsible for ensuring that the Source Code version remains available even if the Electronic Distribution Mechanism is maintained by a third party.\n\n      c. Intellectual Property Matters.\n\n         i. Third Party Claims. If you have knowledge that a license to a third party's intellectual property right is required to exercise the rights granted by this License, you must include a text file with the Source Code distribution titled \"LEGAL\" that describes the claim and the party making the claim in sufficient detail that a recipient will know whom to contact. If you obtain such knowledge after you make any Modifications available as described in Section 4(b), you shall promptly modify the LEGAL file in all copies you make available thereafter and shall take other steps (such as notifying appropriate mailing lists or newsgroups) reasonably calculated to inform those who received the Licensed Product from you that new knowledge has been obtained.\n\n         ii. Contributor APIs. If your Modifications include an application programming interface (\"API\") and you have knowledge of patent licenses that are reasonably necessary to implement that API, you must also include this information in the LEGAL file.\n\n         iii. Representations. You represent that, except as disclosed pursuant to 4(c)(i) above, you believe that any Modifications you distribute are your original creations and that you have sufficient rights to grant the rights conveyed by this License.\n\n      d. Required Notices. You must duplicate this License in any documentation you provide along with the Source Code of any Modifications you create or to which you contribute, and which you distribute, wherever you describe recipients' rights relating to Licensed Product. You must duplicate the notice contained in Exhibit A (the \"Notice\") in each file of the Source Code of any copy you distribute of the Licensed Product. If you created a Modification, you may add your name as a Contributor to the Notice. If it is not possible to put the Notice in a particular Source Code file due to its structure, then you must include such Notice in a location (such as a relevant directory file) where a user would be likely to look for such a notice. You may choose to offer, and charge a fee for, warranty, support, indemnity or liability obligations to one or more recipients of Licensed Product. However, you may do so only on your own behalf, and not on behalf of the Licensor or any Contributor. You must make it clear that any such warranty, support, indemnity or liability obligation is offered by you alone, and you hereby agree to indemnify the Licensor and every Contributor for any liability incurred by the Licensor or such Contributor as a result of warranty, support, indemnity or liability terms you offer.\n\n      e. Distribution of Executable Versions. You may distribute Licensed Product as an executable program under a license of your choice that may contain terms different from this License provided (i) you have satisfied the requirements of Sections 4(a) through 4(d) for that distribution, (ii) you include a conspicuous notice in the executable version, related documentation and collateral materials stating that the Source Code version of the Licensed Product is available under the terms of this License, including a description of how and where you have fulfilled the obligations of Section 4(b), and (iii) you make it clear that any terms that differ from this License are offered by you alone, not by Licensor or any Contributor. You hereby agree to indemnify the Licensor and every Contributor for any liability incurred by Licensor or such Contributor as a result of any terms you offer.\n\n      f. Distribution of Derivative Works. You may create Derivative Works (e.g., combinations of some or all of the Licensed Product with other code) and distribute the Derivative Works as products under any other license you select, with the proviso that the requirements of this License are fulfilled for those portions of the Derivative Works that consist of the Licensed Product or any Modifications thereto.\n\n      g. Compensation for Distribution of Executable Versions of Licensed Products, Modifications or Derivative Works. Notwithstanding any provision of this License to the contrary, by distributing, selling, licensing, sublicensing or otherwise making available any Licensed Product, or Modification or Derivative Work thereof, you and Licensor hereby acknowledge and agree that you may sell, license or sublicense for a fee, accept donations or otherwise receive compensation for executable versions of a Licensed Product, without paying a royalty or other fee to the Licensor or any other Contributor, provided that such executable versions (i) contain your or another Contributor's material Modifications, or (ii) are otherwise material Derivative Works. For purposes of this License, an executable version of the Licensed Product will be deemed to contain a material Modification, or will otherwise be deemed a material Derivative Work, if (a) the Licensed Product is modified with your own or a third party's software programs or other code, and/or the Licensed Product is combined with a number of your own or a third party's software programs or code, respectively, and (b) such software programs or code add or contribute material value, functionality or features to the License Product. For the avoidance of doubt, to the extent your executable version of a Licensed Product does not contain your or another Contributor's material Modifications or is otherwise not a material Derivative Work, in each case as contemplated herein, you may not sell, license or sublicense for a fee, accept donations or otherwise receive compensation for such executable. Additionally, without limitation of the foregoing and notwithstanding any provision of this License to the contrary, you cannot charge for, sell, license or sublicense for a fee, accept donations or otherwise receive compensation for the Source Code.\n\n   5. Inability to Comply Due to Statute or Regulation. If it is impossible for you to comply with any of the terms of this License with respect to some or all of the Licensed Product due to statute, judicial order, or regulation, then you must (i) comply with the terms of this License to the maximum extent possible, (ii) cite the statute or regulation that prohibits you from adhering to the License, and (iii) describe the limitations and the code they affect. Such description must be included in the LEGAL file described in Section 4(d), and must be included with all distributions of the Source Code. Except to the extent prohibited by statute or regulation, such description must be sufficiently detailed for a recipient of ordinary skill at computer programming to be able to understand it.\n\n   6. Application of This License. This License applies to code to which Licensor or Contributor has attached the Notice in Exhibit A, which is incorporated herein by this reference.\n\n   7. Versions of This License.\n\n      a. New Versions. Licensor may publish from time to time revised and/or new versions of the License.\n\n      b. Effect of New Versions. Once Licensed Product has been published under a particular version of the License, you may always continue to use it under the terms of that version, provided that any such license be in full force and effect at the time, and has not been revoked or otherwise terminated. You may also choose to use such Licensed Product under the terms of any subsequent version (but not any prior version) of the License published by Licensor. No one other than Licensor has the right to modify the terms applicable to Licensed Product created under this License.\n\n      c. Derivative Works of this License. If you create or use a modified version of this License, which you may do only in order to apply it to software that is not already a Licensed Product under this License, you must rename your license so that it is not confusingly similar to this License, and must make it clear that your license contains terms that differ from this License. In so naming your license, you may not use any trademark of Licensor or any Contributor.\n\n   8. Disclaimer of Warranty. LICENSED PRODUCT IS PROVIDED UNDER THIS LICENSE ON AN AS IS BASIS, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES THAT THE LICENSED PRODUCT IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE LICENSED PRODUCT IS WITH YOU. SHOULD LICENSED PRODUCT PROVE DEFECTIVE IN ANY RESPECT, YOU (AND NOT THE LICENSOR OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. NO USE OF LICENSED PRODUCT IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER.\n\n   9. Termination.\n\n      a. Automatic Termination Upon Breach. This license and the rights granted hereunder will terminate automatically if you fail to comply with the terms herein and fail to cure such breach within ten (10) days of being notified of the breach by the Licensor. For purposes of this provision, proof of delivery via email to the address listed in the 'WHOIS' database of the registrar for any website through which you distribute or market any Licensed Product, or to any alternate email address which you designate in writing to the Licensor, shall constitute sufficient notification. All sublicenses to the Licensed Product that are properly granted shall survive any termination of this license so long as they continue to complye with the terms of this License. Provisions that, by their nature, must remain in effect beyond the termination of this License, shall survive.\n\n      b. Termination Upon Assertion of Patent Infringement. If you initiate litigation by asserting a patent infringement claim (excluding declaratory judgment actions) against Licensor or a Contributor (Licensor or Contributor against whom you file such an action is referred to herein as Respondent) alleging that Licensed Product directly or indirectly infringes any patent, then any and all rights granted by such Respondent to you under Sections 1 or 2 of this License shall terminate prospectively upon sixty (60) days notice from Respondent (the \"Notice Period\") unless within that Notice Period you either agree in writing (i) to pay Respondent a mutually agreeable reasonably royalty for your past or future use of Licensed Product made by such Respondent, or (ii) withdraw your litigation claim with respect to Licensed Product against such Respondent. If within said Notice Period a reasonable royalty and payment arrangement are not mutually agreed upon in writing by the parties or the litigation claim is not withdrawn, the rights granted by Licensor to you under Sections 1 and 2 automatically terminate at the expiration of said Notice Period.\n\n      c. Reasonable Value of This License. If you assert a patent infringement claim against Respondent alleging that Licensed Product directly or indirectly infringes any patent where such claim is resolved (such as by license or settlement) prior to the initiation of patent infringement litigation, then the reasonable value of the licenses granted by said Respondent under Sections 1 and 2 shall be taken into account in determining the amount or value of any payment or license.\n\n      d. No Retroactive Effect of Termination. In the event of termination under Sections 9(a) or 9(b) above, all end user license agreements (excluding licenses to distributors and resellers) that have been validly granted by you or any distributor hereunder prior to termination shall survive termination.\n\n   10. Limitation of Liability. UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER TORT (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL THE LICENSOR, ANY CONTRIBUTOR, OR ANY DISTRIBUTOR OF LICENSED PRODUCT, OR ANY SUPPLIER OF ANY OF SUCH PARTIES, BE LIABLE TO ANY PERSON FOR ANY INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, COMPUTER FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER COMMERCIAL DAMAGES OR LOSSES, EVEN IF SUCH PARTY SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF LIABILITY SHALL NOT APPLY TO LIABILITY FOR DEATH OR PERSONAL INJURY RESULTING FROM SUCH PARTYS NEGLIGENCE TO THE EXTENT APPLICABLE LAW PROHIBITS SUCH LIMITATION. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OR LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THIS EXCLUSION AND LIMITATION MAY NOT APPLY TO YOU.\n\n   11. Responsibility for Claims. As between Licensor and Contributors, each party is responsible for claims and damages arising, directly or indirectly, out of its utilization of rights under this License. You agree to work with Licensor and Contributors to distribute such responsibility on an equitable basis. Nothing herein is intended or shall be deemed to constitute any admission of liability.\n\n   12. U.S. Government End Users. The Licensed Product is a commercial item, as that term is defined in 48 C.F.R. 2.101 (Oct. 1995), consisting of commercial computer software and commercial computer software documentation, as such terms are used in 48 C.F.R. 12.212 (Sept. 1995). Consistent with 48 C.F.R. 12.212 and 48 C.F.R. 227.7202-1 through 227.7202-4 (June 1995), all U.S. Government End Users acquire Licensed Product with only those rights set forth herein.\n\n   13. Miscellaneous. This License represents the complete agreement concerning the subject matter hereof. If any provision of this License is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable. This License shall be governed by California law provisions (except to the extent applicable law, if any, provides otherwise), excluding its conflict-of-law provisions. You expressly agree that in any litigation relating to this license the losing party shall be responsible for costs including, without limitation, court costs and reasonable attorneys fees and expenses. The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded. Any law or regulation that provides that the language of a contract shall be construed against the drafter shall not apply to this License.\n\n   14. Definition of You in This License. You throughout this License, whether in upper or lower case, means an individual or a legal entity exercising rights under, and complying with all of the terms of, this License or a future version of this License issued under Section 7. For legal entities, you includes any entity that controls, is controlled by, is under common control with, or affiliated with, you. For purposes of this definition, control means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. You are responsible for advising any affiliated entity of the terms of this License, and that any rights or privileges derived from or obtained by way of this License are subject to the restrictions outlined herein.\n\n   15. Glossary. All defined terms in this License that are used in more than one Section of this License are repeated here, in alphabetical order, for the convenience of the reader. The Section of this License in which each defined term is first used is shown in parentheses.\n\n   Contributor: Each person or entity who created or contributed to the creation of, and distributed, a Modification. (See Section 2)\n\n   Derivative Works: That term as used in this License is defined under U.S. copyright law. (See Section 1(b))\n\n   License: This BitTorrent Open Source License. (See first paragraph of License)\n\n   Licensed Product: Any BitTorrent Product licensed pursuant to this License. The term \"Licensed Product\" includes all previous Modifications from any Contributor that you receive. (See first paragraph of License and Section 2)\n\n   Licensor: BitTorrent, Inc. (See first paragraph of License)\n\n   Modifications: Any additions to or deletions from the substance or structure of (i) a file containing Licensed\n\n   Product, or (ii) any new file that contains any part of Licensed Product. (See Section 2)\n\n   Notice: The notice contained in Exhibit A. (See Section 4(e))\n\n   Source Code: The preferred form for making modifications to the Licensed Product, including all modules contained therein, plus any associated interface definition files, scripts used to control compilation and installation of an executable program, or a list of differential comparisons against the Source Code of the Licensed Product. (See Section 1(a))\n\n   You: This term is defined in Section 14 of this License. EXHIBIT A\n\nThe Notice below must appear in each file of the Source Code of any copy you distribute of the Licensed Product or any hereto. Contributors to any Modifications may add their own copyright notices to identify their own contributions.\n\nLicense:\n\nThe contents of this file are subject to the BitTorrent Open Source License Version 1.1 (the License). You may not copy or use this file, in either source code or executable form, except in compliance with the License. You may obtain a copy of the License at http://www.bittorrent.com/license/.\n\nSoftware distributed under the License is distributed on an AS IS basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the specific language governing rights and limitations under the License.\n\nBitTorrent, Inc."],"licenseIds":["BitTorrent-1.1"],"keywords":["1 this bittorrent","been deleted this","deleted this license","use or give","to others free","others free of","without a royalty","a royalty 5","royalty 5 you","may sell accept","any contributor provided","executable versions contain","versions contain your","material modifications for","material modifications you","not sell accept","such executable you","executable you may","for sell accept","time in connection","connection with new","with new versions","or otherwise you","product that was","that was originally","was originally licensed","originally licensed hereunder","licensed hereunder however","hereunder however the","however the new","the new versions","license will at","all times apply","times apply to","apply to new","to new versions","licensed product released","product released by","released by licensor","by licensor after","licensor after the","after the release","the release of","license only the","file containing a","containing a licensed","any contributor subject","contributor subject to","license by application","to license as","license as an","will not without","not without the","of licensor use","licensor use any","use any trademarks","any trademarks copyrights","stated herein for","herein for the","of doubt and","doubt and without","and without limiting","foregoing you hereby","will not use","use or display","or display any","display any trademark","any contributor in","contributor in any","in any domain","any domain name","domain name directory","name directory filepath","directory filepath advertisement","filepath advertisement link","advertisement link or","link or other","or other reference","other reference to","reference to you","any manner or","manner or in","in any media","any media 4","media 4 your","make available without","without charge under","long as any","as any executable","modifications thereto g","thereto g compensation","g compensation for","compensation for distribution","versions of licensed","of licensed products","licensed products modifications","products modifications or","modifications or derivative","derivative works notwithstanding","works notwithstanding any","the contrary by","contrary by distributing","by distributing selling","distributing selling licensing","selling licensing sublicensing","licensing sublicensing or","sublicensing or otherwise","making available any","available any licensed","product or modification","or modification or","modification or derivative","derivative work thereof","work thereof you","thereof you and","licensor hereby acknowledge","hereby acknowledge and","may sell license","other contributor provided","executable versions i","versions i contain","i contain your","or ii are","ii are otherwise","are otherwise material","otherwise material derivative","material derivative works","derivative works for","works for purposes","license an executable","licensed product will","product will be","will be deemed","deemed to contain","contain a material","a material modification","material modification or","modification or will","or will otherwise","will otherwise be","otherwise be deemed","deemed a material","derivative work if","work if a","a the licensed","product is modified","is modified with","modified with your","or other code","or the licensed","product is combined","combined with a","number of your","or code respectively","code respectively and","respectively and b","and b such","b such software","such software programs","or code add","code add or","add or contribute","or contribute material","contribute material value","material value functionality","value functionality or","functionality or features","or features to","features to the","the license product","license product for","product for the","modifications or is","is otherwise not","otherwise not a","not a material","each case as","case as contemplated","as contemplated herein","contemplated herein you","not sell license","such executable additionally","executable additionally without","additionally without limitation","without limitation of","limitation of the","the foregoing and","foregoing and notwithstanding","the contrary you","contrary you cannot","for sell license","source code 5","code 5 inability","that version provided","any such license","such license be","license be in","be in full","and effect at","effect at the"]},{"licenseTexts":["# Blue Oak Model License\n\nVersion 1.0.0\n\n## Purpose\n\nThis license gives everyone as much permission to work with this software as possible, while protecting contributors from liability.\n\n## Acceptance\n\nIn order to receive this license, you must agree to its rules. The rules of this license are both obligations under that agreement and conditions to your license. You must not do anything with this software that triggers a rule that you cannot or will not follow.\n\n## Copyright\n\nEach contributor licenses you to do everything with this software that would otherwise infringe that contributor's copyright in it.\n\n## Notices\n\nYou must ensure that everyone who gets a copy of any part of this software from you, with or without changes, also gets the text of this license or a link to \u003chttps://blueoakcouncil.org/license/1.0.0\u003e.\n\n## Excuse\n\nIf anyone notifies you in writing that you have not complied with [Notices](#notices) , you can keep your license by taking all practical steps to comply within 30 days after the notice. If you do not do so, your license ends immediately.\n\n## Patent\n\nEach contributor licenses you to do everything with this software that would otherwise infringe any patent claims they can license or become able to license.\n\n## Reliability\n\nNo contributor can revoke this license.\n\n## No Liability\n\n***As far as the law allows, this software comes as is, without any warranty or condition, and no contributor will be liable to anyone for any damages related to this software or this license, under any kind of legal claim.***"],"licenseIds":["BlueOak-1.0.0"],"keywords":["model license version","0 0 purpose","0 purpose this","license gives everyone","gives everyone as","everyone as much","as much permission","much permission to","permission to work","software as possible","as possible while","possible while protecting","while protecting contributors","protecting contributors from","contributors from liability","from liability acceptance","liability acceptance in","a rule that","rule that you","that you cannot","not follow copyright","follow copyright each","copyright each contributor","otherwise infringe that","infringe that contributor","in it notices","it notices you","or a link","link to https","to https blueoakcouncil","0 0 excuse","0 excuse if","excuse if anyone","anyone notifies you","notifies you in","you in writing","have not complied","complied with notices","with notices notices","notices notices you","notices you can","you can keep","can keep your","keep your license","your license by","do not do","do so your","so your license","your license ends","ends immediately patent","immediately patent each","patent each contributor","patent claims they","claims they can","license reliability no","reliability no contributor","no contributor can","contributor can revoke","can revoke this","condition and no","and no contributor","no contributor will","oak model license version","model license version 1","version 1 0 0","1 0 0 purpose","0 0 purpose this","0 purpose this license","this license gives everyone","license gives everyone as","gives everyone as much","everyone as much permission","as much permission to","much permission to work","permission to work with","to work with this","work with this software","with this software as","this software as possible","software as possible while","as possible while protecting","possible while protecting contributors","while protecting contributors from","protecting contributors from liability","contributors from liability acceptance","from liability acceptance in","liability acceptance in order","triggers a rule that","a rule that you","rule that you cannot","that you cannot or","will not follow copyright","not follow copyright each","follow copyright each contributor","copyright each contributor licenses","would otherwise infringe that","otherwise infringe that contributor","infringe that contributor s","that contributor s copyright","copyright in it notices","in it notices you","it notices you must","license or a link","or a link to","a link to https","link to https blueoakcouncil","to https blueoakcouncil org","1 0 0 excuse","0 0 excuse if","0 excuse if anyone","excuse if anyone notifies","if anyone notifies you","anyone notifies you in","notifies you in writing","you in writing that","that you have not","you have not complied","have not complied with","not complied with notices","complied with notices notices","with notices notices you","notices notices you can","notices you can keep","you can keep your","can keep your license","keep your license by","your license by taking","the notice if you","notice if you do","you do not do","do not do so","not do so your","do so your license","so your license ends","your license ends immediately","license ends immediately patent","ends immediately patent each","immediately patent each contributor","patent each contributor licenses","otherwise infringe any patent","infringe any patent claims","any patent claims they","patent claims they can","claims they can license","to license reliability no","license reliability no contributor","reliability no contributor can","no contributor can revoke","contributor can revoke this","can revoke this license","or condition and no","condition and no contributor","and no contributor will","no contributor will be","blue oak model license version","oak model license version 1","model license version 1 0","license version 1 0 0","version 1 0 0 purpose","1 0 0 purpose this","0 0 purpose this license","0 purpose this license gives","purpose this license gives everyone","this license gives everyone as","license gives everyone as much","gives everyone as much permission","everyone as much permission to","as much permission to work","much permission to work with","permission to work with this","to work with this software","work with this software as","with this software as possible","this software as possible while","software as possible while protecting","as possible while protecting contributors","possible while protecting contributors from","while protecting contributors from liability","protecting contributors from liability acceptance","contributors from liability acceptance in","from liability acceptance in order","liability acceptance in order to","acceptance in order to receive","license are both obligations under","not do anything with this","that triggers a rule that","triggers a rule that you","a rule that you cannot","rule that you cannot or","that you cannot or will","or will not follow copyright","will not follow copyright each","not follow copyright each contributor","follow copyright each contributor licenses","copyright each contributor licenses you","that would otherwise infringe that","would otherwise infringe that contributor","otherwise infringe that contributor s","infringe that contributor s copyright","that contributor s copyright in"]},{"licenseTexts":["Copyright 1993 Francis Borceux\n\nYou may freely use, modify, and/or distribute each of the files in this package without limitation. The package consists of the following files:\n\nREADME\n\ncompatibility/OldDiagram\n\ncompatibility/OldMaxiDiagram\n\ncompatibility/OldMicroDiagram\n\ncompatibility/OldMiniDiagram\n\ncompatibility/OldMultipleArrows\n\ndiagram/Diagram\n\ndiagram/MaxiDiagram\n\ndiagram/MicroDiagram\n\ndiagram/MiniDiagram\n\ndiagram/MultipleArrows\n\nuser-guides/Diagram_Mode_d_Emploi\n\nuser-guides/Diagram_Read_Me\n\nOf course no support is guaranteed, but the author will attempt to assist with problems. Current email address:\n\nfrancis dot borceux at uclouvain dot be."],"licenseIds":["Borceux"],"keywords":["copyright 1993 francis","1993 francis borceux","francis borceux you","borceux you may","may freely use","freely use modify","or distribute each","distribute each of","package without limitation","limitation the package","the package consists","package consists of","the following files","following files readme","files readme compatibility","readme compatibility olddiagram","compatibility olddiagram compatibility","olddiagram compatibility oldmaxidiagram","compatibility oldmaxidiagram compatibility","oldmaxidiagram compatibility oldmicrodiagram","compatibility oldmicrodiagram compatibility","oldmicrodiagram compatibility oldminidiagram","compatibility oldminidiagram compatibility","oldminidiagram compatibility oldmultiplearrows","compatibility oldmultiplearrows diagram","oldmultiplearrows diagram diagram","diagram diagram diagram","diagram diagram maxidiagram","diagram maxidiagram diagram","maxidiagram diagram microdiagram","diagram microdiagram diagram","microdiagram diagram minidiagram","diagram minidiagram diagram","minidiagram diagram multiplearrows","diagram multiplearrows user","multiplearrows user guides","guides diagram mode","diagram mode d","mode d emploi","d emploi user","emploi user guides","guides diagram read","diagram read me","read me of","me of course","of course no","course no support","no support is","support is guaranteed","is guaranteed but","guaranteed but the","but the author","the author will","author will attempt","will attempt to","attempt to assist","to assist with","assist with problems","with problems current","problems current email","current email address","email address francis","address francis dot","francis dot borceux","dot borceux at","borceux at uclouvain","at uclouvain dot","uclouvain dot be","copyright 1993 francis borceux","1993 francis borceux you","francis borceux you may","borceux you may freely","you may freely use","may freely use modify","freely use modify and","use modify and or","and or distribute each","or distribute each of","distribute each of the","files in this package","in this package without","this package without limitation","package without limitation the","without limitation the package","limitation the package consists","the package consists of","package consists of the","consists of the following","of the following files","the following files readme","following files readme compatibility","files readme compatibility olddiagram","readme compatibility olddiagram compatibility","compatibility olddiagram compatibility oldmaxidiagram","olddiagram compatibility oldmaxidiagram compatibility","compatibility oldmaxidiagram compatibility oldmicrodiagram","oldmaxidiagram compatibility oldmicrodiagram compatibility","compatibility oldmicrodiagram compatibility oldminidiagram","oldmicrodiagram compatibility oldminidiagram compatibility","compatibility oldminidiagram compatibility oldmultiplearrows","oldminidiagram compatibility oldmultiplearrows diagram","compatibility oldmultiplearrows diagram diagram","oldmultiplearrows diagram diagram diagram","diagram diagram diagram maxidiagram","diagram diagram maxidiagram diagram","diagram maxidiagram diagram microdiagram","maxidiagram diagram microdiagram diagram","diagram microdiagram diagram minidiagram","microdiagram diagram minidiagram diagram","diagram minidiagram diagram multiplearrows","minidiagram diagram multiplearrows user","diagram multiplearrows user guides","multiplearrows user guides diagram","user guides diagram mode","guides diagram mode d","diagram mode d emploi","mode d emploi user","d emploi user guides","emploi user guides diagram","user guides diagram read","guides diagram read me","diagram read me of","read me of course","me of course no","of course no support","course no support is","no support is guaranteed","support is guaranteed but","is guaranteed but the","guaranteed but the author","but the author will","the author will attempt","author will attempt to","will attempt to assist","attempt to assist with","to assist with problems","assist with problems current","with problems current email","problems current email address","current email address francis","email address francis dot","address francis dot borceux","francis dot borceux at","dot borceux at uclouvain","borceux at uclouvain dot","at uclouvain dot be","copyright 1993 francis borceux you","1993 francis borceux you may","francis borceux you may freely","borceux you may freely use","you may freely use modify","may freely use modify and","freely use modify and or","use modify and or distribute","modify and or distribute each","and or distribute each of","or distribute each of the","distribute each of the files","each of the files in","the files in this package","files in this package without","in this package without limitation","this package without limitation the","package without limitation the package","without limitation the package consists","limitation the package consists of","the package consists of the","package consists of the following","consists of the following files","of the following files readme","the following files readme compatibility","following files readme compatibility olddiagram","files readme compatibility olddiagram compatibility","readme compatibility olddiagram compatibility oldmaxidiagram","compatibility olddiagram compatibility oldmaxidiagram compatibility","olddiagram compatibility oldmaxidiagram compatibility oldmicrodiagram","compatibility oldmaxidiagram compatibility oldmicrodiagram compatibility","oldmaxidiagram compatibility oldmicrodiagram compatibility oldminidiagram","compatibility oldmicrodiagram compatibility oldminidiagram compatibility","oldmicrodiagram compatibility oldminidiagram compatibility oldmultiplearrows","compatibility oldminidiagram compatibility oldmultiplearrows diagram","oldminidiagram compatibility oldmultiplearrows diagram diagram","compatibility oldmultiplearrows diagram diagram diagram","oldmultiplearrows diagram diagram diagram maxidiagram","diagram diagram diagram maxidiagram diagram","diagram diagram maxidiagram diagram microdiagram","diagram maxidiagram diagram microdiagram diagram","maxidiagram diagram microdiagram diagram minidiagram","diagram microdiagram diagram minidiagram diagram","microdiagram diagram minidiagram diagram multiplearrows","diagram minidiagram diagram multiplearrows user","minidiagram diagram multiplearrows user guides","diagram multiplearrows user guides diagram","multiplearrows user guides diagram mode","user guides diagram mode d","guides diagram mode d emploi","diagram mode d emploi user","mode d emploi user guides","d emploi user guides diagram","emploi user guides diagram read"]},{"licenseTexts":["# The Cryptographic Autonomy License, v. 1.0\n\n*This Cryptographic Autonomy License (the \"License\") applies to any Work whose owner has marked it with any of the following notices, or a similar demonstration of intent: *\n\n\n\nSPDX-License-Identifier: CAL-1.0\n\nLicensed under the Cryptographic Autonomy License version 1.0\n\n\n\n*or*\n\n\n\nSPDX-License-Identifier: CAL-1.0-Combined-Work-Exception\n\nLicensed under the Cryptographic Autonomy License version 1.0, with Combined Work Exception\n\n______________________________________________________________________\n\n\n\n   ## 1. Purpose\n\n   This License gives You unlimited permission to use and modify the software to which it applies (the \"Work\"), either as-is or in modified form, for Your private purposes, while protecting the owners and contributors to the software from liability.\n\n   This License also strives to protect the freedom and autonomy of third parties who receive the Work from you. If any non-affiliated third party receives any part, aspect, or element of the Work from You, this License requires that You provide that third party all the permissions and materials needed to independently use and modify the Work without that third party having a loss of data or capability due to your actions.\n\n   The full permissions, conditions, and other terms are laid out below.\n\n   ## 2. Receiving a License\n\n   In order to receive this License, You must agree to its rules. The rules of this License are both obligations of Your agreement with the Licensor and conditions to your License. You must not do anything with the Work that triggers a rule You cannot or will not follow.\n\n      ### 2.1. Application\n\n      The terms of this License apply to the Work as you receive it from Licensor, as well as to any modifications, elaborations, or implementations created by You that contain any licensable portion of the Work (a \"Modified Work\"). Unless specified, any reference to the Work also applies to a Modified Work.\n\n      ### 2.2. Offer and Acceptance\n\n      This License is automatically offered to every person and organization. You show that you accept this License and agree to its conditions by taking any action with the Work that, absent this License, would infringe any intellectual property right held by Licensor.\n\n      ### 2.3. Compliance and Remedies\n\n      Any failure to act according to the terms and conditions of this License places Your use of the Work outside the scope of the License and infringes the intellectual property rights of the Licensor. In the event of infringement, the terms and conditions of this License may be enforced by Licensor under the intellectual property laws of any jurisdiction to which You are subject. You also agree that either the Licensor or a Recipient (as an intended third-party beneficiary) may enforce the terms and conditions of this License against You via specific performance.\n\n   ## 3. Permissions \n\n   \n\n      ### 3.1. Permissions Granted\n\n      Conditioned on compliance with section 4, and subject to the limitations of section 3.2, Licensor grants You the world-wide, royalty-free, non-exclusive permission to:\n\n         + a) Take any action with the Work that would infringe the non-patent intellectual property laws of any jurisdiction to which You are subject; and\n\n         + b) claims that Licensor can license or becomes able to license, to the extent that those claims are embodied in the Work as distributed by Licensor.\n\n      ### 3.2. Limitations on Permissions Granted\n\n      The following limitations apply to the permissions granted in section 3.1:\n\n         \n\n         + a) Licensor does not grant any patent license for claims that are only infringed due to modification of the Work as provided by Licensor, or the combination of the Work as provided by Licensor, directly or indirectly, with any other component, including other software or hardware.\n\n         \n\n         + b) Licensor does not grant any license to the trademarks, service marks, or logos of Licensor, except to the extent necessary to comply with the attribution conditions in section 4.1 of this License.\n\n   ## 4. Conditions\n\n   If You exercise any permission granted by this License, such that the Work, or any part, aspect, or element of the Work, is distributed, communicated, made available, or made perceptible to a non-Affiliate third party (a \"Recipient\"), either via physical delivery or via a network connection to the Recipient, You must comply with the following conditions:\n\n      ### 4.1. Provide Access to Source Code\n\n      Subject to the exception in section 4.4, You must provide to each Recipient a copy of, or no-charge unrestricted network access to, the Source Code corresponding to the Work (\"Access\").\n\n      The \"Source Code\" of the Work means the form of the Work preferred for making modifications, including any comments, configuration information, documentation, help materials, installation instructions, cryptographic seeds or keys, and any information reasonably necessary for the Recipient to independently compile and use the Source Code and to have full access to the functionality contained in the Work.\n\n         #### 4.1.1. Providing Network Access to the Source Code\n\n         Network Access to the Notices and Source Code may be provided by You or by a third party, such as a public software repository, and must persist during the same period in which You exercise any of the permissions granted to You under this License and for at least one year thereafter.\n\n         #### 4.1.2. Source Code for a Modified Work\n\n         Subject to the exception in section 4.5, You must provide to each Recipient of a Modified Work Access to Source Code corresponding to those portions of the Work remaining in the Modified Work as well as the modifications used by You to create the Modified Work. The Source Code corresponding to the modifications in the Modified Work must be provided to the Recipient either a) under this License, or b) under a Compatible Open Source License.\n\n         #### 4.1.3. Coordinated Disclosure of Security Vulnerabilities\n\n         You may delay providing the Source Code corresponding to a particular modification of the Work for up to ninety (90) days (the \"Embargo Period\") if:\n\n            \n\n            + a) the modification is intended to address a newly-identified vulnerability or a security flaw in the Work,\n\n            \n\n            + b) disclosure of the vulnerability or security flaw before the end of the Embargo Period would put the data, identity, or autonomy of one or more Recipients of the Work at significant risk,\n\n            \n\n            + c) You are participating in a coordinated disclosure of the vulnerability or security flaw with one or more additional Licensees, and\n\n            \n\n            + d) Access to the Source Code pertaining to the modification is provided to all Recipients at the end of the Embargo Period.\n\n      ### 4.2. Maintain User Autonomy\n\n      In addition to providing each Recipient the opportunity to have Access to the Source Code, You cannot use the permissions given under this License to interfere with a Recipient's ability to fully use an independent copy of the Work generated from the Source Code You provide with the Recipient's own User Data.\n\n      \"User Data\" means any data that is an input to or an output from the Work, where the presence of the data is necessary for substantially identical use of the Work in an equivalent context chosen by the Recipient, and where the Recipient has an existing ownership interest, an existing right to possess, or where the data has been generated by, for, or has been assigned to the Recipient.\n\n         #### 4.2.1. No Withholding User Data\n\n         Throughout any period in which You exercise any of the permissions granted to You under this License, You must also provide to any Recipient to whom you provide services via the Work, a no-charge copy, provided in a commonly used electronic form, of the Recipient's User Data in your possession, to the extent that such User Data is available to You for use in conjunction with the Work.\n\n         #### 4.2.2. No Technical Measures that Limit Access\n\n         You may not, by means of the use cryptographic methods applied to anything provided to the Recipient, by possession or control of cryptographic keys, seeds, hashes, by any other technological protection measures, or by any other method, limit a Recipient's ability to access any functionality present in Recipient's independent copy of the Work, or to deny a Recipient full control of the Recipient's User Data.\n\n         #### 4.2.3. No Legal or Contractual Measures that Limit Access\n\n         You may not contractually restrict a Recipient's ability to independently exercise the permissions granted under this License. You waive any legal power to forbid circumvention of technical protection measures that include use of the Work, and You waive any claim that the capabilities of the Work were limited or modified as a means of enforcing the legal rights of third parties against Recipients.\n\n      ### 4.3. Provide Notices and Attribution\n\n      You must retain all licensing, authorship, or attribution notices contained in the Source Code (the \"Notices\"), and provide all such Notices to each Recipient, together with a statement acknowledging the use of the Work. Notices may be provided directly to a Recipient or via an easy-to-find hyperlink to an Internet location also providing Access to Source Code.\n\n      ### 4.4. Scope of Conditions in this License\n\n      You are required to uphold the conditions of this License only relative to those who are Recipients of the Work from You. Other than providing Recipients with the applicable Notices, Access to Source Code, and a copy of and full control of their User Data, nothing in this License requires You to provide processing services to or engage in network interactions with anyone.\n\n      ### 4.5. Combined Work Exception\n\n      As an exception to condition that You provide Recipients Access to Source Code, any Source Code files marked by the Licensor as having the \"Combined Work Exception,\" or any object code exclusively resulting from Source Code files so marked, may be combined with other Software into a \"Larger Work.\" So long as you comply with the requirements to provide Recipients the applicable Notices and Access to the Source Code provided to You by Licensor, and you provide Recipients access to their User Data and do not limit Recipient's ability to independently work with their User Data, any other Software in the Larger Work as well as the Larger Work as a whole may be licensed under the terms of your choice.\n\n   ## 5. Term and Termination\n\n   The term of this License begins when You receive the Work, and continues until terminated for any of the reasons described herein, or until all Licensor's intellectual property rights in the Software expire, whichever comes first (\"Term\"). This License cannot be revoked, only terminated for the reasons listed below.\n\n      ### 5.1. Effect of Termination\n\n      If this License is terminated for any reason, all permissions granted to You under Section 3 by any Licensor automatically terminate. You will immediately cease exercising any permissions granted in this License relative to the Work, including as part of any Modified Work.\n\n      ### 5.2. Termination for Non-Compliance; Reinstatement\n\n      This License terminates automatically if You fail to comply with any of the conditions in section 4. As a special exception to termination for non-compliance, Your permissions for the Work under this License will automatically be reinstated if You come into compliance with all the conditions in section 2 within sixty (60) days of being notified by Licensor or an intended third-party beneficiary of Your noncompliance. You are eligible for reinstatement of permissions for the Work one time only, and only for the sixty days immediately after becoming aware of noncompliance. Loss of permissions granted for the Work under this License due to either a) sustained noncompliance lasting more than sixty days or b) subsequent termination for noncompliance after reinstatement, is permanent, unless rights are specifically restored by Licensor in writing.\n\n      ### 5.3. Termination Due to Litigation\n\n      If You initiate litigation against Licensor, or any Recipient of the Work, either direct or indirect, asserting that the Work directly or indirectly infringes any patent, then all permissions granted to You by this License shall terminate. In the event of termination due to litigation, all permissions validly granted by You under this License, directly or indirectly, shall survive termination. Administrative review procedures, declaratory judgment actions, counterclaims in response to patent litigation, and enforcement actions against former Licensees terminated under this section do not cause termination due to litigation.\n\n   ## 6. Disclaimer of Warranty and Limit on Liability\n\n   As far as the law allows, the Work comes AS-IS, without any warranty of any kind, and no Licensor or contributor will be liable to anyone for any damages related to this software or this license, under any kind of legal claim, or for any type of damages, including indirect, special, incidental, or consequential damages of any type arising as a result of this License or the use of the Work including, without limitation, damages for loss of goodwill, work stoppage, computer failure or malfunction, loss of profits, revenue, or any and all other commercial damages or losses.\n\n   ## 7. Other Provisions \n\n   \n\n      ### 7.1. Affiliates\n\n      An \"Affiliate\" means any other entity that, directly or indirectly through one or more intermediaries, controls, is controlled by, or is under common control with, the Licensee. Employees of a Licensee and natural persons acting as contractors exclusively providing services to Licensee are also Affiliates.\n\n      ### 7.2. Choice of Jurisdiction and Governing Law\n\n      A Licensor may require that any action or suit by a Licensee relating to a Work provided by Licensor under this License may be brought only in the courts of a particular jurisdiction and under the laws of a particular jurisdiction (excluding its conflict-of-law provisions), if Licensor provides conspicuous notice of the particular jurisdiction to all Licensees.\n\n      ### 7.3. No Sublicensing\n\n      This License is not sublicensable. Each time You provide the Work or a Modified Work to a Recipient, the Recipient automatically receives a license under the terms described in this License. You may not impose any further reservations, conditions, or other provisions on any Recipients' exercise of the permissions granted herein.\n\n      ### 7.4. Attorneys' Fees\n\n      In any action to enforce the terms of this License, or seeking damages relating thereto, including by an intended third-party beneficiary, the prevailing party shall be entitled to recover its costs and expenses, including, without limitation, reasonable attorneys' fees and costs incurred in connection with such action, including any appeal of such action. A \"prevailing party\" is the party that achieves, or avoids, compliance with this License, including through settlement. This section shall survive the termination of this License.\n\n      ### 7.5. No Waiver\n\n      Any failure by Licensor to enforce any provision of this License will not constitute a present or future waiver of such provision nor limit Licensor's ability to enforce such provision at a later time.\n\n      ### 7.6. Severability\n\n      If any provision of this License is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable. Any invalid or unenforceable portion will be interpreted to the effect and intent of the original portion. If such a construction is not possible, the invalid or unenforceable portion will be severed from this License but the rest of this License will remain in full force and effect.\n\n      ### 7.7. License for the Text of this License\n\n      The text of this license is released under the Creative Commons Attribution-ShareAlike 4.0 International License, with the caveat that any modifications of this license may not use the name \"Cryptographic Autonomy License\" or any name confusingly similar thereto to describe any derived work of this License."],"licenseIds":["CAL-1.0-Combined-Work-Exception","CAL-1.0"],"keywords":["autonomy license v","0 this cryptographic","this cryptographic autonomy","autonomy license the","any work whose","whose owner has","owner has marked","has marked it","marked it with","it with any","following notices or","notices or a","or a similar","a similar demonstration","similar demonstration of","demonstration of intent","of intent spdx","intent spdx license","1 0 licensed","0 licensed under","0 or spdx","or spdx license","1 0 combined","0 combined work","work exception licensed","exception licensed under","1 0 with","0 with combined","with combined work","work exception 1","exception 1 purpose","1 purpose this","license gives you","it applies the","applies the work","work either as","either as is","as is or","is or in","or in modified","modified form for","form for your","for your private","your private purposes","private purposes while","purposes while protecting","protecting the owners","the owners and","owners and contributors","software from liability","from liability this","liability this license","license also strives","also strives to","strives to protect","freedom and autonomy","and autonomy of","autonomy of third","third parties who","parties who receive","from you if","you if any","if any non","any non affiliated","non affiliated third","affiliated third party","third party receives","party receives any","receives any part","requires that you","you provide that","provide that third","third party all","party all the","all the permissions","the permissions and","permissions and materials","and materials needed","materials needed to","needed to independently","to independently use","independently use and","work without that","without that third","third party having","party having a","having a loss","a loss of","data or capability","or capability due","capability due to","due to your","to your actions","your actions the","actions the full","the full permissions","full permissions conditions","permissions conditions and","conditions and other","and other terms","other terms are","terms are laid","are laid out","laid out below","out below 2","below 2 receiving","2 receiving a","receiving a license","a license in","both obligations of","obligations of your","your agreement with","with the licensor","licensor and conditions","work that triggers","rule you cannot","not follow 2","follow 2 1","2 1 application","1 application the","application the terms","receive it from","it from licensor","from licensor as","licensor as well","any modifications elaborations","modifications elaborations or","elaborations or implementations","or implementations created","implementations created by","you that contain","that contain any","contain any licensable","any licensable portion","licensable portion of","work a modified","modified work unless","work unless specified","unless specified any","specified any reference","work also applies","to a modified","modified work 2","2 2 offer","2 offer and","offer and acceptance","and acceptance this","person and organization","and organization you","organization you show","you show that","show that you","that you accept","license and agree","to its conditions","its conditions by","work that absent","by licensor 2","licensor 2 3","2 3 compliance","3 compliance and","compliance and remedies","and remedies any","remedies any failure","any failure to","failure to act","license places your","places your use","the work outside","license and infringes","and infringes the","infringes the intellectual","licensor in the","event of infringement","of infringement the","under the intellectual","are subject you","subject you also","you also agree","also agree that","agree that either","that either the","either the licensor","or a recipient","recipient as an","as an intended","party beneficiary may","beneficiary may enforce","license against you","against you via","you via specific","via specific performance","specific performance 3","performance 3 permissions","3 permissions 3","permissions 3 1","3 1 permissions","1 permissions granted","permissions granted conditioned","granted conditioned on"]},{"licenseTexts":["Computer Associates Trusted Open Source License\n\nVersion 1.1\n\nPLEASE READ THIS DOCUMENT CAREFULLY AND IN ITS ENTIRETY. THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS COMPUTER ASSOCIATES TRUSTED OPEN SOURCE LICENSE (\"LICENSE\"). ANY USE, REPRODUCTION, MODIFICATION OR DISTRIBUTION OF THE PROGRAM CONSTITUTES THE RECIPIENT'S ACCEPTANCE OF THIS LICENSE.\n\nLicense Background\n\nComputer Associates International, Inc. (CA) believes in open source. We believe that the open source development approach can take appropriate software programs to unprecedented levels of quality, growth, and innovation. To demonstrate our continuing commitment to open source, we are releasing the Program (as defined below) under this License.\n\nThis License is intended to permit contributors and recipients of the Program to use the Program, including its source code, freely and without many of the concerns of some other open source licenses. Although we expect the underlying Program, and Contributions (as defined below) made to such Program, to remain open, this License is designed to permit you to maintain your own software programs free of this License unless you choose to do so. Thus, only your Contributions to the Program must be distributed under the terms of this License.\n\nThe provisions that follow set forth the terms and conditions under which you may use the Program.\n\n   1. DEFINITIONS\n\n      1.1 Contribution means (a) in the case of CA, the Original Program; and (b) in the case of each Contributor (including CA), changes and additions to the Program, where such changes and/or additions to the Program originate from and are distributed by that particular Contributor to unaffiliated third parties. A Contribution originates from a Contributor if it was added to the Program by such Contributor itself or anyone acting on such Contributors behalf. Contributions do not include additions to the Program which: (x) are separate modules of software distributed in conjunction with the Program under their own license agreement, and (y) are not derivative works of the Program.\n\n      1.2 Contributor means CA and any other person or entity that distributes the Program.\n\n      1.3 Contributor Version means as to a Contributor, that version of the Program that includes the Contributors Contribution but not any Contributions made to the Program thereafter.\n\n      1.4 Larger Work means a work that combines the Program or portions thereof with code not governed by the terms of this License.\n\n      1.5 Licensed Patents mean patents licensable by a Contributor that are infringed by the use or sale of its Contribution alone or when combined with the Program.\n\n      1.6 Original Program means the original version of the software to which this License is attached and as released by CA, including source code, object code and documentation, if any.\n\n      1.7 Program means the Original Program and Contributions.\n\n      1.8 Recipient means anyone who modifies, copies, uses or distributes the Program.\n\n   2. GRANT OF RIGHTS\n\n      2.1 Subject to the terms of this License, each Contributor hereby grants Recipient an irrevocable, non-exclusive, worldwide, royalty-free license to reproduce, prepare derivative works of, publicly display, publicly perform, distribute and sublicense the Contribution of such Contributor, if any, and such derivative works, in source code and object code form. For the avoidance of doubt, the license provided in this Section 2.1 shall not include a license to any Licensed Patents of a Contributor.\n\n      2.2 Subject to the terms of this License, each Contributor hereby grants Recipient an irrevocable, non-exclusive, worldwide, royalty-free license to the Licensed Patents to the extent necessary to make, use, sell, offer to sell and import the Contribution of such Contributor, if any, in source code and object code form. The license granted in this Section 2.2 shall apply to the combination of the Contribution and the Program if, at the time the Contribution is added by the Contributor, such addition of the Contribution causes the Licensed Patents to be infringed by such combination. Notwithstanding the foregoing, no license is granted under this Section 2.2: (a) for any code or works that do not include the Contributor Version, as it exists and is used in accordance with the terms hereof; (b) for infringements caused by: (i) third party modifications of the Contributor Version; or (ii) the combination of Contributions made by each such Contributor with other software (except as part of the Contributor Version) or other devices; or (c) with respect to Licensed Patents infringed by the Program in the absence of Contributions made by that Contributor.\n\n      2.3 Recipient understands that although each Contributor grants the licenses to its Contributions set forth herein, except as provided in Section 2.4, no assurances are provided by any Contributor that the Program does not infringe the patent or other intellectual property rights of any other person or entity. Each Contributor disclaims any liability to Recipient for claims brought by any other person or entity based on infringement of intellectual property rights or otherwise. As a condition to exercising the rights and licenses granted hereunder, each Recipient hereby assumes sole responsibility to secure any other intellectual property rights needed, if any.\n\n      2.4 Each Contributor represents and warrants that it has all right, title and interest in the copyrights in its Contributions, and has the right to grant the copyright licenses set forth in this License.\n\n   3. DISTRIBUTION REQUIREMENTS\n\n      3.1 If the Program is distributed in object code form, then a prominent notice must be included in the code itself as well as in any related documentation, stating that the source code for the Program is available from the Contributor with information on how and where to obtain the source code. A Contributor may choose to distribute the Program in object code form under its own license agreement, provided that:\n\n         * it complies with the terms and conditions of this License; and\n\n         * its license agreement:\n\n         * effectively disclaims on behalf of all Contributors all warranties and conditions, express and implied, including warranties or conditions of title and non-infringement, and implied warranties or conditions of merchantability and fitness for a particular purpose, to the maximum extent permitted by applicable law;\n\n         * effectively excludes on behalf of all Contributors all liability for damages, including direct, indirect, special, incidental and consequential damages, such as lost profits, to the maximum extent permitted by applicable law;\n\n         * states that any provisions which are inconsistent with this License are offered by that Contributor alone and not by any other party; and\n\n         * states that source code for the Program is available from such Contributor at the cost of distribution, and informs licensees how to obtain it in a reasonable manner.\n\n      3.2 When the Program is made available in source code form:\n\n         * it must be made available under this License; and\n\n         * a copy of this License must be included with each copy of the Program.\n\n      3.3 This License is intended to facilitate the commercial distribution of the Program by any Contributor. However, Contributors may only charge Recipients a one-time, upfront fee for the distribution of the Program. Contributors may not charge Recipients any recurring charge, license fee, or any ongoing royalty for the Recipients exercise of its rights under this License to the Program. Contributors shall make the source code for the Contributor Version they distribute available at a cost, if any, equal to the cost to the Contributor to physically copy and distribute the work. It is not the intent of this License to prohibit a Contributor from charging fees for any service or maintenance that a Contributor may charge to a Recipient, so long as such fees are not an attempt to circumvent the foregoing restrictions on charging royalties or other recurring fees for the Program itself.\n\n      3.4 A Contributor may create a Larger Work by combining the Program with other software code not governed by the terms of this License, and distribute the Larger Work as a single product. In such a case, the Contributor must make sure that the requirements of this License are fulfilled for the Program. Any Contributor who includes the Program in a commercial product offering, including as part of a Larger Work, may subject itself, but not any other Contributor, to additional contractual commitments, including, but not limited to, performance warranties and non-infringement representations on suchContributors behalf. No Contributor may create any additional liability for other Contributors. Therefore, if a Contributor includes the Program in a commercial product offering, such Contributor (Commercial Contributor) hereby agrees to defend and indemnify every other Contributor (Indemnified Contributor) who made Contributions to the Program distributed by the Commercial Contributor against any losses, damages and costs (collectively Losses) arising from claims, lawsuits and other legal actions brought by a third party against the Indemnified Contributor to the extent caused by the acts or omissions, including any additional contractual commitments, of such Commercial Contributor in connection with its distribution of the Program. The obligations in this section do not apply to any claims or Losses relating to any actual or alleged intellectual property infringement.\n\n      3.5 If Contributor has knowledge that a license under a third partys intellectual property rights is required to exercise the rights granted by such Contributor under Sections 2.1 or 2.2, Contributor must (a) include a text file with the Program source code distribution titled ../IP_ISSUES, and (b) notify CA in writing at Computer Associates International, Inc., One Computer Associates Plaza, Islandia, New York 11749, Attn: Open Source Group or by email at opensource@ca.com, both describing the claim and the party making the claim in sufficient detail that a Recipient and CA will know whom to contact with regard to such matter. If Contributor obtains such knowledge after the Contribution is made available, Contributor shall also promptly modify the IP_ISSUES file in all copies Contributor makes available thereafter and shall take other steps (such as notifying appropriate mailing lists or newsgroups) reasonably calculated to inform those who received the Program that such new knowledge has been obtained.\n\n      3.6 Recipient shall not remove, obscure, or modify any CA or other Contributor copyright or patent proprietary notices appearing in the Program, whether in the source code, object code or in any documentation. In addition to the obligations set forth in Section 4, each Contributor must identify itself as the originator of its Contribution, if any, in a manner that reasonably allows subsequent Recipients to identify the originator of the Contribution.\n\n   4. CONTRIBUTION RESTRICTIONS\n\n      4.1 Each Contributor must cause the Program to which the Contributor provides a Contribution to contain a file documenting the changes the Contributor made to create its version of the Program and the date of any change. Each Contributor must also include a prominent statement that the Contribution is derived, directly or indirectly, from the Program distributed by a prior Contributor, including the name of the prior Contributor from which such Contribution was derived, in (a) the Program source code, and (b) in any notice in an executable version or related documentation in which the Contributor describes the origin or ownership of the Program.\n\n   5. NO WARRANTY\n\n      5.1 EXCEPT AS EXPRESSLY SET FORTH IN THIS LICENSE, THE PROGRAM IS PROVIDED AS IS AND IN ITS PRESENT STATE AND CONDITION. NO WARRANTY, REPRESENTATION, CONDITION, UNDERTAKING OR TERM, EXPRESS OR IMPLIED, STATUTORY OR OTHERWISE, AS TO THE CONDITION, QUALITY, DURABILITY, PERFORMANCE, NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE OR USE OF THE PROGRAM IS GIVEN OR ASSUMED BY ANY CONTRIBUTOR AND ALL SUCH WARRANTIES, REPRESENTATIONS, CONDITIONS, UNDERTAKINGS AND TERMS ARE HEREBY EXCLUDED TO THE FULLEST EXTENT PERMITTED BY LAW.\n\n      5.2 Each Recipient is solely responsible for determining the appropriateness of using and distributing the Program and assumes all risks associated with its exercise of rights under this License, including but not limited to the risks and costs of program errors, compliance with applicable laws, damage to or loss of data, programs or equipment, and unavailability or interruption of operations.\n\n      5.3 Each Recipient acknowledges that the Program is not intended for use in the operation of nuclear facilities, aircraft navigation, communication systems, or air traffic control machines in which case the failure of the Program could lead to death, personal injury, or severe physical or environmental damage.\n\n   6. DISCLAIMER OF LIABILITY\n\n      6.1 EXCEPT AS EXPRESSLY SET FORTH IN THIS LICENSE, AND TO THE EXTENT PERMITTED BY LAW, NO CONTRIBUTOR SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\n   7. TRADEMARKS AND BRANDING\n\n      7.1 This License does not grant any Recipient or any third party any rights to use the trademarks or trade names now or subsequently posted at http://www.ca.com/catrdmrk.htm, or any other trademarks, service marks, logos or trade names belonging to CA (collectively CA Marks) or to any trademark, service mark, logo or trade name belonging to any Contributor. Recipient agrees not to use any CA Marks in or as part of the name of products derived from the Original Program or to endorse or promote products derived from the Original Program.\n\n      7.2 Subject to Section 7.1, Recipients may distribute the Program under trademarks, logos, and product names belonging to the Recipient provided that all copyright and other attribution notices remain in the Program.\n\n   8. PATENT LITIGATION\n\n      8.1 If Recipient institutes patent litigation against any person or entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Program itself (excluding combinations of the Program with other software or hardware) infringes such Recipients patent(s), then such Recipients rights granted under Section 2.2 shall terminate as of the date such litigation is filed.\n\n   9. OWNERSHIP\n\n      9.1 Subject to the licenses granted under this License in Sections 2.1 and 2.2 above, each Contributor retains all rights, title and interest in and to any Contributions made by such Contributor. CA retains all rights, title and interest in and to the Original Program and any Contributions made by or on behalf of CA (CA Contributions), and such CA Contributions will not be automatically subject to this License. CA may, at its sole discretion, choose to license such CA Contributions under this License, or on different terms from those contained in this License or may choose not to license them at all.\n\n   10. TERMINATION\n\n      10.1 All of Recipients rights under this License shall terminate if it fails to comply with any of the material terms or conditions of this License and does not cure such failure in a reasonable period of time after becoming aware of such noncompliance. If Recipients rights under this License terminate, Recipient agrees to cease use and distribution of the Program as soon as reasonably practicable. However, Recipients obligations under this License and any licenses granted by Recipient as a Contributor relating to the Program shall continue and survive termination.\n\n   11. GENERAL\n\n      11.1 If any provision of this License is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this License, and without further action by the parties hereto, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.\n\n      11.2 CA may publish new versions (including revisions) of this License from time to time. Each new version of the License will be given a distinguishing version number. The Program (including Contributions) may always be distributed subject to the version of the License under which it was received. In addition, after a new version of the License is published, Contributor may elect to distribute the Program (including its Contributions) under the new version. No one other than CA has the right to modify this License.\n\n      11.3 If it is impossible for Recipient to comply with any of the terms of this License with respect to some or all of the Program due to statute, judicial order, or regulation, then Recipient must: (a) comply with the terms of this License to the maximum extent possible; and (b) describe the limitations and the code they affect. Such description must be included in the IP_ISSUES file described in Section 3.5 and must be included with all distributions of the Program source code. Except to the extent prohibited by statute or regulation, such description must be sufficiently detailed for a Recipient of ordinary skill to be able to understand it.\n\n      11.4 This License is governed by the laws of the State of New York. No Recipient will bring a legal action under this License more than one year after the cause of action arose. Each Recipient waives its rights to a jury trial in any resulting litigation. Any litigation or other dispute resolution between a Recipient and CA relating to this License shall take place in the State of New York, and Recipient and CA hereby consent to the personal jurisdiction of, and venue in, the state and federal courts within that district with respect to this License. The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded.\n\n      11.5 Where Recipient is located in the province of Quebec, Canada, the following clause applies: The parties hereby confirm that they have requested that this License and all related documents be drafted in English. Les parties contractantes confirment qu'elles ont exige que le present contrat et tous les documents associes soient rediges en anglais.\n\n      11.6 The Program is subject to all export and import laws, restrictions and regulations of the country in which Recipient receives the Program. Recipient is solely responsible for complying with and ensuring that Recipient does not export, re-export, or import the Program in violation of such laws, restrictions or regulations, or without any necessary licenses and authorizations.\n\n      11.7 This License constitutes the entire agreement between the parties with respect to the subject matter hereof."],"licenseIds":["CATOSL-1.1"],"keywords":["1 1 please","1 please read","document carefully and","carefully and in","its entirety the","entirety the accompanying","of this computer","this computer associates","program constitutes the","license license background","license background computer","background computer associates","international inc ca","inc ca believes","ca believes in","believes in open","in open source","source we believe","that the open","source development approach","development approach can","approach can take","can take appropriate","take appropriate software","appropriate software programs","software programs to","programs to unprecedented","to unprecedented levels","unprecedented levels of","levels of quality","of quality growth","quality growth and","growth and innovation","and innovation to","innovation to demonstrate","to demonstrate our","demonstrate our continuing","our continuing commitment","continuing commitment to","commitment to open","to open source","source we are","we are releasing","are releasing the","releasing the program","defined below under","below under this","to permit contributors","permit contributors and","contributors and recipients","and recipients of","program to use","including its source","code freely and","freely and without","and without many","without many of","many of the","of the concerns","the concerns of","concerns of some","of some other","some other open","source licenses although","licenses although we","although we expect","we expect the","expect the underlying","the underlying program","underlying program and","and contributions as","contributions as defined","defined below made","below made to","made to such","such program to","program to remain","to remain open","remain open this","open this license","designed to permit","to permit you","permit you to","you to maintain","to maintain your","maintain your own","your own software","own software programs","software programs free","programs free of","free of this","unless you choose","choose to do","do so thus","so thus only","thus only your","only your contributions","the provisions that","provisions that follow","that follow set","follow set forth","set forth the","forth the terms","program 1 definitions","case of ca","of ca the","ca the original","each contributor including","contributor including ca","including ca changes","ca changes and","particular contributor to","contributor to unaffiliated","to unaffiliated third","unaffiliated third parties","parties a contribution","on such contributors","such contributors behalf","contributors behalf contributions","program which x","which x are","x are separate","agreement and y","and y are","y are not","program 1 2","contributor means ca","means ca and","ca and any","program 1 3","version means as","means as to","to a contributor","contributor that version","program that includes","includes the contributors","the contributors contribution","contributors contribution but","contribution but not","not any contributions","the program thereafter","program thereafter 1","thereafter 1 4","combines the program","program or portions","1 5 licensed","5 licensed patents","patents mean patents","mean patents licensable","patents licensable by","program 1 6","6 original program","to which this","license is attached","is attached and","attached and as","and as released","released by ca","by ca including","ca including source","if any 1","any 1 7","1 7 program","7 program means","and contributions 1","contributions 1 8","1 8 recipient","8 recipient means","anyone who modifies","who modifies copies","modifies copies uses","copies uses or","uses or distributes","program 2 grant","of rights 2","rights 2 1","code form for","form for the","doubt the license","2 1 shall","1 shall not","include a license","license to any","any licensed patents","licensed patents of","patents of a","a contributor 2","contributor 2 2","2 2 subject","import the contribution","form the license","2 shall apply","contribution causes the","causes the licensed","patents to be","to be infringed","infringed by such","by such combination","such combination notwithstanding","combination notwithstanding the"]},{"licenseTexts":["Creative Commons Attribution 1.0 CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE LEGAL SERVICES. DISTRIBUTION OF THIS DRAFT LICENSE DOES NOT CREATE AN ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS INFORMATION ON AN \"AS-IS\" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES REGARDING THE INFORMATION PROVIDED, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM ITS USE.\n\nLicense\n\nTHE WORK (AS DEFINED BELOW) IS PROVIDED UNDER THE TERMS OF THIS CREATIVE COMMONS PUBLIC LICENSE (\"CCPL\" OR \"LICENSE\"). THE WORK IS PROTECTED BY COPYRIGHT AND/OR OTHER APPLICABLE LAW. ANY USE OF THE WORK OTHER THAN AS AUTHORIZED UNDER THIS LICENSE IS PROHIBITED.\n\nBY EXERCISING ANY RIGHTS TO THE WORK PROVIDED HERE, YOU ACCEPT AND AGREE TO BE BOUND BY THE TERMS OF THIS LICENSE. THE LICENSOR GRANTS YOU THE RIGHTS CONTAINED HERE IN CONSIDERATION OF YOUR ACCEPTANCE OF SUCH TERMS AND CONDITIONS.\n\n   1. Definitions\n\n      a. \"Collective Work\" means a work, such as a periodical issue, anthology or encyclopedia, in which the Work in its entirety in unmodified form, along with a number of other contributions, constituting separate and independent works in themselves, are assembled into a collective whole. A work that constitutes a Collective Work will not be considered a Derivative Work (as defined below) for the purposes of this License.\n\n      b. \"Derivative Work\" means a work based upon the Work or upon the Work and other pre-existing works, such as a translation, musical arrangement, dramatization, fictionalization, motion picture version, sound recording, art reproduction, abridgment, condensation, or any other form in which the Work may be recast, transformed, or adapted, except that a work that constitutes a Collective Work will not be considered a Derivative Work for the purpose of this License.\n\n      c. \"Licensor\" means the individual or entity that offers the Work under the terms of this License.\n\n      d. \"Original Author\" means the individual or entity who created the Work.\n\n      e. \"Work\" means the copyrightable work of authorship offered under the terms of this License.\n\n      f. \"You\" means an individual or entity exercising rights under this License who has not previously violated the terms of this License with respect to the Work, or who has received express permission from the Licensor to exercise rights under this License despite a previous violation.\n\n   2. Fair Use Rights. Nothing in this license is intended to reduce, limit, or restrict any rights arising from fair use, first sale or other limitations on the exclusive rights of the copyright owner under copyright law or other applicable laws.\n\n   3. License Grant. Subject to the terms and conditions of this License, Licensor hereby grants You a worldwide, royalty-free, non-exclusive, perpetual (for the duration of the applicable copyright) license to exercise the rights in the Work as stated below:\n\n      a. to reproduce the Work, to incorporate the Work into one or more Collective Works, and to reproduce the Work as incorporated in the Collective Works;\n\n      b. to create and reproduce Derivative Works;\n\n      c. to distribute copies or phonorecords of, display publicly, perform publicly, and perform publicly by means of a digital audio transmission the Work including as incorporated in Collective Works;\n\n      d. to distribute copies or phonorecords of, display publicly, perform publicly, and perform publicly by means of a digital audio transmission Derivative Works;\n\n      The above rights may be exercised in all media and formats whether now known or hereafter devised. The above rights include the right to make such modifications as are technically necessary to exercise the rights in other media and formats. All rights not expressly granted by Licensor are hereby reserved.\n\n   4. Restrictions. The license granted in Section 3 above is expressly made subject to and limited by the following restrictions:\n\n      a. You may distribute, publicly display, publicly perform, or publicly digitally perform the Work only under the terms of this License, and You must include a copy of, or the Uniform Resource Identifier for, this License with every copy or phonorecord of the Work You distribute, publicly display, publicly perform, or publicly digitally perform. You may not offer or impose any terms on the Work that alter or restrict the terms of this License or the recipients' exercise of the rights granted hereunder. You may not sublicense the Work. You must keep intact all notices that refer to this License and to the disclaimer of warranties. You may not distribute, publicly display, publicly perform, or publicly digitally perform the Work with any technological measures that control access or use of the Work in a manner inconsistent with the terms of this License Agreement. The above applies to the Work as incorporated in a Collective Work, but this does not require the Collective Work apart from the Work itself to be made subject to the terms of this License. If You create a Collective Work, upon notice from any Licensor You must, to the extent practicable, remove from the Collective Work any reference to such Licensor or the Original Author, as requested. If You create a Derivative Work, upon notice from any Licensor You must, to the extent practicable, remove from the Derivative Work any reference to such Licensor or the Original Author, as requested.\n\n      b. If you distribute, publicly display, publicly perform, or publicly digitally perform the Work or any Derivative Works or Collective Works, You must keep intact all copyright notices for the Work and give the Original Author credit reasonable to the medium or means You are utilizing by conveying the name (or pseudonym if applicable) of the Original Author if supplied; the title of the Work if supplied; in the case of a Derivative Work, a credit identifying the use of the Work in the Derivative Work (e.g., \"French translation of the Work by Original Author,\" or \"Screenplay based on original Work by Original Author\"). Such credit may be implemented in any reasonable manner; provided, however, that in the case of a Derivative Work or Collective Work, at a minimum such credit will appear where any other comparable authorship credit appears and in a manner at least as prominent as such other comparable authorship credit.\n\n   5. Representations, Warranties and Disclaimer\n\n      a. By offering the Work for public release under this License, Licensor represents and warrants that, to the best of Licensor's knowledge after reasonable inquiry:\n\n         i. Licensor has secured all rights in the Work necessary to grant the license rights hereunder and to permit the lawful exercise of the rights granted hereunder without You having any obligation to pay any royalties, compulsory license fees, residuals or any other payments;\n\n         ii. The Work does not infringe the copyright, trademark, publicity rights, common law rights or any other right of any third party or constitute defamation, invasion of privacy or other tortious injury to any third party.\n\n      b. EXCEPT AS EXPRESSLY STATED IN THIS LICENSE OR OTHERWISE AGREED IN WRITING OR REQUIRED BY APPLICABLE LAW, THE WORK IS LICENSED ON AN \"AS IS\" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES REGARDING THE CONTENTS OR ACCURACY OF THE WORK.\n\n   6. Limitation on Liability. EXCEPT TO THE EXTENT REQUIRED BY APPLICABLE LAW, AND EXCEPT FOR DAMAGES ARISING FROM LIABILITY TO A THIRD PARTY RESULTING FROM BREACH OF THE WARRANTIES IN SECTION 5, IN NO EVENT WILL LICENSOR BE LIABLE TO YOU ON ANY LEGAL THEORY FOR ANY SPECIAL, INCIDENTAL, CONSEQUENTIAL, PUNITIVE OR EXEMPLARY DAMAGES ARISING OUT OF THIS LICENSE OR THE USE OF THE WORK, EVEN IF LICENSOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\n   7. Termination\n\n      a. This License and the rights granted hereunder will terminate automatically upon any breach by You of the terms of this License. Individuals or entities who have received Derivative Works or Collective Works from You under this License, however, will not have their licenses terminated provided such individuals or entities remain in full compliance with those licenses. Sections 1, 2, 5, 6, 7, and 8 will survive any termination of this License.\n\n      b. Subject to the above terms and conditions, the license granted here is perpetual (for the duration of the applicable copyright in the Work). Notwithstanding the above, Licensor reserves the right to release the Work under different license terms or to stop distributing the Work at any time; provided, however that any such election will not serve to withdraw this License (or any other license that has been, or is required to be, granted under the terms of this License), and this License will continue in full force and effect unless terminated as stated above.\n\n   8. Miscellaneous\n\n      a. Each time You distribute or publicly digitally perform the Work or a Collective Work, the Licensor offers to the recipient a license to the Work on the same terms and conditions as the license granted to You under this License.\n\n      b. Each time You distribute or publicly digitally perform a Derivative Work, Licensor offers to the recipient a license to the original Work on the same terms and conditions as the license granted to You under this License.\n\n      c. If any provision of this License is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this License, and without further action by the parties to this agreement, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.\n\n      d. No term or provision of this License shall be deemed waived and no breach consented to unless such waiver or consent shall be in writing and signed by the party to be charged with such waiver or consent.\n\n      e. This License constitutes the entire agreement between the parties with respect to the Work licensed here. There are no understandings, agreements or representations with respect to the Work not specified here. Licensor shall not be bound by any additional provisions that may appear in any communication from You. This License may not be modified without the mutual written agreement of the Licensor and You.\n\nCreative Commons is not a party to this License, and makes no warranty whatsoever in connection with the Work. Creative Commons will not be liable to You or any party on any legal theory for any damages whatsoever, including without limitation any general, special, incidental or consequential damages arising in connection to this license. Notwithstanding the foregoing two (2) sentences, if Creative Commons has expressly identified itself as the Licensor hereunder, it shall have all rights and obligations of Licensor.\n\nExcept for the limited purpose of indicating to the public that the Work is licensed under the CCPL, neither party will use the trademark \"Creative Commons\" or any related trademark or logo of Creative Commons without the prior written consent of Creative Commons. Any permitted use will be in compliance with Creative Commons' then-current trademark usage guidelines, as may be published on its website or otherwise made available upon request from time to time.\n\nCreative Commons may be contacted at http://creativecommons.org/."],"licenseIds":["CC-BY-1.0"],"keywords":["commons attribution 1","attribution 1 0","creative commons attribution 1","commons attribution 1 0","attribution 1 0 creative","creative commons attribution 1 0","commons attribution 1 0 creative","attribution 1 0 creative commons"]},{"licenseTexts":["Creative Commons Attribution 2.0 CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE LEGAL SERVICES. DISTRIBUTION OF THIS LICENSE DOES NOT CREATE AN ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS INFORMATION ON AN \"AS-IS\" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES REGARDING THE INFORMATION PROVIDED, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM ITS USE.\n\nLicense\n\nTHE WORK (AS DEFINED BELOW) IS PROVIDED UNDER THE TERMS OF THIS CREATIVE COMMONS PUBLIC LICENSE (\"CCPL\" OR \"LICENSE\"). THE WORK IS PROTECTED BY COPYRIGHT AND/OR OTHER APPLICABLE LAW. ANY USE OF THE WORK OTHER THAN AS AUTHORIZED UNDER THIS LICENSE OR COPYRIGHT LAW IS PROHIBITED.\n\nBY EXERCISING ANY RIGHTS TO THE WORK PROVIDED HERE, YOU ACCEPT AND AGREE TO BE BOUND BY THE TERMS OF THIS LICENSE. THE LICENSOR GRANTS YOU THE RIGHTS CONTAINED HERE IN CONSIDERATION OF YOUR ACCEPTANCE OF SUCH TERMS AND CONDITIONS.\n\n   1. Definitions\n\n      a. \"Collective Work\" means a work, such as a periodical issue, anthology or encyclopedia, in which the Work in its entirety in unmodified form, along with a number of other contributions, constituting separate and independent works in themselves, are assembled into a collective whole. A work that constitutes a Collective Work will not be considered a Derivative Work (as defined below) for the purposes of this License.\n\n      b. \"Derivative Work\" means a work based upon the Work or upon the Work and other pre-existing works, such as a translation, musical arrangement, dramatization, fictionalization, motion picture version, sound recording, art reproduction, abridgment, condensation, or any other form in which the Work may be recast, transformed, or adapted, except that a work that constitutes a Collective Work will not be considered a Derivative Work for the purpose of this License. For the avoidance of doubt, where the Work is a musical composition or sound recording, the synchronization of the Work in timed-relation with a moving image (\"synching\") will be considered a Derivative Work for the purpose of this License.\n\n      c. \"Licensor\" means the individual or entity that offers the Work under the terms of this License.\n\n      d. \"Original Author\" means the individual or entity who created the Work.\n\n      e. \"Work\" means the copyrightable work of authorship offered under the terms of this License.\n\n      f. \"You\" means an individual or entity exercising rights under this License who has not previously violated the terms of this License with respect to the Work, or who has received express permission from the Licensor to exercise rights under this License despite a previous violation.\n\n   2. Fair Use Rights. Nothing in this license is intended to reduce, limit, or restrict any rights arising from fair use, first sale or other limitations on the exclusive rights of the copyright owner under copyright law or other applicable laws.\n\n   3. License Grant. Subject to the terms and conditions of this License, Licensor hereby grants You a worldwide, royalty-free, non-exclusive, perpetual (for the duration of the applicable copyright) license to exercise the rights in the Work as stated below:\n\n      a. to reproduce the Work, to incorporate the Work into one or more Collective Works, and to reproduce the Work as incorporated in the Collective Works;\n\n      b. to create and reproduce Derivative Works;\n\n      c. to distribute copies or phonorecords of, display publicly, perform publicly, and perform publicly by means of a digital audio transmission the Work including as incorporated in Collective Works;\n\n      d. to distribute copies or phonorecords of, display publicly, perform publicly, and perform publicly by means of a digital audio transmission Derivative Works.\n\n      e. For the avoidance of doubt, where the work is a musical composition:\n\n         i. Performance Royalties Under Blanket Licenses. Licensor waives the exclusive right to collect, whether individually or via a performance rights society (e.g. ASCAP, BMI, SESAC), royalties for the public performance or public digital performance (e.g. webcast) of the Work.\n\n         ii. Mechanical Rights and Statutory Royalties. Licensor waives the exclusive right to collect, whether individually or via a music rights agency or designated agent (e.g. Harry Fox Agency), royalties for any phonorecord You create from the Work (\"cover version\") and distribute, subject to the compulsory license created by 17 USC Section 115 of the US Copyright Act (or the equivalent in other jurisdictions).\n\n      f. Webcasting Rights and Statutory Royalties. For the avoidance of doubt, where the Work is a sound recording, Licensor waives the exclusive right to collect, whether individually or via a performance-rights society (e.g. SoundExchange), royalties for the public digital performance (e.g. webcast) of the Work, subject to the compulsory license created by 17 USC Section 114 of the US Copyright Act (or the equivalent in other jurisdictions).\n\n   The above rights may be exercised in all media and formats whether now known or hereafter devised. The above rights include the right to make such modifications as are technically necessary to exercise the rights in other media and formats. All rights not expressly granted by Licensor are hereby reserved.\n\n   4. Restrictions. The license granted in Section 3 above is expressly made subject to and limited by the following restrictions:\n\n      a. You may distribute, publicly display, publicly perform, or publicly digitally perform the Work only under the terms of this License, and You must include a copy of, or the Uniform Resource Identifier for, this License with every copy or phonorecord of the Work You distribute, publicly display, publicly perform, or publicly digitally perform. You may not offer or impose any terms on the Work that alter or restrict the terms of this License or the recipients' exercise of the rights granted hereunder. You may not sublicense the Work. You must keep intact all notices that refer to this License and to the disclaimer of warranties. You may not distribute, publicly display, publicly perform, or publicly digitally perform the Work with any technological measures that control access or use of the Work in a manner inconsistent with the terms of this License Agreement. The above applies to the Work as incorporated in a Collective Work, but this does not require the Collective Work apart from the Work itself to be made subject to the terms of this License. If You create a Collective Work, upon notice from any Licensor You must, to the extent practicable, remove from the Collective Work any reference to such Licensor or the Original Author, as requested. If You create a Derivative Work, upon notice from any Licensor You must, to the extent practicable, remove from the Derivative Work any reference to such Licensor or the Original Author, as requested.\n\n      b. If you distribute, publicly display, publicly perform, or publicly digitally perform the Work or any Derivative Works or Collective Works, You must keep intact all copyright notices for the Work and give the Original Author credit reasonable to the medium or means You are utilizing by conveying the name (or pseudonym if applicable) of the Original Author if supplied; the title of the Work if supplied; to the extent reasonably practicable, the Uniform Resource Identifier, if any, that Licensor specifies to be associated with the Work, unless such URI does not refer to the copyright notice or licensing information for the Work; and in the case of a Derivative Work, a credit identifying the use of the Work in the Derivative Work (e.g., \"French translation of the Work by Original Author,\" or \"Screenplay based on original Work by Original Author\"). Such credit may be implemented in any reasonable manner; provided, however, that in the case of a Derivative Work or Collective Work, at a minimum such credit will appear where any other comparable authorship credit appears and in a manner at least as prominent as such other comparable authorship credit.\n\n   5. Representations, Warranties and Disclaimer\n\n   UNLESS OTHERWISE MUTUALLY AGREED TO BY THE PARTIES IN WRITING, LICENSOR OFFERS THE WORK AS-IS AND MAKES NO REPRESENTATIONS OR WARRANTIES OF ANY KIND CONCERNING THE WORK, EXPRESS, IMPLIED, STATUTORY OR OTHERWISE, INCLUDING, WITHOUT LIMITATION, WARRANTIES OF TITLE, MERCHANTIBILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT, OR THE ABSENCE OF LATENT OR OTHER DEFECTS, ACCURACY, OR THE PRESENCE OF ABSENCE OF ERRORS, WHETHER OR NOT DISCOVERABLE. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OF IMPLIED WARRANTIES, SO SUCH EXCLUSION MAY NOT APPLY TO YOU.\n\n   6. Limitation on Liability. EXCEPT TO THE EXTENT REQUIRED BY APPLICABLE LAW, IN NO EVENT WILL LICENSOR BE LIABLE TO YOU ON ANY LEGAL THEORY FOR ANY SPECIAL, INCIDENTAL, CONSEQUENTIAL, PUNITIVE OR EXEMPLARY DAMAGES ARISING OUT OF THIS LICENSE OR THE USE OF THE WORK, EVEN IF LICENSOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\n   7. Termination\n\n      a. This License and the rights granted hereunder will terminate automatically upon any breach by You of the terms of this License. Individuals or entities who have received Derivative Works or Collective Works from You under this License, however, will not have their licenses terminated provided such individuals or entities remain in full compliance with those licenses. Sections 1, 2, 5, 6, 7, and 8 will survive any termination of this License.\n\n      b. Subject to the above terms and conditions, the license granted here is perpetual (for the duration of the applicable copyright in the Work). Notwithstanding the above, Licensor reserves the right to release the Work under different license terms or to stop distributing the Work at any time; provided, however that any such election will not serve to withdraw this License (or any other license that has been, or is required to be, granted under the terms of this License), and this License will continue in full force and effect unless terminated as stated above.\n\n   8. Miscellaneous\n\n      a. Each time You distribute or publicly digitally perform the Work or a Collective Work, the Licensor offers to the recipient a license to the Work on the same terms and conditions as the license granted to You under this License.\n\n      b. Each time You distribute or publicly digitally perform a Derivative Work, Licensor offers to the recipient a license to the original Work on the same terms and conditions as the license granted to You under this License.\n\n      c. If any provision of this License is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this License, and without further action by the parties to this agreement, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.\n\n      d. No term or provision of this License shall be deemed waived and no breach consented to unless such waiver or consent shall be in writing and signed by the party to be charged with such waiver or consent.\n\n      e. This License constitutes the entire agreement between the parties with respect to the Work licensed here. There are no understandings, agreements or representations with respect to the Work not specified here. Licensor shall not be bound by any additional provisions that may appear in any communication from You. This License may not be modified without the mutual written agreement of the Licensor and You.\n\nCreative Commons is not a party to this License, and makes no warranty whatsoever in connection with the Work. Creative Commons will not be liable to You or any party on any legal theory for any damages whatsoever, including without limitation any general, special, incidental or consequential damages arising in connection to this license. Notwithstanding the foregoing two (2) sentences, if Creative Commons has expressly identified itself as the Licensor hereunder, it shall have all rights and obligations of Licensor.\n\nExcept for the limited purpose of indicating to the public that the Work is licensed under the CCPL, neither party will use the trademark \"Creative Commons\" or any related trademark or logo of Creative Commons without the prior written consent of Creative Commons. Any permitted use will be in compliance with Creative Commons' then-current trademark usage guidelines, as may be published on its website or otherwise made available upon request from time to time.\n\nCreative Commons may be contacted at http://creativecommons.org/."],"licenseIds":["CC-BY-2.0"],"keywords":["attribution 2 0","commons attribution 2 0","attribution 2 0 creative","creative commons attribution 2 0","commons attribution 2 0 creative","attribution 2 0 creative commons"]},{"licenseTexts":["Creative Commons Attribution 2.5 CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE LEGAL SERVICES. DISTRIBUTION OF THIS LICENSE DOES NOT CREATE AN ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS INFORMATION ON AN \"AS-IS\" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES REGARDING THE INFORMATION PROVIDED, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM ITS USE.\n\nLicense\n\nTHE WORK (AS DEFINED BELOW) IS PROVIDED UNDER THE TERMS OF THIS CREATIVE COMMONS PUBLIC LICENSE (\"CCPL\" OR \"LICENSE\"). THE WORK IS PROTECTED BY COPYRIGHT AND/OR OTHER APPLICABLE LAW. ANY USE OF THE WORK OTHER THAN AS AUTHORIZED UNDER THIS LICENSE OR COPYRIGHT LAW IS PROHIBITED.\n\nBY EXERCISING ANY RIGHTS TO THE WORK PROVIDED HERE, YOU ACCEPT AND AGREE TO BE BOUND BY THE TERMS OF THIS LICENSE. THE LICENSOR GRANTS YOU THE RIGHTS CONTAINED HERE IN CONSIDERATION OF YOUR ACCEPTANCE OF SUCH TERMS AND CONDITIONS.\n\n   1. Definitions\n\n      a. \"Collective Work\" means a work, such as a periodical issue, anthology or encyclopedia, in which the Work in its entirety in unmodified form, along with a number of other contributions, constituting separate and independent works in themselves, are assembled into a collective whole. A work that constitutes a Collective Work will not be considered a Derivative Work (as defined below) for the purposes of this License.\n\n      b. \"Derivative Work\" means a work based upon the Work or upon the Work and other pre-existing works, such as a translation, musical arrangement, dramatization, fictionalization, motion picture version, sound recording, art reproduction, abridgment, condensation, or any other form in which the Work may be recast, transformed, or adapted, except that a work that constitutes a Collective Work will not be considered a Derivative Work for the purpose of this License. For the avoidance of doubt, where the Work is a musical composition or sound recording, the synchronization of the Work in timed-relation with a moving image (\"synching\") will be considered a Derivative Work for the purpose of this License.\n\n      c. \"Licensor\" means the individual or entity that offers the Work under the terms of this License.\n\n      d. \"Original Author\" means the individual or entity who created the Work.\n\n      e. \"Work\" means the copyrightable work of authorship offered under the terms of this License.\n\n      f. \"You\" means an individual or entity exercising rights under this License who has not previously violated the terms of this License with respect to the Work, or who has received express permission from the Licensor to exercise rights under this License despite a previous violation.\n\n   2. Fair Use Rights. Nothing in this license is intended to reduce, limit, or restrict any rights arising from fair use, first sale or other limitations on the exclusive rights of the copyright owner under copyright law or other applicable laws.\n\n   3. License Grant. Subject to the terms and conditions of this License, Licensor hereby grants You a worldwide, royalty-free, non-exclusive, perpetual (for the duration of the applicable copyright) license to exercise the rights in the Work as stated below:\n\n      a. to reproduce the Work, to incorporate the Work into one or more Collective Works, and to reproduce the Work as incorporated in the Collective Works;\n\n      b. to create and reproduce Derivative Works;\n\n      c. to distribute copies or phonorecords of, display publicly, perform publicly, and perform publicly by means of a digital audio transmission the Work including as incorporated in Collective Works;\n\n      d. to distribute copies or phonorecords of, display publicly, perform publicly, and perform publicly by means of a digital audio transmission Derivative Works.\n\n      e. For the avoidance of doubt, where the work is a musical composition:\n\n         i. Performance Royalties Under Blanket Licenses. Licensor waives the exclusive right to collect, whether individually or via a performance rights society (e.g. ASCAP, BMI, SESAC), royalties for the public performance or public digital performance (e.g. webcast) of the Work.\n\n         ii. Mechanical Rights and Statutory Royalties. Licensor waives the exclusive right to collect, whether individually or via a music rights agency or designated agent (e.g. Harry Fox Agency), royalties for any phonorecord You create from the Work (\"cover version\") and distribute, subject to the compulsory license created by 17 USC Section 115 of the US Copyright Act (or the equivalent in other jurisdictions).\n\n      f. Webcasting Rights and Statutory Royalties. For the avoidance of doubt, where the Work is a sound recording, Licensor waives the exclusive right to collect, whether individually or via a performance-rights society (e.g. SoundExchange), royalties for the public digital performance (e.g. webcast) of the Work, subject to the compulsory license created by 17 USC Section 114 of the US Copyright Act (or the equivalent in other jurisdictions).\n\n      The above rights may be exercised in all media and formats whether now known or hereafter devised. The above rights include the right to make such modifications as are technically necessary to exercise the rights in other media and formats. All rights not expressly granted by Licensor are hereby reserved.\n\n   4. Restrictions. The license granted in Section 3 above is expressly made subject to and limited by the following restrictions:\n\n      a. You may distribute, publicly display, publicly perform, or publicly digitally perform the Work only under the terms of this License, and You must include a copy of, or the Uniform Resource Identifier for, this License with every copy or phonorecord of the Work You distribute, publicly display, publicly perform, or publicly digitally perform. You may not offer or impose any terms on the Work that alter or restrict the terms of this License or the recipients' exercise of the rights granted hereunder. You may not sublicense the Work. You must keep intact all notices that refer to this License and to the disclaimer of warranties. You may not distribute, publicly display, publicly perform, or publicly digitally perform the Work with any technological measures that control access or use of the Work in a manner inconsistent with the terms of this License Agreement. The above applies to the Work as incorporated in a Collective Work, but this does not require the Collective Work apart from the Work itself to be made subject to the terms of this License. If You create a Collective Work, upon notice from any Licensor You must, to the extent practicable, remove from the Collective Work any credit as required by clause 4(b), as requested. If You create a Derivative Work, upon notice from any Licensor You must, to the extent practicable, remove from the Derivative Work any credit as required by clause 4(b), as requested.\n\n      b. If you distribute, publicly display, publicly perform, or publicly digitally perform the Work or any Derivative Works or Collective Works, You must keep intact all copyright notices for the Work and provide, reasonable to the medium or means You are utilizing: (i) the name of the Original Author (or pseudonym, if applicable) if supplied, and/or (ii) if the Original Author and/or Licensor designate another party or parties (e.g. a sponsor institute, publishing entity, journal) for attribution in Licensor's copyright notice, terms of service or by other reasonable means, the name of such party or parties; the title of the Work if supplied; to the extent reasonably practicable, the Uniform Resource Identifier, if any, that Licensor specifies to be associated with the Work, unless such URI does not refer to the copyright notice or licensing information for the Work; and in the case of a Derivative Work, a credit identifying the use of the Work in the Derivative Work (e.g., \"French translation of the Work by Original Author,\" or \"Screenplay based on original Work by Original Author\"). Such credit may be implemented in any reasonable manner; provided, however, that in the case of a Derivative Work or Collective Work, at a minimum such credit will appear where any other comparable authorship credit appears and in a manner at least as prominent as such other comparable authorship credit.\n\n   5. Representations, Warranties and Disclaimer\n\n   UNLESS OTHERWISE MUTUALLY AGREED TO BY THE PARTIES IN WRITING, LICENSOR OFFERS THE WORK AS-IS AND MAKES NO REPRESENTATIONS OR WARRANTIES OF ANY KIND CONCERNING THE WORK, EXPRESS, IMPLIED, STATUTORY OR OTHERWISE, INCLUDING, WITHOUT LIMITATION, WARRANTIES OF TITLE, MERCHANTIBILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT, OR THE ABSENCE OF LATENT OR OTHER DEFECTS, ACCURACY, OR THE PRESENCE OF ABSENCE OF ERRORS, WHETHER OR NOT DISCOVERABLE. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OF IMPLIED WARRANTIES, SO SUCH EXCLUSION MAY NOT APPLY TO YOU.\n\n   6. Limitation on Liability. EXCEPT TO THE EXTENT REQUIRED BY APPLICABLE LAW, IN NO EVENT WILL LICENSOR BE LIABLE TO YOU ON ANY LEGAL THEORY FOR ANY SPECIAL, INCIDENTAL, CONSEQUENTIAL, PUNITIVE OR EXEMPLARY DAMAGES ARISING OUT OF THIS LICENSE OR THE USE OF THE WORK, EVEN IF LICENSOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\n   7. Termination\n\n      a. This License and the rights granted hereunder will terminate automatically upon any breach by You of the terms of this License. Individuals or entities who have received Derivative Works or Collective Works from You under this License, however, will not have their licenses terminated provided such individuals or entities remain in full compliance with those licenses. Sections 1, 2, 5, 6, 7, and 8 will survive any termination of this License.\n\n      b. Subject to the above terms and conditions, the license granted here is perpetual (for the duration of the applicable copyright in the Work). Notwithstanding the above, Licensor reserves the right to release the Work under different license terms or to stop distributing the Work at any time; provided, however that any such election will not serve to withdraw this License (or any other license that has been, or is required to be, granted under the terms of this License), and this License will continue in full force and effect unless terminated as stated above.\n\n   8. Miscellaneous\n\n      a. Each time You distribute or publicly digitally perform the Work or a Collective Work, the Licensor offers to the recipient a license to the Work on the same terms and conditions as the license granted to You under this License.\n\n      b. Each time You distribute or publicly digitally perform a Derivative Work, Licensor offers to the recipient a license to the original Work on the same terms and conditions as the license granted to You under this License.\n\n      c. If any provision of this License is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this License, and without further action by the parties to this agreement, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.\n\n      d. No term or provision of this License shall be deemed waived and no breach consented to unless such waiver or consent shall be in writing and signed by the party to be charged with such waiver or consent.\n\n      e. This License constitutes the entire agreement between the parties with respect to the Work licensed here. There are no understandings, agreements or representations with respect to the Work not specified here. Licensor shall not be bound by any additional provisions that may appear in any communication from You. This License may not be modified without the mutual written agreement of the Licensor and You.\n\nCreative Commons is not a party to this License, and makes no warranty whatsoever in connection with the Work. Creative Commons will not be liable to You or any party on any legal theory for any damages whatsoever, including without limitation any general, special, incidental or consequential damages arising in connection to this license. Notwithstanding the foregoing two (2) sentences, if Creative Commons has expressly identified itself as the Licensor hereunder, it shall have all rights and obligations of Licensor.\n\nExcept for the limited purpose of indicating to the public that the Work is licensed under the CCPL, neither party will use the trademark \"Creative Commons\" or any related trademark or logo of Creative Commons without the prior written consent of Creative Commons. Any permitted use will be in compliance with Creative Commons' then-current trademark usage guidelines, as may be published on its website or otherwise made available upon request from time to time.\n\nCreative Commons may be contacted at http://creativecommons.org/."],"licenseIds":["CC-BY-2.5"],"keywords":["attribution 2 5","commons attribution 2 5","attribution 2 5 creative","creative commons attribution 2 5","commons attribution 2 5 creative","attribution 2 5 creative commons"]},{"licenseTexts":["Creative Commons Attribution 3.0 Unported CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE LEGAL SERVICES. DISTRIBUTION OF THIS LICENSE DOES NOT CREATE AN ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS INFORMATION ON AN \"AS-IS\" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES REGARDING THE INFORMATION PROVIDED, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM ITS USE.\n\nLicense\n\nTHE WORK (AS DEFINED BELOW) IS PROVIDED UNDER THE TERMS OF THIS CREATIVE COMMONS PUBLIC LICENSE (\"CCPL\" OR \"LICENSE\"). THE WORK IS PROTECTED BY COPYRIGHT AND/OR OTHER APPLICABLE LAW. ANY USE OF THE WORK OTHER THAN AS AUTHORIZED UNDER THIS LICENSE OR COPYRIGHT LAW IS PROHIBITED.\n\nBY EXERCISING ANY RIGHTS TO THE WORK PROVIDED HERE, YOU ACCEPT AND AGREE TO BE BOUND BY THE TERMS OF THIS LICENSE. TO THE EXTENT THIS LICENSE MAY BE CONSIDERED TO BE A CONTRACT, THE LICENSOR GRANTS YOU THE RIGHTS CONTAINED HERE IN CONSIDERATION OF YOUR ACCEPTANCE OF SUCH TERMS AND CONDITIONS.\n\n   1. Definitions\n\n      a. \"Adaptation\" means a work based upon the Work, or upon the Work and other pre-existing works, such as a translation, adaptation, derivative work, arrangement of music or other alterations of a literary or artistic work, or phonogram or performance and includes cinematographic adaptations or any other form in which the Work may be recast, transformed, or adapted including in any form recognizably derived from the original, except that a work that constitutes a Collection will not be considered an Adaptation for the purpose of this License. For the avoidance of doubt, where the Work is a musical work, performance or phonogram, the synchronization of the Work in timed-relation with a moving image (\"synching\") will be considered an Adaptation for the purpose of this License.\n\n      b. \"Collection\" means a collection of literary or artistic works, such as encyclopedias and anthologies, or performances, phonograms or broadcasts, or other works or subject matter other than works listed in Section 1(f) below, which, by reason of the selection and arrangement of their contents, constitute intellectual creations, in which the Work is included in its entirety in unmodified form along with one or more other contributions, each constituting separate and independent works in themselves, which together are assembled into a collective whole. A work that constitutes a Collection will not be considered an Adaptation (as defined above) for the purposes of this License.\n\n      c. \"Distribute\" means to make available to the public the original and copies of the Work or Adaptation, as appropriate, through sale or other transfer of ownership.\n\n      d. \"Licensor\" means the individual, individuals, entity or entities that offer(s) the Work under the terms of this License.\n\n      e. \"Original Author\" means, in the case of a literary or artistic work, the individual, individuals, entity or entities who created the Work or if no individual or entity can be identified, the publisher; and in addition (i) in the case of a performance the actors, singers, musicians, dancers, and other persons who act, sing, deliver, declaim, play in, interpret or otherwise perform literary or artistic works or expressions of folklore; (ii) in the case of a phonogram the producer being the person or legal entity who first fixes the sounds of a performance or other sounds; and, (iii) in the case of broadcasts, the organization that transmits the broadcast.\n\n      f. \"Work\" means the literary and/or artistic work offered under the terms of this License including without limitation any production in the literary, scientific and artistic domain, whatever may be the mode or form of its expression including digital form, such as a book, pamphlet and other writing; a lecture, address, sermon or other work of the same nature; a dramatic or dramatico-musical work; a choreographic work or entertainment in dumb show; a musical composition with or without words; a cinematographic work to which are assimilated works expressed by a process analogous to cinematography; a work of drawing, painting, architecture, sculpture, engraving or lithography; a photographic work to which are assimilated works expressed by a process analogous to photography; a work of applied art; an illustration, map, plan, sketch or three-dimensional work relative to geography, topography, architecture or science; a performance; a broadcast; a phonogram; a compilation of data to the extent it is protected as a copyrightable work; or a work performed by a variety or circus performer to the extent it is not otherwise considered a literary or artistic work.\n\n      g. \"You\" means an individual or entity exercising rights under this License who has not previously violated the terms of this License with respect to the Work, or who has received express permission from the Licensor to exercise rights under this License despite a previous violation.\n\n      h. \"Publicly Perform\" means to perform public recitations of the Work and to communicate to the public those public recitations, by any means or process, including by wire or wireless means or public digital performances; to make available to the public Works in such a way that members of the public may access these Works from a place and at a place individually chosen by them; to perform the Work to the public by any means or process and the communication to the public of the performances of the Work, including by public digital performance; to broadcast and rebroadcast the Work by any means including signs, sounds or images.\n\n      i. \"Reproduce\" means to make copies of the Work by any means including without limitation by sound or visual recordings and the right of fixation and reproducing fixations of the Work, including storage of a protected performance or phonogram in digital form or other electronic medium.\n\n   2. Fair Dealing Rights. Nothing in this License is intended to reduce, limit, or restrict any uses free from copyright or rights arising from limitations or exceptions that are provided for in connection with the copyright protection under copyright law or other applicable laws.\n\n   3. License Grant. Subject to the terms and conditions of this License, Licensor hereby grants You a worldwide, royalty-free, non-exclusive, perpetual (for the duration of the applicable copyright) license to exercise the rights in the Work as stated below:\n\n      a. to Reproduce the Work, to incorporate the Work into one or more Collections, and to Reproduce the Work as incorporated in the Collections;\n\n      b. to create and Reproduce Adaptations provided that any such Adaptation, including any translation in any medium, takes reasonable steps to clearly label, demarcate or otherwise identify that changes were made to the original Work. For example, a translation could be marked \"The original work was translated from English to Spanish,\" or a modification could indicate \"The original work has been modified.\";\n\n      c. to Distribute and Publicly Perform the Work including as incorporated in Collections; and,\n\n      d. to Distribute and Publicly Perform Adaptations.\n\n      e. For the avoidance of doubt:\n\n         i. Non-waivable Compulsory License Schemes. In those jurisdictions in which the right to collect royalties through any statutory or compulsory licensing scheme cannot be waived, the Licensor reserves the exclusive right to collect such royalties for any exercise by You of the rights granted under this License;\n\n         ii. Waivable Compulsory License Schemes. In those jurisdictions in which the right to collect royalties through any statutory or compulsory licensing scheme can be waived, the Licensor waives the exclusive right to collect such royalties for any exercise by You of the rights granted under this License; and,\n\n         iii. Voluntary License Schemes. The Licensor waives the right to collect royalties, whether individually or, in the event that the Licensor is a member of a collecting society that administers voluntary licensing schemes, via that society, from any exercise by You of the rights granted under this License.\n\n   The above rights may be exercised in all media and formats whether now known or hereafter devised. The above rights include the right to make such modifications as are technically necessary to exercise the rights in other media and formats. Subject to Section 8(f), all rights not expressly granted by Licensor are hereby reserved.\n\n   4. Restrictions. The license granted in Section 3 above is expressly made subject to and limited by the following restrictions:\n\n      a. You may Distribute or Publicly Perform the Work only under the terms of this License. You must include a copy of, or the Uniform Resource Identifier (URI) for, this License with every copy of the Work You Distribute or Publicly Perform. You may not offer or impose any terms on the Work that restrict the terms of this License or the ability of the recipient of the Work to exercise the rights granted to that recipient under the terms of the License. You may not sublicense the Work. You must keep intact all notices that refer to this License and to the disclaimer of warranties with every copy of the Work You Distribute or Publicly Perform. When You Distribute or Publicly Perform the Work, You may not impose any effective technological measures on the Work that restrict the ability of a recipient of the Work from You to exercise the rights granted to that recipient under the terms of the License. This Section 4(a) applies to the Work as incorporated in a Collection, but this does not require the Collection apart from the Work itself to be made subject to the terms of this License. If You create a Collection, upon notice from any Licensor You must, to the extent practicable, remove from the Collection any credit as required by Section 4(b), as requested. If You create an Adaptation, upon notice from any Licensor You must, to the extent practicable, remove from the Adaptation any credit as required by Section 4(b), as requested.\n\n      b. If You Distribute, or Publicly Perform the Work or any Adaptations or Collections, You must, unless a request has been made pursuant to Section 4(a), keep intact all copyright notices for the Work and provide, reasonable to the medium or means You are utilizing: (i) the name of the Original Author (or pseudonym, if applicable) if supplied, and/or if the Original Author and/or Licensor designate another party or parties (e.g., a sponsor institute, publishing entity, journal) for attribution (\"Attribution Parties\") in Licensor's copyright notice, terms of service or by other reasonable means, the name of such party or parties; (ii) the title of the Work if supplied; (iii) to the extent reasonably practicable, the URI, if any, that Licensor specifies to be associated with the Work, unless such URI does not refer to the copyright notice or licensing information for the Work; and (iv), consistent with Section 3(b), in the case of an Adaptation, a credit identifying the use of the Work in the Adaptation (e.g., \"French translation of the Work by Original Author,\" or \"Screenplay based on original Work by Original Author\"). The credit required by this Section 4 (b) may be implemented in any reasonable manner; provided, however, that in the case of a Adaptation or Collection, at a minimum such credit will appear, if a credit for all contributing authors of the Adaptation or Collection appears, then as part of these credits and in a manner at least as prominent as the credits for the other contributing authors. For the avoidance of doubt, You may only use the credit required by this Section for the purpose of attribution in the manner set out above and, by exercising Your rights under this License, You may not implicitly or explicitly assert or imply any connection with, sponsorship or endorsement by the Original Author, Licensor and/or Attribution Parties, as appropriate, of You or Your use of the Work, without the separate, express prior written permission of the Original Author, Licensor and/or Attribution Parties.\n\n      c. Except as otherwise agreed in writing by the Licensor or as may be otherwise permitted by applicable law, if You Reproduce, Distribute or Publicly Perform the Work either by itself or as part of any Adaptations or Collections, You must not distort, mutilate, modify or take other derogatory action in relation to the Work which would be prejudicial to the Original Author's honor or reputation. Licensor agrees that in those jurisdictions (e.g. Japan), in which any exercise of the right granted in Section 3(b) of this License (the right to make Adaptations) would be deemed to be a distortion, mutilation, modification or other derogatory action prejudicial to the Original Author's honor and reputation, the Licensor will waive or not assert, as appropriate, this Section, to the fullest extent permitted by the applicable national law, to enable You to reasonably exercise Your right under Section 3(b) of this License (right to make Adaptations) but not otherwise.\n\n   5. Representations, Warranties and Disclaimer\n\n   UNLESS OTHERWISE MUTUALLY AGREED TO BY THE PARTIES IN WRITING, LICENSOR OFFERS THE WORK AS-IS AND MAKES NO REPRESENTATIONS OR WARRANTIES OF ANY KIND CONCERNING THE WORK, EXPRESS, IMPLIED, STATUTORY OR OTHERWISE, INCLUDING, WITHOUT LIMITATION, WARRANTIES OF TITLE, MERCHANTIBILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT, OR THE ABSENCE OF LATENT OR OTHER DEFECTS, ACCURACY, OR THE PRESENCE OF ABSENCE OF ERRORS, WHETHER OR NOT DISCOVERABLE. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OF IMPLIED WARRANTIES, SO SUCH EXCLUSION MAY NOT APPLY TO YOU.\n\n   6. Limitation on Liability. EXCEPT TO THE EXTENT REQUIRED BY APPLICABLE LAW, IN NO EVENT WILL LICENSOR BE LIABLE TO YOU ON ANY LEGAL THEORY FOR ANY SPECIAL, INCIDENTAL, CONSEQUENTIAL, PUNITIVE OR EXEMPLARY DAMAGES ARISING OUT OF THIS LICENSE OR THE USE OF THE WORK, EVEN IF LICENSOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\n   7. Termination\n\n      a. This License and the rights granted hereunder will terminate automatically upon any breach by You of the terms of this License. Individuals or entities who have received Adaptations or Collections from You under this License, however, will not have their licenses terminated provided such individuals or entities remain in full compliance with those licenses. Sections 1, 2, 5, 6, 7, and 8 will survive any termination of this License.\n\n      b. Subject to the above terms and conditions, the license granted here is perpetual (for the duration of the applicable copyright in the Work). Notwithstanding the above, Licensor reserves the right to release the Work under different license terms or to stop distributing the Work at any time; provided, however that any such election will not serve to withdraw this License (or any other license that has been, or is required to be, granted under the terms of this License), and this License will continue in full force and effect unless terminated as stated above.\n\n   8. Miscellaneous\n\n      a. Each time You Distribute or Publicly Perform the Work or a Collection, the Licensor offers to the recipient a license to the Work on the same terms and conditions as the license granted to You under this License.\n\n      b. Each time You Distribute or Publicly Perform an Adaptation, Licensor offers to the recipient a license to the original Work on the same terms and conditions as the license granted to You under this License.\n\n      c. If any provision of this License is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this License, and without further action by the parties to this agreement, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.\n\n      d. No term or provision of this License shall be deemed waived and no breach consented to unless such waiver or consent shall be in writing and signed by the party to be charged with such waiver or consent. This License constitutes the entire agreement between the parties with respect to the Work licensed here. There are no understandings, agreements or representations with respect to the Work not specified here. Licensor shall not be bound by any additional provisions that may appear in any communication from You.\n\n      e. This License may not be modified without the mutual written agreement of the Licensor and You.\n\n      f. The rights granted under, and the subject matter referenced, in this License were drafted utilizing the terminology of the Berne Convention for the Protection of Literary and Artistic Works (as amended on September 28, 1979), the Rome Convention of 1961, the WIPO Copyright Treaty of 1996, the WIPO Performances and Phonograms Treaty of 1996 and the Universal Copyright Convention (as revised on July 24, 1971). These rights and subject matter take effect in the relevant jurisdiction in which the License terms are sought to be enforced according to the corresponding provisions of the implementation of those treaty provisions in the applicable national law. If the standard suite of rights granted under applicable copyright law includes additional rights not granted under this License, such additional rights are deemed to be included in the License; this License is not intended to restrict the license of any rights under applicable law.\n\nCreative Commons Notice\n\nCreative Commons is not a party to this License, and makes no warranty whatsoever in connection with the Work. Creative Commons will not be liable to You or any party on any legal theory for any damages whatsoever, including without limitation any general, special, incidental or consequential damages arising in connection to this license. Notwithstanding the foregoing two (2) sentences, if Creative Commons has expressly identified itself as the Licensor hereunder, it shall have all rights and obligations of Licensor.\n\nExcept for the limited purpose of indicating to the public that the Work is licensed under the CCPL, Creative Commons does not authorize the use by either party of the trademark \"Creative Commons\" or any related trademark or logo of Creative Commons without the prior written consent of Creative Commons. Any permitted use will be in compliance with Creative Commons' then-current trademark usage guidelines, as may be published on its website or otherwise made available upon request from time to time. For the avoidance of doubt, this trademark restriction does not form part of this License.\n\nCreative Commons may be contacted at http://creativecommons.org/."],"licenseIds":["CC-BY-3.0"],"keywords":["commons attribution 3","attribution 3 0","or consent this","from you e","you e this","creative commons attribution 3","commons attribution 3 0","attribution 3 0 unported","waiver or consent this","or consent this license","consent this license constitutes","communication from you e","from you e this","you e this license","e this license may","creative commons attribution 3 0","commons attribution 3 0 unported","attribution 3 0 unported creative","such waiver or consent this","waiver or consent this license","or consent this license constitutes","consent this license constitutes the","any communication from you e","communication from you e this","from you e this license","you e this license may","e this license may not"]},{"licenseTexts":["Creative Commons Attribution 4.0 International Creative Commons Corporation (\"Creative Commons\") is not a law firm and does not provide legal services or legal advice. Distribution of Creative Commons public licenses does not create a lawyer-client or other relationship. Creative Commons makes its licenses and related information available on an \"as-is\" basis. Creative Commons gives no warranties regarding its licenses, any material licensed under their terms and conditions, or any related information. Creative Commons disclaims all liability for damages resulting from their use to the fullest extent possible.\n\nUsing Creative Commons Public Licenses\n\nCreative Commons public licenses provide a standard set of terms and conditions that creators and other rights holders may use to share original works of authorship and other material subject to copyright and certain other rights specified in the public license below. The following considerations are for informational purposes only, are not exhaustive, and do not form part of our licenses.\n\nConsiderations for licensors: Our public licenses are intended for use by those authorized to give the public permission to use material in ways otherwise restricted by copyright and certain other rights. Our licenses are irrevocable. Licensors should read and understand the terms and conditions of the license they choose before applying it. Licensors should also secure all rights necessary before applying our licenses so that the public can reuse the material as expected. Licensors should clearly mark any material not subject to the license. This includes other CC-licensed material, or material used under an exception or limitation to copyright. More considerations for licensors : wiki.creativecommons.org/Considerations_for_licensors\n\nConsiderations for the public: By using one of our public licenses, a licensor grants the public permission to use the licensed material under specified terms and conditions. If the licensor's permission is not necessary for any reason–for example, because of any applicable exception or limitation to copyright–then that use is not regulated by the license. Our licenses grant only permissions under copyright and certain other rights that a licensor has authority to grant. Use of the licensed material may still be restricted for other reasons, including because others have copyright or other rights in the material. A licensor may make special requests, such as asking that all changes be marked or described. Although not required by our licenses, you are encouraged to respect those requests where reasonable. More considerations for the public : wiki.creativecommons.org/Considerations_for_licensees Creative Commons Attribution 4.0 International Public License\n\nBy exercising the Licensed Rights (defined below), You accept and agree to be bound by the terms and conditions of this Creative Commons Attribution 4.0 International Public License (\"Public License\"). To the extent this Public License may be interpreted as a contract, You are granted the Licensed Rights in consideration of Your acceptance of these terms and conditions, and the Licensor grants You such rights in consideration of benefits the Licensor receives from making the Licensed Material available under these terms and conditions.\n\nSection 1 – Definitions.\n\n   a. Adapted Material means material subject to Copyright and Similar Rights that is derived from or based upon the Licensed Material and in which the Licensed Material is translated, altered, arranged, transformed, or otherwise modified in a manner requiring permission under the Copyright and Similar Rights held by the Licensor. For purposes of this Public License, where the Licensed Material is a musical work, performance, or sound recording, Adapted Material is always produced where the Licensed Material is synched in timed relation with a moving image.\n\n   b. Adapter's License means the license You apply to Your Copyright and Similar Rights in Your contributions to Adapted Material in accordance with the terms and conditions of this Public License.\n\n   c. Copyright and Similar Rights means copyright and/or similar rights closely related to copyright including, without limitation, performance, broadcast, sound recording, and Sui Generis Database Rights, without regard to how the rights are labeled or categorized. For purposes of this Public License, the rights specified in Section 2(b)(1)-(2) are not Copyright and Similar Rights.\n\n   d. Effective Technological Measures means those measures that, in the absence of proper authority, may not be circumvented under laws fulfilling obligations under Article 11 of the WIPO Copyright Treaty adopted on December 20, 1996, and/or similar international agreements.\n\n   e. Exceptions and Limitations means fair use, fair dealing, and/or any other exception or limitation to Copyright and Similar Rights that applies to Your use of the Licensed Material.\n\n   f. Licensed Material means the artistic or literary work, database, or other material to which the Licensor applied this Public License.\n\n   g. Licensed Rights means the rights granted to You subject to the terms and conditions of this Public License, which are limited to all Copyright and Similar Rights that apply to Your use of the Licensed Material and that the Licensor has authority to license.\n\n   h. Licensor means the individual(s) or entity(ies) granting rights under this Public License.\n\n   i. Share means to provide material to the public by any means or process that requires permission under the Licensed Rights, such as reproduction, public display, public performance, distribution, dissemination, communication, or importation, and to make material available to the public including in ways that members of the public may access the material from a place and at a time individually chosen by them.\n\n   j. Sui Generis Database Rights means rights other than copyright resulting from Directive 96/9/EC of the European Parliament and of the Council of 11 March 1996 on the legal protection of databases, as amended and/or succeeded, as well as other essentially equivalent rights anywhere in the world.\n\n   k. You means the individual or entity exercising the Licensed Rights under this Public License. Your has a corresponding meaning.\n\nSection 2 – Scope.\n\n   a. License grant.\n\n      1. Subject to the terms and conditions of this Public License, the Licensor hereby grants You a worldwide, royalty-free, non-sublicensable, non-exclusive, irrevocable license to exercise the Licensed Rights in the Licensed Material to:\n\n         A. reproduce and Share the Licensed Material, in whole or in part; and\n\n         B. produce, reproduce, and Share Adapted Material.\n\n      2. Exceptions and Limitations. For the avoidance of doubt, where Exceptions and Limitations apply to Your use, this Public License does not apply, and You do not need to comply with its terms and conditions.\n\n      3. Term. The term of this Public License is specified in Section 6(a).\n\n      4. Media and formats; technical modifications allowed. The Licensor authorizes You to exercise the Licensed Rights in all media and formats whether now known or hereafter created, and to make technical modifications necessary to do so. The Licensor waives and/or agrees not to assert any right or authority to forbid You from making technical modifications necessary to exercise the Licensed Rights, including technical modifications necessary to circumvent Effective Technological Measures. For purposes of this Public License, simply making modifications authorized by this Section 2(a)(4) never produces Adapted Material.\n\n      5. Downstream recipients.\n\n         A. Offer from the Licensor – Licensed Material. Every recipient of the Licensed Material automatically receives an offer from the Licensor to exercise the Licensed Rights under the terms and conditions of this Public License.\n\n         B. No downstream restrictions. You may not offer or impose any additional or different terms or conditions on, or apply any Effective Technological Measures to, the Licensed Material if doing so restricts exercise of the Licensed Rights by any recipient of the Licensed Material.\n\n      6. No endorsement. Nothing in this Public License constitutes or may be construed as permission to assert or imply that You are, or that Your use of the Licensed Material is, connected with, or sponsored, endorsed, or granted official status by, the Licensor or others designated to receive attribution as provided in Section 3(a)(1)(A)(i).\n\n   b. Other rights.\n\n      1. Moral rights, such as the right of integrity, are not licensed under this Public License, nor are publicity, privacy, and/or other similar personality rights; however, to the extent possible, the Licensor waives and/or agrees not to assert any such rights held by the Licensor to the limited extent necessary to allow You to exercise the Licensed Rights, but not otherwise.\n\n      2. Patent and trademark rights are not licensed under this Public License.\n\n      3. To the extent possible, the Licensor waives any right to collect royalties from You for the exercise of the Licensed Rights, whether directly or through a collecting society under any voluntary or waivable statutory or compulsory licensing scheme. In all other cases the Licensor expressly reserves any right to collect such royalties.\n\nSection 3 – License Conditions.\n\nYour exercise of the Licensed Rights is expressly made subject to the following conditions.\n\n   a. Attribution.\n\n      1. If You Share the Licensed Material (including in modified form), You must:\n\n         A. retain the following if it is supplied by the Licensor with the Licensed Material:\n\n            i. identification of the creator(s) of the Licensed Material and any others designated to receive attribution, in any reasonable manner requested by the Licensor (including by pseudonym if designated);\n\n            ii. a copyright notice;\n\n            iii. a notice that refers to this Public License;\n\n            iv. a notice that refers to the disclaimer of warranties;\n\n            v. a URI or hyperlink to the Licensed Material to the extent reasonably practicable;\n\n         B. indicate if You modified the Licensed Material and retain an indication of any previous modifications; and\n\n         C. indicate the Licensed Material is licensed under this Public License, and include the text of, or the URI or hyperlink to, this Public License.\n\n      2. You may satisfy the conditions in Section 3(a)(1) in any reasonable manner based on the medium, means, and context in which You Share the Licensed Material. For example, it may be reasonable to satisfy the conditions by providing a URI or hyperlink to a resource that includes the required information.\n\n      3. If requested by the Licensor, You must remove any of the information required by Section 3(a)(1)(A) to the extent reasonably practicable.\n\n      4. If You Share Adapted Material You produce, the Adapter's License You apply must not prevent recipients of the Adapted Material from complying with this Public License.\n\nSection 4 – Sui Generis Database Rights.\n\nWhere the Licensed Rights include Sui Generis Database Rights that apply to Your use of the Licensed Material:\n\n   a. for the avoidance of doubt, Section 2(a)(1) grants You the right to extract, reuse, reproduce, and Share all or a substantial portion of the contents of the database;\n\n   b. if You include all or a substantial portion of the database contents in a database in which You have Sui Generis Database Rights, then the database in which You have Sui Generis Database Rights (but not its individual contents) is Adapted Material; and\n\n   c. You must comply with the conditions in Section 3(a) if You Share all or a substantial portion of the contents of the database.\n\nFor the avoidance of doubt, this Section 4 supplements and does not replace Your obligations under this Public License where the Licensed Rights include other Copyright and Similar Rights.\n\nSection 5 – Disclaimer of Warranties and Limitation of Liability.\n\n   a. Unless otherwise separately undertaken by the Licensor, to the extent possible, the Licensor offers the Licensed Material as-is and as-available, and makes no representations or warranties of any kind concerning the Licensed Material, whether express, implied, statutory, or other. This includes, without limitation, warranties of title, merchantability, fitness for a particular purpose, non-infringement, absence of latent or other defects, accuracy, or the presence or absence of errors, whether or not known or discoverable. Where disclaimers of warranties are not allowed in full or in part, this disclaimer may not apply to You.\n\n   b. To the extent possible, in no event will the Licensor be liable to You on any legal theory (including, without limitation, negligence) or otherwise for any direct, special, indirect, incidental, consequential, punitive, exemplary, or other losses, costs, expenses, or damages arising out of this Public License or use of the Licensed Material, even if the Licensor has been advised of the possibility of such losses, costs, expenses, or damages. Where a limitation of liability is not allowed in full or in part, this limitation may not apply to You.\n\n   c. The disclaimer of warranties and limitation of liability provided above shall be interpreted in a manner that, to the extent possible, most closely approximates an absolute disclaimer and waiver of all liability.\n\nSection 6 – Term and Termination.\n\n   a. This Public License applies for the term of the Copyright and Similar Rights licensed here. However, if You fail to comply with this Public License, then Your rights under this Public License terminate automatically.\n\n   b. Where Your right to use the Licensed Material has terminated under Section 6(a), it reinstates:\n\n      1. automatically as of the date the violation is cured, provided it is cured within 30 days of Your discovery of the violation; or\n\n      2. upon express reinstatement by the Licensor.\n\n   c. For the avoidance of doubt, this Section 6(b) does not affect any right the Licensor may have to seek remedies for Your violations of this Public License.\n\n   d. For the avoidance of doubt, the Licensor may also offer the Licensed Material under separate terms or conditions or stop distributing the Licensed Material at any time; however, doing so will not terminate this Public License.\n\n   e. Sections 1, 5, 6, 7, and 8 survive termination of this Public License.\n\nSection 7 – Other Terms and Conditions.\n\n   a. The Licensor shall not be bound by any additional or different terms or conditions communicated by You unless expressly agreed.\n\n   b. Any arrangements, understandings, or agreements regarding the Licensed Material not stated herein are separate from and independent of the terms and conditions of this Public License.\n\nSection 8 – Interpretation.\n\n   a. For the avoidance of doubt, this Public License does not, and shall not be interpreted to, reduce, limit, restrict, or impose conditions on any use of the Licensed Material that could lawfully be made without permission under this Public License.\n\n   b. To the extent possible, if any provision of this Public License is deemed unenforceable, it shall be automatically reformed to the minimum extent necessary to make it enforceable. If the provision cannot be reformed, it shall be severed from this Public License without affecting the enforceability of the remaining terms and conditions.\n\n   c. No term or condition of this Public License will be waived and no failure to comply consented to unless expressly agreed to by the Licensor.\n\n   d. Nothing in this Public License constitutes or may be interpreted as a limitation upon, or waiver of, any privileges and immunities that apply to the Licensor or You, including from the legal processes of any jurisdiction or authority.\n\nCreative Commons is not a party to its public licenses. Notwithstanding, Creative Commons may elect to apply one of its public licenses to material it publishes and in those instances will be considered the \"Licensor.\" The text of the Creative Commons public licenses is dedicated to the public domain under the CC0 Public Domain Dedication. Except for the limited purpose of indicating that material is shared under a Creative Commons public license or as otherwise permitted by the Creative Commons policies published at creativecommons.org/policies, Creative Commons does not authorize the use of the trademark \"Creative Commons\" or any other trademark or logo of Creative Commons without its prior written consent including, without limitation, in connection with any unauthorized modifications to any of its public licenses or any other arrangements, understandings, or agreements concerning use of licensed material. For the avoidance of doubt, this paragraph does not form part of the public licenses.\n\nCreative Commons may be contacted at creativecommons.org."],"licenseIds":["CC-BY-4.0"],"keywords":["license i share","public license i share","license i share means","attribution 4 0 international creative","licensees creative commons attribution 4","this creative commons attribution 4","this public license i share","public license i share means","license i share means to"]},{"licenseTexts":["Creative Commons Attribution-NonCommercial 1.0 CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE LEGAL SERVICES. DISTRIBUTION OF THIS DRAFT LICENSE DOES NOT CREATE AN ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS INFORMATION ON AN \"AS-IS\" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES REGARDING THE INFORMATION PROVIDED, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM ITS USE.\n\nLicense\n\nTHE WORK (AS DEFINED BELOW) IS PROVIDED UNDER THE TERMS OF THIS CREATIVE COMMONS PUBLIC LICENSE (\"CCPL\" OR \"LICENSE\"). THE WORK IS PROTECTED BY COPYRIGHT AND/OR OTHER APPLICABLE LAW. ANY USE OF THE WORK OTHER THAN AS AUTHORIZED UNDER THIS LICENSE IS PROHIBITED.\n\nBY EXERCISING ANY RIGHTS TO THE WORK PROVIDED HERE, YOU ACCEPT AND AGREE TO BE BOUND BY THE TERMS OF THIS LICENSE. THE LICENSOR GRANTS YOU THE RIGHTS CONTAINED HERE IN CONSIDERATION OF YOUR ACCEPTANCE OF SUCH TERMS AND CONDITIONS.\n\n   1. Definitions\n\n      a. \"Collective Work\" means a work, such as a periodical issue, anthology or encyclopedia, in which the Work in its entirety in unmodified form, along with a number of other contributions, constituting separate and independent works in themselves, are assembled into a collective whole. A work that constitutes a Collective Work will not be considered a Derivative Work (as defined below) for the purposes of this License.\n\n      b. \"Derivative Work\" means a work based upon the Work or upon the Work and other pre-existing works, such as a translation, musical arrangement, dramatization, fictionalization, motion picture version, sound recording, art reproduction, abridgment, condensation, or any other form in which the Work may be recast, transformed, or adapted, except that a work that constitutes a Collective Work will not be considered a Derivative Work for the purpose of this License.\n\n      c. \"Licensor\" means the individual or entity that offers the Work under the terms of this License.\n\n      d. \"Original Author\" means the individual or entity who created the Work.\n\n      e. \"Work\" means the copyrightable work of authorship offered under the terms of this License.\n\n      f. \"You\" means an individual or entity exercising rights under this License who has not previously violated the terms of this License with respect to the Work, or who has received express permission from the Licensor to exercise rights under this License despite a previous violation.\n\n   2. Fair Use Rights. Nothing in this license is intended to reduce, limit, or restrict any rights arising from fair use, first sale or other limitations on the exclusive rights of the copyright owner under copyright law or other applicable laws.\n\n   3. License Grant. Subject to the terms and conditions of this License, Licensor hereby grants You a worldwide, royalty-free, non-exclusive, perpetual (for the duration of the applicable copyright) license to exercise the rights in the Work as stated below:\n\n      a. to reproduce the Work, to incorporate the Work into one or more Collective Works, and to reproduce the Work as incorporated in the Collective Works;\n\n      b. to create and reproduce Derivative Works;\n\n      c. to distribute copies or phonorecords of, display publicly, perform publicly, and perform publicly by means of a digital audio transmission the Work including as incorporated in Collective Works;\n\n      d. to distribute copies or phonorecords of, display publicly, perform publicly, and perform publicly by means of a digital audio transmission Derivative Works;\n\n   The above rights may be exercised in all media and formats whether now known or hereafter devised. The above rights include the right to make such modifications as are technically necessary to exercise the rights in other media and formats. All rights not expressly granted by Licensor are hereby reserved.\n\n   4. Restrictions. The license granted in Section 3 above is expressly made subject to and limited by the following restrictions:\n\n      a. You may distribute, publicly display, publicly perform, or publicly digitally perform the Work only under the terms of this License, and You must include a copy of, or the Uniform Resource Identifier for, this License with every copy or phonorecord of the Work You distribute, publicly display, publicly perform, or publicly digitally perform. You may not offer or impose any terms on the Work that alter or restrict the terms of this License or the recipients' exercise of the rights granted hereunder. You may not sublicense the Work. You must keep intact all notices that refer to this License and to the disclaimer of warranties. You may not distribute, publicly display, publicly perform, or publicly digitally perform the Work with any technological measures that control access or use of the Work in a manner inconsistent with the terms of this License Agreement. The above applies to the Work as incorporated in a Collective Work, but this does not require the Collective Work apart from the Work itself to be made subject to the terms of this License. If You create a Collective Work, upon notice from any Licensor You must, to the extent practicable, remove from the Collective Work any reference to such Licensor or the Original Author, as requested. If You create a Derivative Work, upon notice from any Licensor You must, to the extent practicable, remove from the Derivative Work any reference to such Licensor or the Original Author, as requested.\n\n      b. You may not exercise any of the rights granted to You in Section 3 above in any manner that is primarily intended for or directed toward commercial advantage or private monetary compensation. The exchange of the Work for other copyrighted works by means of digital file-sharing or otherwise shall not be considered to be intended for or directed toward commercial advantage or private monetary compensation, provided there is no payment of any monetary compensation in connection with the exchange of copyrighted works.\n\n      c. If you distribute, publicly display, publicly perform, or publicly digitally perform the Work or any Derivative Works or Collective Works, You must keep intact all copyright notices for the Work and give the Original Author credit reasonable to the medium or means You are utilizing by conveying the name (or pseudonym if applicable) of the Original Author if supplied; the title of the Work if supplied; in the case of a Derivative Work, a credit identifying the use of the Work in the Derivative Work (e.g., \"French translation of the Work by Original Author,\" or \"Screenplay based on original Work by Original Author\"). Such credit may be implemented in any reasonable manner; provided, however, that in the case of a Derivative Work or Collective Work, at a minimum such credit will appear where any other comparable authorship credit appears and in a manner at least as prominent as such other comparable authorship credit.\n\n   5. Representations, Warranties and Disclaimer\n\n   By offering the Work for public release under this License, Licensor represents and warrants that, to the best of Licensor's knowledge after reasonable inquiry: Licensor has secured all rights in the Work necessary to grant the license rights hereunder and to permit the lawful exercise of the rights granted hereunder without You having any obligation to pay any royalties, compulsory license fees, residuals or any other payments; The Work does not infringe the copyright, trademark, publicity rights, common law rights or any other right of any third party or constitute defamation, invasion of privacy or other tortious injury to any third party. EXCEPT AS EXPRESSLY STATED IN THIS LICENSE OR OTHERWISE AGREED IN WRITING OR REQUIRED BY APPLICABLE LAW, THE WORK IS LICENSED ON AN \"AS IS\" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES REGARDING THE CONTENTS OR ACCURACY OF THE WORK.\n\n   6. Limitation on Liability. EXCEPT TO THE EXTENT REQUIRED BY APPLICABLE LAW, AND EXCEPT FOR DAMAGES ARISING FROM LIABILITY TO A THIRD PARTY RESULTING FROM BREACH OF THE WARRANTIES IN SECTION 5, IN NO EVENT WILL LICENSOR BE LIABLE TO YOU ON ANY LEGAL THEORY FOR ANY SPECIAL, INCIDENTAL, CONSEQUENTIAL, PUNITIVE OR EXEMPLARY DAMAGES ARISING OUT OF THIS LICENSE OR THE USE OF THE WORK, EVEN IF LICENSOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\n   7. Termination\n\n      a. This License and the rights granted hereunder will terminate automatically upon any breach by You of the terms of this License. Individuals or entities who have received Derivative Works or Collective Works from You under this License, however, will not have their licenses terminated provided such individuals or entities remain in full compliance with those licenses. Sections 1, 2, 5, 6, 7, and 8 will survive any termination of this License.\n\n      b. Subject to the above terms and conditions, the license granted here is perpetual (for the duration of the applicable copyright in the Work). Notwithstanding the above, Licensor reserves the right to release the Work under different license terms or to stop distributing the Work at any time; provided, however that any such election will not serve to withdraw this License (or any other license that has been, or is required to be, granted under the terms of this License), and this License will continue in full force and effect unless terminated as stated above.\n\n   8. Miscellaneous\n\n      a. Each time You distribute or publicly digitally perform the Work or a Collective Work, the Licensor offers to the recipient a license to the Work on the same terms and conditions as the license granted to You under this License.\n\n      b. Each time You distribute or publicly digitally perform a Derivative Work, Licensor offers to the recipient a license to the original Work on the same terms and conditions as the license granted to You under this License.\n\n      c. If any provision of this License is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this License, and without further action by the parties to this agreement, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.\n\n      d. No term or provision of this License shall be deemed waived and no breach consented to unless such waiver or consent shall be in writing and signed by the party to be charged with such waiver or consent.\n\n      e. This License constitutes the entire agreement between the parties with respect to the Work licensed here. There are no understandings, agreements or representations with respect to the Work not specified here. Licensor shall not be bound by any additional provisions that may appear in any communication from You. This License may not be modified without the mutual written agreement of the Licensor and You.\n\nCreative Commons is not a party to this License, and makes no warranty whatsoever in connection with the Work. Creative Commons will not be liable to You or any party on any legal theory for any damages whatsoever, including without limitation any general, special, incidental or consequential damages arising in connection to this license. Notwithstanding the foregoing two (2) sentences, if Creative Commons has expressly identified itself as the Licensor hereunder, it shall have all rights and obligations of Licensor.\n\nExcept for the limited purpose of indicating to the public that the Work is licensed under the CCPL, neither party will use the trademark \"Creative Commons\" or any related trademark or logo of Creative Commons without the prior written consent of Creative Commons. Any permitted use will be in compliance with Creative Commons' then-current trademark usage guidelines, as may be published on its website or otherwise made available upon request from time to time.\n\nCreative Commons may be contacted at http://creativecommons.org/."],"licenseIds":["CC-BY-NC-1.0"],"keywords":["attribution noncommercial 1","and disclaimer by","disclaimer by offering","reasonable inquiry licensor","inquiry licensor has","other payments the","payments the work","party except as","commons attribution noncommercial 1","attribution noncommercial 1 0","warranties and disclaimer by","and disclaimer by offering","disclaimer by offering the","after reasonable inquiry licensor","reasonable inquiry licensor has","inquiry licensor has secured","any other payments the","other payments the work","payments the work does","third party except as","party except as expressly","creative commons attribution noncommercial 1","commons attribution noncommercial 1 0","attribution noncommercial 1 0 creative","representations warranties and disclaimer by","warranties and disclaimer by offering","and disclaimer by offering the","disclaimer by offering the work","knowledge after reasonable inquiry licensor","after reasonable inquiry licensor has","reasonable inquiry licensor has secured","inquiry licensor has secured all","or any other payments the","any other payments the work","other payments the work does","payments the work does not","to any third party except","any third party except as","third party except as expressly","party except as expressly stated"]},{"licenseTexts":["Creative Commons Attribution-NonCommercial 2.0 CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE LEGAL SERVICES. DISTRIBUTION OF THIS LICENSE DOES NOT CREATE AN ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS INFORMATION ON AN \"AS-IS\" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES REGARDING THE INFORMATION PROVIDED, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM ITS USE.\n\nLicense\n\nTHE WORK (AS DEFINED BELOW) IS PROVIDED UNDER THE TERMS OF THIS CREATIVE COMMONS PUBLIC LICENSE (\"CCPL\" OR \"LICENSE\"). THE WORK IS PROTECTED BY COPYRIGHT AND/OR OTHER APPLICABLE LAW. ANY USE OF THE WORK OTHER THAN AS AUTHORIZED UNDER THIS LICENSE OR COPYRIGHT LAW IS PROHIBITED.\n\nBY EXERCISING ANY RIGHTS TO THE WORK PROVIDED HERE, YOU ACCEPT AND AGREE TO BE BOUND BY THE TERMS OF THIS LICENSE. THE LICENSOR GRANTS YOU THE RIGHTS CONTAINED HERE IN CONSIDERATION OF YOUR ACCEPTANCE OF SUCH TERMS AND CONDITIONS.\n\n   1. Definitions\n\n      a. \"Collective Work\" means a work, such as a periodical issue, anthology or encyclopedia, in which the Work in its entirety in unmodified form, along with a number of other contributions, constituting separate and independent works in themselves, are assembled into a collective whole. A work that constitutes a Collective Work will not be considered a Derivative Work (as defined below) for the purposes of this License.\n\n      b. \"Derivative Work\" means a work based upon the Work or upon the Work and other pre-existing works, such as a translation, musical arrangement, dramatization, fictionalization, motion picture version, sound recording, art reproduction, abridgment, condensation, or any other form in which the Work may be recast, transformed, or adapted, except that a work that constitutes a Collective Work will not be considered a Derivative Work for the purpose of this License. For the avoidance of doubt, where the Work is a musical composition or sound recording, the synchronization of the Work in timed-relation with a moving image (\"synching\") will be considered a Derivative Work for the purpose of this License.\n\n      c. \"Licensor\" means the individual or entity that offers the Work under the terms of this License.\n\n      d. \"Original Author\" means the individual or entity who created the Work.\n\n      e. \"Work\" means the copyrightable work of authorship offered under the terms of this License.\n\n      f. \"You\" means an individual or entity exercising rights under this License who has not previously violated the terms of this License with respect to the Work, or who has received express permission from the Licensor to exercise rights under this License despite a previous violation.\n\n   2. Fair Use Rights. Nothing in this license is intended to reduce, limit, or restrict any rights arising from fair use, first sale or other limitations on the exclusive rights of the copyright owner under copyright law or other applicable laws.\n\n   3. License Grant. Subject to the terms and conditions of this License, Licensor hereby grants You a worldwide, royalty-free, non-exclusive, perpetual (for the duration of the applicable copyright) license to exercise the rights in the Work as stated below:\n\n      a. to reproduce the Work, to incorporate the Work into one or more Collective Works, and to reproduce the Work as incorporated in the Collective Works;\n\n      b. to create and reproduce Derivative Works;\n\n      c. to distribute copies or phonorecords of, display publicly, perform publicly, and perform publicly by means of a digital audio transmission the Work including as incorporated in Collective Works;\n\n      d. to distribute copies or phonorecords of, display publicly, perform publicly, and perform publicly by means of a digital audio transmission Derivative Works;\n\n      The above rights may be exercised in all media and formats whether now known or hereafter devised. The above rights include the right to make such modifications as are technically necessary to exercise the rights in other media and formats. All rights not expressly granted by Licensor are hereby reserved, including but not limited to the rights set forth in Sections 4(d) and 4(e).\n\n   4. Restrictions.The license granted in Section 3 above is expressly made subject to and limited by the following restrictions:\n\n      a. You may distribute, publicly display, publicly perform, or publicly digitally perform the Work only under the terms of this License, and You must include a copy of, or the Uniform Resource Identifier for, this License with every copy or phonorecord of the Work You distribute, publicly display, publicly perform, or publicly digitally perform. You may not offer or impose any terms on the Work that alter or restrict the terms of this License or the recipients' exercise of the rights granted hereunder. You may not sublicense the Work. You must keep intact all notices that refer to this License and to the disclaimer of warranties. You may not distribute, publicly display, publicly perform, or publicly digitally perform the Work with any technological measures that control access or use of the Work in a manner inconsistent with the terms of this License Agreement. The above applies to the Work as incorporated in a Collective Work, but this does not require the Collective Work apart from the Work itself to be made subject to the terms of this License. If You create a Collective Work, upon notice from any Licensor You must, to the extent practicable, remove from the Collective Work any reference to such Licensor or the Original Author, as requested. If You create a Derivative Work, upon notice from any Licensor You must, to the extent practicable, remove from the Derivative Work any reference to such Licensor or the Original Author, as requested.\n\n      b. You may not exercise any of the rights granted to You in Section 3 above in any manner that is primarily intended for or directed toward commercial advantage or private monetary compensation. The exchange of the Work for other copyrighted works by means of digital file-sharing or otherwise shall not be considered to be intended for or directed toward commercial advantage or private monetary compensation, provided there is no payment of any monetary compensation in connection with the exchange of copyrighted works.\n\n      c. If you distribute, publicly display, publicly perform, or publicly digitally perform the Work or any Derivative Works or Collective Works, You must keep intact all copyright notices for the Work and give the Original Author credit reasonable to the medium or means You are utilizing by conveying the name (or pseudonym if applicable) of the Original Author if supplied; the title of the Work if supplied; to the extent reasonably practicable, the Uniform Resource Identifier, if any, that Licensor specifies to be associated with the Work, unless such URI does not refer to the copyright notice or licensing information for the Work; and in the case of a Derivative Work, a credit identifying the use of the Work in the Derivative Work (e.g., \"French translation of the Work by Original Author,\" or \"Screenplay based on original Work by Original Author\"). Such credit may be implemented in any reasonable manner; provided, however, that in the case of a Derivative Work or Collective Work, at a minimum such credit will appear where any other comparable authorship credit appears and in a manner at least as prominent as such other comparable authorship credit.\n\n      d. For the avoidance of doubt, where the Work is a musical composition:\n\n         i. Performance Royalties Under Blanket Licenses. Licensor reserves the exclusive right to collect, whether individually or via a performance rights society (e.g. ASCAP, BMI, SESAC), royalties for the public performance or public digital performance (e.g. webcast) of the Work if that performance is primarily intended for or directed toward commercial advantage or private monetary compensation.\n\n         ii. Mechanical Rights and Statutory Royalties. Licensor reserves the exclusive right to collect, whether individually or via a music rights agency or designated agent (e.g. Harry Fox Agency), royalties for any phonorecord You create from the Work (\"cover version\") and distribute, subject to the compulsory license created by 17 USC Section 115 of the US Copyright Act (or the equivalent in other jurisdictions), if Your distribution of such cover version is primarily intended for or directed toward commercial advantage or private monetary compensation. Webcasting Rights and Statutory Royalties. For the avoidance of doubt, where the Work is a sound recording, Licensor reserves the exclusive right to collect, whether individually or via a performance-rights society (e.g. SoundExchange), royalties for the public digital performance (e.g. webcast) of the Work, subject to the compulsory license created by 17 USC Section 114 of the US Copyright Act (or the equivalent in other jurisdictions), if Your public digital performance is primarily intended for or directed toward commercial advantage or private monetary compensation.\n\n   5. Representations, Warranties and Disclaimer\n\n   UNLESS OTHERWISE MUTUALLY AGREED TO BY THE PARTIES IN WRITING, LICENSOR OFFERS THE WORK AS-IS AND MAKES NO REPRESENTATIONS OR WARRANTIES OF ANY KIND CONCERNING THE WORK, EXPRESS, IMPLIED, STATUTORY OR OTHERWISE, INCLUDING, WITHOUT LIMITATION, WARRANTIES OF TITLE, MERCHANTIBILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT, OR THE ABSENCE OF LATENT OR OTHER DEFECTS, ACCURACY, OR THE PRESENCE OF ABSENCE OF ERRORS, WHETHER OR NOT DISCOVERABLE. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OF IMPLIED WARRANTIES, SO SUCH EXCLUSION MAY NOT APPLY TO YOU.\n\n   6. Limitation on Liability. EXCEPT TO THE EXTENT REQUIRED BY APPLICABLE LAW, IN NO EVENT WILL LICENSOR BE LIABLE TO YOU ON ANY LEGAL THEORY FOR ANY SPECIAL, INCIDENTAL, CONSEQUENTIAL, PUNITIVE OR EXEMPLARY DAMAGES ARISING OUT OF THIS LICENSE OR THE USE OF THE WORK, EVEN IF LICENSOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\n   7. Termination\n\n      a. This License and the rights granted hereunder will terminate automatically upon any breach by You of the terms of this License. Individuals or entities who have received Derivative Works or Collective Works from You under this License, however, will not have their licenses terminated provided such individuals or entities remain in full compliance with those licenses. Sections 1, 2, 5, 6, 7, and 8 will survive any termination of this License.\n\n      b. Subject to the above terms and conditions, the license granted here is perpetual (for the duration of the applicable copyright in the Work). Notwithstanding the above, Licensor reserves the right to release the Work under different license terms or to stop distributing the Work at any time; provided, however that any such election will not serve to withdraw this License (or any other license that has been, or is required to be, granted under the terms of this License), and this License will continue in full force and effect unless terminated as stated above.\n\n   8. Miscellaneous\n\n      a. Each time You distribute or publicly digitally perform the Work or a Collective Work, the Licensor offers to the recipient a license to the Work on the same terms and conditions as the license granted to You under this License.\n\n      b. Each time You distribute or publicly digitally perform a Derivative Work, Licensor offers to the recipient a license to the original Work on the same terms and conditions as the license granted to You under this License.\n\n      c. If any provision of this License is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this License, and without further action by the parties to this agreement, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.\n\n      d. No term or provision of this License shall be deemed waived and no breach consented to unless such waiver or consent shall be in writing and signed by the party to be charged with such waiver or consent.\n\n      e. This License constitutes the entire agreement between the parties with respect to the Work licensed here. There are no understandings, agreements or representations with respect to the Work not specified here. Licensor shall not be bound by any additional provisions that may appear in any communication from You. This License may not be modified without the mutual written agreement of the Licensor and You.\n\nCreative Commons is not a party to this License, and makes no warranty whatsoever in connection with the Work. Creative Commons will not be liable to You or any party on any legal theory for any damages whatsoever, including without limitation any general, special, incidental or consequential damages arising in connection to this license. Notwithstanding the foregoing two (2) sentences, if Creative Commons has expressly identified itself as the Licensor hereunder, it shall have all rights and obligations of Licensor.\n\nExcept for the limited purpose of indicating to the public that the Work is licensed under the CCPL, neither party will use the trademark \"Creative Commons\" or any related trademark or logo of Creative Commons without the prior written consent of Creative Commons. Any permitted use will be in compliance with Creative Commons' then-current trademark usage guidelines, as may be published on its website or otherwise made available upon request from time to time.\n\nCreative Commons may be contacted at http://creativecommons.org/."],"licenseIds":["CC-BY-NC-2.0"],"keywords":["noncommercial 2 0","monetary compensation webcasting","compensation webcasting rights","attribution noncommercial 2 0","noncommercial 2 0 creative","private monetary compensation webcasting","monetary compensation webcasting rights","compensation webcasting rights and","commons attribution noncommercial 2 0","attribution noncommercial 2 0 creative","noncommercial 2 0 creative commons","or private monetary compensation webcasting","private monetary compensation webcasting rights","monetary compensation webcasting rights and","compensation webcasting rights and statutory"]},{"licenseTexts":["Creative Commons Attribution-NonCommercial 2.5 CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE LEGAL SERVICES. DISTRIBUTION OF THIS LICENSE DOES NOT CREATE AN ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS INFORMATION ON AN \"AS-IS\" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES REGARDING THE INFORMATION PROVIDED, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM ITS USE.\n\nLicense\n\nTHE WORK (AS DEFINED BELOW) IS PROVIDED UNDER THE TERMS OF THIS CREATIVE COMMONS PUBLIC LICENSE (\"CCPL\" OR \"LICENSE\"). THE WORK IS PROTECTED BY COPYRIGHT AND/OR OTHER APPLICABLE LAW. ANY USE OF THE WORK OTHER THAN AS AUTHORIZED UNDER THIS LICENSE OR COPYRIGHT LAW IS PROHIBITED.\n\nBY EXERCISING ANY RIGHTS TO THE WORK PROVIDED HERE, YOU ACCEPT AND AGREE TO BE BOUND BY THE TERMS OF THIS LICENSE. THE LICENSOR GRANTS YOU THE RIGHTS CONTAINED HERE IN CONSIDERATION OF YOUR ACCEPTANCE OF SUCH TERMS AND CONDITIONS.\n\n   1. Definitions\n\n      a. \"Collective Work\" means a work, such as a periodical issue, anthology or encyclopedia, in which the Work in its entirety in unmodified form, along with a number of other contributions, constituting separate and independent works in themselves, are assembled into a collective whole. A work that constitutes a Collective Work will not be considered a Derivative Work (as defined below) for the purposes of this License.\n\n      b. \"Derivative Work\" means a work based upon the Work or upon the Work and other pre-existing works, such as a translation, musical arrangement, dramatization, fictionalization, motion picture version, sound recording, art reproduction, abridgment, condensation, or any other form in which the Work may be recast, transformed, or adapted, except that a work that constitutes a Collective Work will not be considered a Derivative Work for the purpose of this License. For the avoidance of doubt, where the Work is a musical composition or sound recording, the synchronization of the Work in timed-relation with a moving image (\"synching\") will be considered a Derivative Work for the purpose of this License.\n\n      c. \"Licensor\" means the individual or entity that offers the Work under the terms of this License. \"Original Author\" means the individual or entity who created the Work.\n\n      d. \"Work\" means the copyrightable work of authorship offered under the terms of this License.\n\n      e. \"You\" means an individual or entity exercising rights under this License who has not previously violated the terms of this License with respect to the Work, or who has received express permission from the Licensor to exercise rights under this License despite a previous violation.\n\n   2. Fair Use Rights. Nothing in this license is intended to reduce, limit, or restrict any rights arising from fair use, first sale or other limitations on the exclusive rights of the copyright owner under copyright law or other applicable laws.\n\n   3. License Grant. Subject to the terms and conditions of this License, Licensor hereby grants You a worldwide, royalty-free, non-exclusive, perpetual (for the duration of the applicable copyright) license to exercise the rights in the Work as stated below:\n\n      a. to reproduce the Work, to incorporate the Work into one or more Collective Works, and to reproduce the Work as incorporated in the Collective Works;\n\n      b. to create and reproduce Derivative Works;\n\n      c. to distribute copies or phonorecords of, display publicly, perform publicly, and perform publicly by means of a digital audio transmission the Work including as incorporated in Collective Works;\n\n      d. to distribute copies or phonorecords of, display publicly, perform publicly, and perform publicly by means of a digital audio transmission Derivative Works;\n\n      The above rights may be exercised in all media and formats whether now known or hereafter devised. The above rights include the right to make such modifications as are technically necessary to exercise the rights in other media and formats. All rights not expressly granted by Licensor are hereby reserved, including but not limited to the rights set forth in Sections 4(d) and 4(e).\n\n   4. Restrictions.The license granted in Section 3 above is expressly made subject to and limited by the following restrictions:\n\n      a. You may distribute, publicly display, publicly perform, or publicly digitally perform the Work only under the terms of this License, and You must include a copy of, or the Uniform Resource Identifier for, this License with every copy or phonorecord of the Work You distribute, publicly display, publicly perform, or publicly digitally perform. You may not offer or impose any terms on the Work that alter or restrict the terms of this License or the recipients' exercise of the rights granted hereunder.\n\n      b. You may not sublicense the Work. You must keep intact all notices that refer to this License and to the disclaimer of warranties. You may not distribute, publicly display, publicly perform, or publicly digitally perform the Work with any technological measures that control access or use of the Work in a manner inconsistent with the terms of this License Agreement. The above applies to the Work as incorporated in a Collective Work, but this does not require the Collective Work apart from the Work itself to be made subject to the terms of this License. If You create a Collective Work, upon notice from any Licensor You must, to the extent practicable, remove from the Collective Work any credit as required by clause 4(c), as requested. If You create a Derivative Work, upon notice from any Licensor You must, to the extent practicable, remove from the Derivative Work any credit as required by clause 4(c), as requested. You may not exercise any of the rights granted to You in Section 3 above in any manner that is primarily intended for or directed toward commercial advantage or private monetary compensation. The exchange of the Work for other copyrighted works by means of digital file-sharing or otherwise shall not be considered to be intended for or directed toward commercial advantage or private monetary compensation, provided there is no payment of any monetary compensation in connection with the exchange of copyrighted works.\n\n      c. If you distribute, publicly display, publicly perform, or publicly digitally perform the Work or any Derivative Works or Collective Works, You must keep intact all copyright notices for the Work and provide, reasonable to the medium or means You are utilizing: (i) the name of Original Author (or pseudonym, if applicable) if supplied, and/or (ii) if the Original Author and/or Licensor designate another party or parties (e.g. a sponsor institute, publishing entity, journal) for attribution in Licensor's copyright notice, terms of service or by other reasonable means, the name of such party or parties; the title of the Work if supplied; to the extent reasonably practicable, the Uniform Resource Identifier, if any, that Licensor specifies to be associated with the Work, unless such URI does not refer to the copyright notice or licensing information for the Work; and in the case of a Derivative Work, a credit identifying the use of the Work in the Derivative Work (e.g., \"French translation of the Work by Original Author,\" or \"Screenplay based on original Work by Original Author\"). Such credit may be implemented in any reasonable manner; provided, however, that in the case of a Derivative Work or Collective Work, at a minimum such credit will appear where any other comparable authorship credit appears and in a manner at least as prominent as such other comparable authorship credit.\n\n      d. For the avoidance of doubt, where the Work is a musical composition:\n\n         i. Performance Royalties Under Blanket Licenses. Licensor reserves the exclusive right to collect, whether individually or via a performance rights society (e.g. ASCAP, BMI, SESAC), royalties for the public performance or public digital performance (e.g. webcast) of the Work if that performance is primarily intended for or directed toward commercial advantage or private monetary compensation.\n\n         ii. Mechanical Rights and Statutory Royalties. Licensor reserves the exclusive right to collect, whether individually or via a music rights agency or designated agent (e.g. Harry Fox Agency), royalties for any phonorecord You create from the Work (\"cover version\") and distribute, subject to the compulsory license created by 17 USC Section 115 of the US Copyright Act (or the equivalent in other jurisdictions), if Your distribution of such cover version is primarily intended for or directed toward commercial advantage or private monetary compensation.\n\n      e. Webcasting Rights and Statutory Royalties. For the avoidance of doubt, where the Work is a sound recording, Licensor reserves the exclusive right to collect, whether individually or via a performance-rights society (e.g. SoundExchange), royalties for the public digital performance (e.g. webcast) of the Work, subject to the compulsory license created by 17 USC Section 114 of the US Copyright Act (or the equivalent in other jurisdictions), if Your public digital performance is primarily intended for or directed toward commercial advantage or private monetary compensation.\n\n   5. Representations, Warranties and Disclaimer\n\n   UNLESS OTHERWISE MUTUALLY AGREED TO BY THE PARTIES IN WRITING, LICENSOR OFFERS THE WORK AS-IS AND MAKES NO REPRESENTATIONS OR WARRANTIES OF ANY KIND CONCERNING THE WORK, EXPRESS, IMPLIED, STATUTORY OR OTHERWISE, INCLUDING, WITHOUT LIMITATION, WARRANTIES OF TITLE, MERCHANTIBILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT, OR THE ABSENCE OF LATENT OR OTHER DEFECTS, ACCURACY, OR THE PRESENCE OF ABSENCE OF ERRORS, WHETHER OR NOT DISCOVERABLE. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OF IMPLIED WARRANTIES, SO SUCH EXCLUSION MAY NOT APPLY TO YOU.\n\n   6. Limitation on Liability. EXCEPT TO THE EXTENT REQUIRED BY APPLICABLE LAW, IN NO EVENT WILL LICENSOR BE LIABLE TO YOU ON ANY LEGAL THEORY FOR ANY SPECIAL, INCIDENTAL, CONSEQUENTIAL, PUNITIVE OR EXEMPLARY DAMAGES ARISING OUT OF THIS LICENSE OR THE USE OF THE WORK, EVEN IF LICENSOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\n   7. Termination\n\n      a. This License and the rights granted hereunder will terminate automatically upon any breach by You of the terms of this License. Individuals or entities who have received Derivative Works or Collective Works from You under this License, however, will not have their licenses terminated provided such individuals or entities remain in full compliance with those licenses. Sections 1, 2, 5, 6, 7, and 8 will survive any termination of this License.\n\n      b. Subject to the above terms and conditions, the license granted here is perpetual (for the duration of the applicable copyright in the Work). Notwithstanding the above, Licensor reserves the right to release the Work under different license terms or to stop distributing the Work at any time; provided, however that any such election will not serve to withdraw this License (or any other license that has been, or is required to be, granted under the terms of this License), and this License will continue in full force and effect unless terminated as stated above.\n\n   8. Miscellaneous\n\n      a. Each time You distribute or publicly digitally perform the Work or a Collective Work, the Licensor offers to the recipient a license to the Work on the same terms and conditions as the license granted to You under this License.\n\n      b. Each time You distribute or publicly digitally perform a Derivative Work, Licensor offers to the recipient a license to the original Work on the same terms and conditions as the license granted to You under this License.\n\n      c. If any provision of this License is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this License, and without further action by the parties to this agreement, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.\n\n      d. No term or provision of this License shall be deemed waived and no breach consented to unless such waiver or consent shall be in writing and signed by the party to be charged with such waiver or consent.\n\n      e. This License constitutes the entire agreement between the parties with respect to the Work licensed here. There are no understandings, agreements or representations with respect to the Work not specified here. Licensor shall not be bound by any additional provisions that may appear in any communication from You. This License may not be modified without the mutual written agreement of the Licensor and You.\n\nCreative Commons is not a party to this License, and makes no warranty whatsoever in connection with the Work. Creative Commons will not be liable to You or any party on any legal theory for any damages whatsoever, including without limitation any general, special, incidental or consequential damages arising in connection to this license. Notwithstanding the foregoing two (2) sentences, if Creative Commons has expressly identified itself as the Licensor hereunder, it shall have all rights and obligations of Licensor.\n\nExcept for the limited purpose of indicating to the public that the Work is licensed under the CCPL, neither party will use the trademark \"Creative Commons\" or any related trademark or logo of Creative Commons without the prior written consent of Creative Commons. Any permitted use will be in compliance with Creative Commons' then-current trademark usage guidelines, as may be published on its website or otherwise made available upon request from time to time.\n\nCreative Commons may be contacted at http://creativecommons.org/."],"licenseIds":["CC-BY-NC-2.5"],"keywords":["noncommercial 2 5","this license original","license original author","work d work","d work means","license e you","e you means","granted hereunder b","hereunder b you","as requested you","requested you may","name of original","of original author","attribution noncommercial 2 5","noncommercial 2 5 creative","of this license original","this license original author","license original author means","created the work d","the work d work","work d work means","d work means the","this license e you","license e you means","e you means an","rights granted hereunder b","granted hereunder b you","hereunder b you may","c as requested you","as requested you may","requested you may not","the name of original","name of original author","of original author or","commons attribution noncommercial 2 5","attribution noncommercial 2 5 creative","noncommercial 2 5 creative commons","terms of this license original","of this license original author","this license original author means","license original author means the","who created the work d","created the work d work","the work d work means","work d work means the","d work means the copyrightable","of this license e you","this license e you means","license e you means an","e you means an individual","the rights granted hereunder b","rights granted hereunder b you","granted hereunder b you may","hereunder b you may not","b you may not sublicense","4 c as requested you","c as requested you may","as requested you may not","requested you may not exercise","i the name of original","the name of original author","name of original author or","of original author or pseudonym"]},{"licenseTexts":["Creative Commons Attribution-NonCommercial 3.0 Unported CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE LEGAL SERVICES. DISTRIBUTION OF THIS LICENSE DOES NOT CREATE AN ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS INFORMATION ON AN \"AS-IS\" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES REGARDING THE INFORMATION PROVIDED, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM ITS USE.\n\nLicense\n\nTHE WORK (AS DEFINED BELOW) IS PROVIDED UNDER THE TERMS OF THIS CREATIVE COMMONS PUBLIC LICENSE (\"CCPL\" OR \"LICENSE\"). THE WORK IS PROTECTED BY COPYRIGHT AND/OR OTHER APPLICABLE LAW. ANY USE OF THE WORK OTHER THAN AS AUTHORIZED UNDER THIS LICENSE OR COPYRIGHT LAW IS PROHIBITED.\n\nBY EXERCISING ANY RIGHTS TO THE WORK PROVIDED HERE, YOU ACCEPT AND AGREE TO BE BOUND BY THE TERMS OF THIS LICENSE. TO THE EXTENT THIS LICENSE MAY BE CONSIDERED TO BE A CONTRACT, THE LICENSOR GRANTS YOU THE RIGHTS CONTAINED HERE IN CONSIDERATION OF YOUR ACCEPTANCE OF SUCH TERMS AND CONDITIONS.\n\n   1. Definitions\n\n      a. \"Adaptation\" means a work based upon the Work, or upon the Work and other pre-existing works, such as a translation, adaptation, derivative work, arrangement of music or other alterations of a literary or artistic work, or phonogram or performance and includes cinematographic adaptations or any other form in which the Work may be recast, transformed, or adapted including in any form recognizably derived from the original, except that a work that constitutes a Collection will not be considered an Adaptation for the purpose of this License. For the avoidance of doubt, where the Work is a musical work, performance or phonogram, the synchronization of the Work in timed-relation with a moving image (\"synching\") will be considered an Adaptation for the purpose of this License.\n\n      b. \"Collection\" means a collection of literary or artistic works, such as encyclopedias and anthologies, or performances, phonograms or broadcasts, or other works or subject matter other than works listed in Section 1(f) below, which, by reason of the selection and arrangement of their contents, constitute intellectual creations, in which the Work is included in its entirety in unmodified form along with one or more other contributions, each constituting separate and independent works in themselves, which together are assembled into a collective whole. A work that constitutes a Collection will not be considered an Adaptation (as defined above) for the purposes of this License.\n\n      c. \"Distribute\" means to make available to the public the original and copies of the Work or Adaptation, as appropriate, through sale or other transfer of ownership.\n\n      d. \"Licensor\" means the individual, individuals, entity or entities that offer(s) the Work under the terms of this License.\n\n      e. \"Original Author\" means, in the case of a literary or artistic work, the individual, individuals, entity or entities who created the Work or if no individual or entity can be identified, the publisher; and in addition (i) in the case of a performance the actors, singers, musicians, dancers, and other persons who act, sing, deliver, declaim, play in, interpret or otherwise perform literary or artistic works or expressions of folklore; (ii) in the case of a phonogram the producer being the person or legal entity who first fixes the sounds of a performance or other sounds; and, (iii) in the case of broadcasts, the organization that transmits the broadcast.\n\n      f. \"Work\" means the literary and/or artistic work offered under the terms of this License including without limitation any production in the literary, scientific and artistic domain, whatever may be the mode or form of its expression including digital form, such as a book, pamphlet and other writing; a lecture, address, sermon or other work of the same nature; a dramatic or dramatico-musical work; a choreographic work or entertainment in dumb show; a musical composition with or without words; a cinematographic work to which are assimilated works expressed by a process analogous to cinematography; a work of drawing, painting, architecture, sculpture, engraving or lithography; a photographic work to which are assimilated works expressed by a process analogous to photography; a work of applied art; an illustration, map, plan, sketch or three-dimensional work relative to geography, topography, architecture or science; a performance; a broadcast; a phonogram; a compilation of data to the extent it is protected as a copyrightable work; or a work performed by a variety or circus performer to the extent it is not otherwise considered a literary or artistic work.\n\n      g. \"You\" means an individual or entity exercising rights under this License who has not previously violated the terms of this License with respect to the Work, or who has received express permission from the Licensor to exercise rights under this License despite a previous violation.\n\n      h. \"Publicly Perform\" means to perform public recitations of the Work and to communicate to the public those public recitations, by any means or process, including by wire or wireless means or public digital performances; to make available to the public Works in such a way that members of the public may access these Works from a place and at a place individually chosen by them; to perform the Work to the public by any means or process and the communication to the public of the performances of the Work, including by public digital performance; to broadcast and rebroadcast the Work by any means including signs, sounds or images.\n\n      i. \"Reproduce\" means to make copies of the Work by any means including without limitation by sound or visual recordings and the right of fixation and reproducing fixations of the Work, including storage of a protected performance or phonogram in digital form or other electronic medium.\n\n   2. Fair Dealing Rights. Nothing in this License is intended to reduce, limit, or restrict any uses free from copyright or rights arising from limitations or exceptions that are provided for in connection with the copyright protection under copyright law or other applicable laws.\n\n   3. License Grant. Subject to the terms and conditions of this License, Licensor hereby grants You a worldwide, royalty-free, non-exclusive, perpetual (for the duration of the applicable copyright) license to exercise the rights in the Work as stated below:\n\n      a. to Reproduce the Work, to incorporate the Work into one or more Collections, and to Reproduce the Work as incorporated in the Collections;\n\n      b. to create and Reproduce Adaptations provided that any such Adaptation, including any translation in any medium, takes reasonable steps to clearly label, demarcate or otherwise identify that changes were made to the original Work. For example, a translation could be marked \"The original work was translated from English to Spanish,\" or a modification could indicate \"The original work has been modified.\";\n\n      c. to Distribute and Publicly Perform the Work including as incorporated in Collections; and,\n\n      d. to Distribute and Publicly Perform Adaptations.\n\n      The above rights may be exercised in all media and formats whether now known or hereafter devised. The above rights include the right to make such modifications as are technically necessary to exercise the rights in other media and formats. Subject to Section 8(f), all rights not expressly granted by Licensor are hereby reserved, including but not limited to the rights set forth in Section 4(d).\n\n   4. Restrictions. The license granted in Section 3 above is expressly made subject to and limited by the following restrictions:\n\n      a. You may Distribute or Publicly Perform the Work only under the terms of this License. You must include a copy of, or the Uniform Resource Identifier (URI) for, this License with every copy of the Work You Distribute or Publicly Perform. You may not offer or impose any terms on the Work that restrict the terms of this License or the ability of the recipient of the Work to exercise the rights granted to that recipient under the terms of the License. You may not sublicense the Work. You must keep intact all notices that refer to this License and to the disclaimer of warranties with every copy of the Work You Distribute or Publicly Perform. When You Distribute or Publicly Perform the Work, You may not impose any effective technological measures on the Work that restrict the ability of a recipient of the Work from You to exercise the rights granted to that recipient under the terms of the License. This Section 4(a) applies to the Work as incorporated in a Collection, but this does not require the Collection apart from the Work itself to be made subject to the terms of this License. If You create a Collection, upon notice from any Licensor You must, to the extent practicable, remove from the Collection any credit as required by Section 4(c), as requested. If You create an Adaptation, upon notice from any Licensor You must, to the extent practicable, remove from the Adaptation any credit as required by Section 4(c), as requested.\n\n      b. You may not exercise any of the rights granted to You in Section 3 above in any manner that is primarily intended for or directed toward commercial advantage or private monetary compensation. The exchange of the Work for other copyrighted works by means of digital file-sharing or otherwise shall not be considered to be intended for or directed toward commercial advantage or private monetary compensation, provided there is no payment of any monetary compensation in connection with the exchange of copyrighted works.\n\n      c. If You Distribute, or Publicly Perform the Work or any Adaptations or Collections, You must, unless a request has been made pursuant to Section 4(a), keep intact all copyright notices for the Work and provide, reasonable to the medium or means You are utilizing: (i) the name of the Original Author (or pseudonym, if applicable) if supplied, and/or if the Original Author and/or Licensor designate another party or parties (e.g., a sponsor institute, publishing entity, journal) for attribution (\"Attribution Parties\") in Licensor's copyright notice, terms of service or by other reasonable means, the name of such party or parties; (ii) the title of the Work if supplied; (iii) to the extent reasonably practicable, the URI, if any, that Licensor specifies to be associated with the Work, unless such URI does not refer to the copyright notice or licensing information for the Work; and, (iv) consistent with Section 3(b), in the case of an Adaptation, a credit identifying the use of the Work in the Adaptation (e.g., \"French translation of the Work by Original Author,\" or \"Screenplay based on original Work by Original Author\"). The credit required by this Section 4(c) may be implemented in any reasonable manner; provided, however, that in the case of a Adaptation or Collection, at a minimum such credit will appear, if a credit for all contributing authors of the Adaptation or Collection appears, then as part of these credits and in a manner at least as prominent as the credits for the other contributing authors. For the avoidance of doubt, You may only use the credit required by this Section for the purpose of attribution in the manner set out above and, by exercising Your rights under this License, You may not implicitly or explicitly assert or imply any connection with, sponsorship or endorsement by the Original Author, Licensor and/or Attribution Parties, as appropriate, of You or Your use of the Work, without the separate, express prior written permission of the Original Author, Licensor and/or Attribution Parties.\n\n      d. For the avoidance of doubt:\n\n         i. Non-waivable Compulsory License Schemes. In those jurisdictions in which the right to collect royalties through any statutory or compulsory licensing scheme cannot be waived, the Licensor reserves the exclusive right to collect such royalties for any exercise by You of the rights granted under this License;\n\n         ii. Waivable Compulsory License Schemes. In those jurisdictions in which the right to collect royalties through any statutory or compulsory licensing scheme can be waived, the Licensor reserves the exclusive right to collect such royalties for any exercise by You of the rights granted under this License if Your exercise of such rights is for a purpose or use which is otherwise than noncommercial as permitted under Section 4(b) and otherwise waives the right to collect royalties through any statutory or compulsory licensing scheme; and,\n\n         iii. Voluntary License Schemes. The Licensor reserves the right to collect royalties, whether individually or, in the event that the Licensor is a member of a collecting society that administers voluntary licensing schemes, via that society, from any exercise by You of the rights granted under this License that is for a purpose or use which is otherwise than noncommercial as permitted under Section 4(c).\n\n      e. Except as otherwise agreed in writing by the Licensor or as may be otherwise permitted by applicable law, if You Reproduce, Distribute or Publicly Perform the Work either by itself or as part of any Adaptations or Collections, You must not distort, mutilate, modify or take other derogatory action in relation to the Work which would be prejudicial to the Original Author's honor or reputation. Licensor agrees that in those jurisdictions (e.g. Japan), in which any exercise of the right granted in Section 3(b) of this License (the right to make Adaptations) would be deemed to be a distortion, mutilation, modification or other derogatory action prejudicial to the Original Author's honor and reputation, the Licensor will waive or not assert, as appropriate, this Section, to the fullest extent permitted by the applicable national law, to enable You to reasonably exercise Your right under Section 3(b) of this License (right to make Adaptations) but not otherwise.\n\n   5. Representations, Warranties and Disclaimer\n\n   UNLESS OTHERWISE MUTUALLY AGREED TO BY THE PARTIES IN WRITING, LICENSOR OFFERS THE WORK AS-IS AND MAKES NO REPRESENTATIONS OR WARRANTIES OF ANY KIND CONCERNING THE WORK, EXPRESS, IMPLIED, STATUTORY OR OTHERWISE, INCLUDING, WITHOUT LIMITATION, WARRANTIES OF TITLE, MERCHANTIBILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT, OR THE ABSENCE OF LATENT OR OTHER DEFECTS, ACCURACY, OR THE PRESENCE OF ABSENCE OF ERRORS, WHETHER OR NOT DISCOVERABLE. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OF IMPLIED WARRANTIES, SO SUCH EXCLUSION MAY NOT APPLY TO YOU.\n\n   6. Limitation on Liability. EXCEPT TO THE EXTENT REQUIRED BY APPLICABLE LAW, IN NO EVENT WILL LICENSOR BE LIABLE TO YOU ON ANY LEGAL THEORY FOR ANY SPECIAL, INCIDENTAL, CONSEQUENTIAL, PUNITIVE OR EXEMPLARY DAMAGES ARISING OUT OF THIS LICENSE OR THE USE OF THE WORK, EVEN IF LICENSOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\n   7. Termination\n\n      a. This License and the rights granted hereunder will terminate automatically upon any breach by You of the terms of this License. Individuals or entities who have received Adaptations or Collections from You under this License, however, will not have their licenses terminated provided such individuals or entities remain in full compliance with those licenses. Sections 1, 2, 5, 6, 7, and 8 will survive any termination of this License.\n\n      b. Subject to the above terms and conditions, the license granted here is perpetual (for the duration of the applicable copyright in the Work). Notwithstanding the above, Licensor reserves the right to release the Work under different license terms or to stop distributing the Work at any time; provided, however that any such election will not serve to withdraw this License (or any other license that has been, or is required to be, granted under the terms of this License), and this License will continue in full force and effect unless terminated as stated above.\n\n   8. Miscellaneous\n\n      a. Each time You Distribute or Publicly Perform the Work or a Collection, the Licensor offers to the recipient a license to the Work on the same terms and conditions as the license granted to You under this License.\n\n      b. Each time You Distribute or Publicly Perform an Adaptation, Licensor offers to the recipient a license to the original Work on the same terms and conditions as the license granted to You under this License.\n\n      c. If any provision of this License is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this License, and without further action by the parties to this agreement, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.\n\n      d. No term or provision of this License shall be deemed waived and no breach consented to unless such waiver or consent shall be in writing and signed by the party to be charged with such waiver or consent.\n\n      e. This License constitutes the entire agreement between the parties with respect to the Work licensed here. There are no understandings, agreements or representations with respect to the Work not specified here. Licensor shall not be bound by any additional provisions that may appear in any communication from You. This License may not be modified without the mutual written agreement of the Licensor and You.\n\n      f. The rights granted under, and the subject matter referenced, in this License were drafted utilizing the terminology of the Berne Convention for the Protection of Literary and Artistic Works (as amended on September 28, 1979), the Rome Convention of 1961, the WIPO Copyright Treaty of 1996, the WIPO Performances and Phonograms Treaty of 1996 and the Universal Copyright Convention (as revised on July 24, 1971). These rights and subject matter take effect in the relevant jurisdiction in which the License terms are sought to be enforced according to the corresponding provisions of the implementation of those treaty provisions in the applicable national law. If the standard suite of rights granted under applicable copyright law includes additional rights not granted under this License, such additional rights are deemed to be included in the License; this License is not intended to restrict the license of any rights under applicable law.\n\nCreative Commons Notice\n\nCreative Commons is not a party to this License, and makes no warranty whatsoever in connection with the Work. Creative Commons will not be liable to You or any party on any legal theory for any damages whatsoever, including without limitation any general, special, incidental or consequential damages arising in connection to this license. Notwithstanding the foregoing two (2) sentences, if Creative Commons has expressly identified itself as the Licensor hereunder, it shall have all rights and obligations of Licensor.\n\nExcept for the limited purpose of indicating to the public that the Work is licensed under the CCPL, Creative Commons does not authorize the use by either party of the trademark \"Creative Commons\" or any related trademark or logo of Creative Commons without the prior written consent of Creative Commons. Any permitted use will be in compliance with Creative Commons' then-current trademark usage guidelines, as may be published on its website or otherwise made available upon request from time to time. For the avoidance of doubt, this trademark restriction does not form part of the License.\n\nCreative Commons may be contacted at http://creativecommons.org/."],"licenseIds":["CC-BY-NC-3.0"],"keywords":["attribution noncommercial 3","noncommercial 3 0","4 c e","c e except","commons attribution noncommercial 3","attribution noncommercial 3 0","noncommercial 3 0 unported","section 4 c e","4 c e except","c e except as","creative commons attribution noncommercial 3","commons attribution noncommercial 3 0","attribution noncommercial 3 0 unported","noncommercial 3 0 unported creative","under section 4 c e","section 4 c e except","4 c e except as","c e except as otherwise"]},{"licenseTexts":["Creative Commons Attribution-NonCommercial 4.0 International Creative Commons Corporation (\"Creative Commons\") is not a law firm and does not provide legal services or legal advice. Distribution of Creative Commons public licenses does not create a lawyer-client or other relationship. Creative Commons makes its licenses and related information available on an \"as-is\" basis. Creative Commons gives no warranties regarding its licenses, any material licensed under their terms and conditions, or any related information. Creative Commons disclaims all liability for damages resulting from their use to the fullest extent possible.\n\nUsing Creative Commons Public Licenses\n\nCreative Commons public licenses provide a standard set of terms and conditions that creators and other rights holders may use to share original works of authorship and other material subject to copyright and certain other rights specified in the public license below. The following considerations are for informational purposes only, are not exhaustive, and do not form part of our licenses.\n\n   \n\n   Considerations for licensors: Our public licenses are intended for use by those authorized to give the public permission to use material in ways otherwise restricted by copyright and certain other rights. Our licenses are irrevocable. Licensors should read and understand the terms and conditions of the license they choose before applying it. Licensors should also secure all rights necessary before applying our licenses so that the public can reuse the material as expected. Licensors should clearly mark any material not subject to the license. This includes other CC-licensed material, or material used under an exception or limitation to copyright. More considerations for licensors : wiki.creativecommons.org/Considerations_for_licensors\n\n   \n\n   Considerations for the public: By using one of our public licenses, a licensor grants the public permission to use the licensed material under specified terms and conditions. If the licensor's permission is not necessary for any reason–for example, because of any applicable exception or limitation to copyright–then that use is not regulated by the license. Our licenses grant only permissions under copyright and certain other rights that a licensor has authority to grant. Use of the licensed material may still be restricted for other reasons, including because others have copyright or other rights in the material. A licensor may make special requests, such as asking that all changes be marked or described. Although not required by our licenses, you are encouraged to respect those requests where reasonable. More considerations for the public : wiki.creativecommons.org/Considerations_for_licensees Creative Commons Attribution-NonCommercial 4.0 International Public License\n\nBy exercising the Licensed Rights (defined below), You accept and agree to be bound by the terms and conditions of this Creative Commons Attribution-NonCommercial 4.0 International Public License (\"Public License\"). To the extent this Public License may be interpreted as a contract, You are granted the Licensed Rights in consideration of Your acceptance of these terms and conditions, and the Licensor grants You such rights in consideration of benefits the Licensor receives from making the Licensed Material available under these terms and conditions.\n\n   \n\n   Section 1 – Definitions.\n\n      a. Adapted Material means material subject to Copyright and Similar Rights that is derived from or based upon the Licensed Material and in which the Licensed Material is translated, altered, arranged, transformed, or otherwise modified in a manner requiring permission under the Copyright and Similar Rights held by the Licensor. For purposes of this Public License, where the Licensed Material is a musical work, performance, or sound recording, Adapted Material is always produced where the Licensed Material is synched in timed relation with a moving image.\n\n      b. Adapter's License means the license You apply to Your Copyright and Similar Rights in Your contributions to Adapted Material in accordance with the terms and conditions of this Public License.\n\n      c. Copyright and Similar Rights means copyright and/or similar rights closely related to copyright including, without limitation, performance, broadcast, sound recording, and Sui Generis Database Rights, without regard to how the rights are labeled or categorized. For purposes of this Public License, the rights specified in Section 2(b)(1)-(2) are not Copyright and Similar Rights.\n\n      d. Effective Technological Measures means those measures that, in the absence of proper authority, may not be circumvented under laws fulfilling obligations under Article 11 of the WIPO Copyright Treaty adopted on December 20, 1996, and/or similar international agreements.\n\n      e. Exceptions and Limitations means fair use, fair dealing, and/or any other exception or limitation to Copyright and Similar Rights that applies to Your use of the Licensed Material.\n\n      f. Licensed Material means the artistic or literary work, database, or other material to which the Licensor applied this Public License.\n\n      g. Licensed Rights means the rights granted to You subject to the terms and conditions of this Public License, which are limited to all Copyright and Similar Rights that apply to Your use of the Licensed Material and that the Licensor has authority to license.\n\n      h. Licensor means the individual(s) or entity(ies) granting rights under this Public License.\n\n      i. NonCommercial means not primarily intended for or directed towards commercial advantage or monetary compensation. For purposes of this Public License, the exchange of the Licensed Material for other material subject to Copyright and Similar Rights by digital file-sharing or similar means is NonCommercial provided there is no payment of monetary compensation in connection with the exchange.\n\n      j. Share means to provide material to the public by any means or process that requires permission under the Licensed Rights, such as reproduction, public display, public performance, distribution, dissemination, communication, or importation, and to make material available to the public including in ways that members of the public may access the material from a place and at a time individually chosen by them.\n\n      k. Sui Generis Database Rights means rights other than copyright resulting from Directive 96/9/EC of the European Parliament and of the Council of 11 March 1996 on the legal protection of databases, as amended and/or succeeded, as well as other essentially equivalent rights anywhere in the world.\n\n      l. You means the individual or entity exercising the Licensed Rights under this Public License. Your has a corresponding meaning.\n\n   \n\n   Section 2 – Scope.\n\n      a. License grant.\n\n         1. Subject to the terms and conditions of this Public License, the Licensor hereby grants You a worldwide, royalty-free, non-sublicensable, non-exclusive, irrevocable license to exercise the Licensed Rights in the Licensed Material to:\n\n            A. reproduce and Share the Licensed Material, in whole or in part, for NonCommercial purposes only; and\n\n            B. produce, reproduce, and Share Adapted Material for NonCommercial purposes only.\n\n         2. Exceptions and Limitations. For the avoidance of doubt, where Exceptions and Limitations apply to Your use, this Public License does not apply, and You do not need to comply with its terms and conditions.\n\n         3. Term. The term of this Public License is specified in Section 6(a).\n\n         4. Media and formats; technical modifications allowed. The Licensor authorizes You to exercise the Licensed Rights in all media and formats whether now known or hereafter created, and to make technical modifications necessary to do so. The Licensor waives and/or agrees not to assert any right or authority to forbid You from making technical modifications necessary to exercise the Licensed Rights, including technical modifications necessary to circumvent Effective Technological Measures. For purposes of this Public License, simply making modifications authorized by this Section 2(a)(4) never produces Adapted Material.\n\n         5. Downstream recipients.\n\n            A. Offer from the Licensor – Licensed Material. Every recipient of the Licensed Material automatically receives an offer from the Licensor to exercise the Licensed Rights under the terms and conditions of this Public License.\n\n            B. No downstream restrictions. You may not offer or impose any additional or different terms or conditions on, or apply any Effective Technological Measures to, the Licensed Material if doing so restricts exercise of the Licensed Rights by any recipient of the Licensed Material.\n\n         6. No endorsement. Nothing in this Public License constitutes or may be construed as permission to assert or imply that You are, or that Your use of the Licensed Material is, connected with, or sponsored, endorsed, or granted official status by, the Licensor or others designated to receive attribution as provided in Section 3(a)(1)(A)(i).\n\n      b. Other rights.\n\n         1. Moral rights, such as the right of integrity, are not licensed under this Public License, nor are publicity, privacy, and/or other similar personality rights; however, to the extent possible, the Licensor waives and/or agrees not to assert any such rights held by the Licensor to the limited extent necessary to allow You to exercise the Licensed Rights, but not otherwise.\n\n         2. Patent and trademark rights are not licensed under this Public License.\n\n         3. To the extent possible, the Licensor waives any right to collect royalties from You for the exercise of the Licensed Rights, whether directly or through a collecting society under any voluntary or waivable statutory or compulsory licensing scheme. In all other cases the Licensor expressly reserves any right to collect such royalties, including when the Licensed Material is used other than for NonCommercial purposes.\n\n   \n\n   Section 3 – License Conditions.\n\n   Your exercise of the Licensed Rights is expressly made subject to the following conditions.\n\n      a. Attribution.\n\n         1. If You Share the Licensed Material (including in modified form), You must:\n\n            A. retain the following if it is supplied by the Licensor with the Licensed Material:\n\n               i. identification of the creator(s) of the Licensed Material and any others designated to receive attribution, in any reasonable manner requested by the Licensor (including by pseudonym if designated);\n\n               ii. a copyright notice;\n\n               iii. a notice that refers to this Public License;\n\n               iv. a notice that refers to the disclaimer of warranties;\n\n               v. a URI or hyperlink to the Licensed Material to the extent reasonably practicable;\n\n            B. indicate if You modified the Licensed Material and retain an indication of any previous modifications; and\n\n            C. indicate the Licensed Material is licensed under this Public License, and include the text of, or the URI or hyperlink to, this Public License.\n\n         2. You may satisfy the conditions in Section 3(a)(1) in any reasonable manner based on the medium, means, and context in which You Share the Licensed Material. For example, it may be reasonable to satisfy the conditions by providing a URI or hyperlink to a resource that includes the required information.\n\n         3. If requested by the Licensor, You must remove any of the information required by Section 3(a)(1)(A) to the extent reasonably practicable.\n\n         4. If You Share Adapted Material You produce, the Adapter's License You apply must not prevent recipients of the Adapted Material from complying with this Public License.\n\n   \n\n   Section 4 – Sui Generis Database Rights.\n\n   Where the Licensed Rights include Sui Generis Database Rights that apply to Your use of the Licensed Material:\n\n      a. for the avoidance of doubt, Section 2(a)(1) grants You the right to extract, reuse, reproduce, and Share all or a substantial portion of the contents of the database for NonCommercial purposes only;\n\n      b. if You include all or a substantial portion of the database contents in a database in which You have Sui Generis Database Rights, then the database in which You have Sui Generis Database Rights (but not its individual contents) is Adapted Material; and\n\n      c. You must comply with the conditions in Section 3(a) if You Share all or a substantial portion of the contents of the database.\n\n   For the avoidance of doubt, this Section 4 supplements and does not replace Your obligations under this Public License where the Licensed Rights include other Copyright and Similar Rights.\n\n   \n\n   Section 5 – Disclaimer of Warranties and Limitation of Liability.\n\n      a. Unless otherwise separately undertaken by the Licensor, to the extent possible, the Licensor offers the Licensed Material as-is and as-available, and makes no representations or warranties of any kind concerning the Licensed Material, whether express, implied, statutory, or other. This includes, without limitation, warranties of title, merchantability, fitness for a particular purpose, non-infringement, absence of latent or other defects, accuracy, or the presence or absence of errors, whether or not known or discoverable. Where disclaimers of warranties are not allowed in full or in part, this disclaimer may not apply to You.\n\n      b. To the extent possible, in no event will the Licensor be liable to You on any legal theory (including, without limitation, negligence) or otherwise for any direct, special, indirect, incidental, consequential, punitive, exemplary, or other losses, costs, expenses, or damages arising out of this Public License or use of the Licensed Material, even if the Licensor has been advised of the possibility of such losses, costs, expenses, or damages. Where a limitation of liability is not allowed in full or in part, this limitation may not apply to You.\n\n      c. The disclaimer of warranties and limitation of liability provided above shall be interpreted in a manner that, to the extent possible, most closely approximates an absolute disclaimer and waiver of all liability.\n\n   \n\n   Section 6 – Term and Termination.\n\n      a. This Public License applies for the term of the Copyright and Similar Rights licensed here. However, if You fail to comply with this Public License, then Your rights under this Public License terminate automatically.\n\n      b. Where Your right to use the Licensed Material has terminated under Section 6(a), it reinstates:\n\n         1. automatically as of the date the violation is cured, provided it is cured within 30 days of Your discovery of the violation; or\n\n         2. upon express reinstatement by the Licensor.\n\n      For the avoidance of doubt, this Section 6(b) does not affect any right the Licensor may have to seek remedies for Your violations of this Public License.\n\n      c. For the avoidance of doubt, the Licensor may also offer the Licensed Material under separate terms or conditions or stop distributing the Licensed Material at any time; however, doing so will not terminate this Public License.\n\n      d. Sections 1, 5, 6, 7, and 8 survive termination of this Public License.\n\n   \n\n   Section 7 – Other Terms and Conditions.\n\n      a. The Licensor shall not be bound by any additional or different terms or conditions communicated by You unless expressly agreed.\n\n      b. Any arrangements, understandings, or agreements regarding the Licensed Material not stated herein are separate from and independent of the terms and conditions of this Public License.\n\n   \n\n   Section 8 – Interpretation.\n\n      a. For the avoidance of doubt, this Public License does not, and shall not be interpreted to, reduce, limit, restrict, or impose conditions on any use of the Licensed Material that could lawfully be made without permission under this Public License.\n\n      b. To the extent possible, if any provision of this Public License is deemed unenforceable, it shall be automatically reformed to the minimum extent necessary to make it enforceable. If the provision cannot be reformed, it shall be severed from this Public License without affecting the enforceability of the remaining terms and conditions.\n\n      c. No term or condition of this Public License will be waived and no failure to comply consented to unless expressly agreed to by the Licensor.\n\n      d. Nothing in this Public License constitutes or may be interpreted as a limitation upon, or waiver of, any privileges and immunities that apply to the Licensor or You, including from the legal processes of any jurisdiction or authority.\n\nCreative Commons is not a party to its public licenses. Notwithstanding, Creative Commons may elect to apply one of its public licenses to material it publishes and in those instances will be considered the \"Licensor.\" The text of the Creative Commons public licenses is dedicated to the public domain under the CC0 Public Domain Dedication. Except for the limited purpose of indicating that material is shared under a Creative Commons public license or as otherwise permitted by the Creative Commons policies published at creativecommons.org/policies, Creative Commons does not authorize the use of the trademark \"Creative Commons\" or any other trademark or logo of Creative Commons without its prior written consent including, without limitation, in connection with any unauthorized modifications to any of its public licenses or any other arrangements, understandings, or agreements concerning use of licensed material. For the avoidance of doubt, this paragraph does not form part of the public licenses.\n\nCreative Commons may be contacted at creativecommons.org."],"licenseIds":["CC-BY-NC-4.0"],"keywords":["license i noncommercial","i noncommercial means","the exchange j","exchange j share","j share means","by them k","them k sui","k sui generis","the world l","world l you","l you means","public license i noncommercial","license i noncommercial means","i noncommercial means not","with the exchange j","the exchange j share","exchange j share means","j share means to","chosen by them k","by them k sui","them k sui generis","k sui generis database","in the world l","the world l you","world l you means","l you means the","noncommercial 4 0 international creative","this public license i noncommercial","public license i noncommercial means","license i noncommercial means not","i noncommercial means not primarily","connection with the exchange j","with the exchange j share","the exchange j share means","exchange j share means to","j share means to provide","individually chosen by them k","chosen by them k sui","by them k sui generis","them k sui generis database","k sui generis database rights","anywhere in the world l","in the world l you","the world l you means","world l you means the","l you means the individual"]},{"licenseTexts":["Creative Commons Attribution-NoDerivs-NonCommercial 1.0 CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE LEGAL SERVICES. DISTRIBUTION OF THIS DRAFT LICENSE DOES NOT CREATE AN ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS INFORMATION ON AN \"AS-IS\" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES REGARDING THE INFORMATION PROVIDED, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM ITS USE.\n\nLicense\n\nTHE WORK (AS DEFINED BELOW) IS PROVIDED UNDER THE TERMS OF THIS CREATIVE COMMONS PUBLIC LICENSE (\"CCPL\" OR \"LICENSE\"). THE WORK IS PROTECTED BY COPYRIGHT AND/OR OTHER APPLICABLE LAW. ANY USE OF THE WORK OTHER THAN AS AUTHORIZED UNDER THIS LICENSE IS PROHIBITED.\n\nBY EXERCISING ANY RIGHTS TO THE WORK PROVIDED HERE, YOU ACCEPT AND AGREE TO BE BOUND BY THE TERMS OF THIS LICENSE. THE LICENSOR GRANTS YOU THE RIGHTS CONTAINED HERE IN CONSIDERATION OF YOUR ACCEPTANCE OF SUCH TERMS AND CONDITIONS.\n\n   1. Definitions\n\n      a. \"Collective Work\" means a work, such as a periodical issue, anthology or encyclopedia, in which the Work in its entirety in unmodified form, along with a number of other contributions, constituting separate and independent works in themselves, are assembled into a collective whole. A work that constitutes a Collective Work will not be considered a Derivative Work (as defined below) for the purposes of this License.\n\n      b. \"Derivative Work\" means a work based upon the Work or upon the Work and other pre-existing works, such as a translation, musical arrangement, dramatization, fictionalization, motion picture version, sound recording, art reproduction, abridgment, condensation, or any other form in which the Work may be recast, transformed, or adapted, except that a work that constitutes a Collective Work will not be considered a Derivative Work for the purpose of this License.\n\n      c. \"Licensor\" means the individual or entity that offers the Work under the terms of this License.\n\n      d. \"Original Author\" means the individual or entity who created the Work.\n\n      e. \"Work\" means the copyrightable work of authorship offered under the terms of this License.\n\n      f. \"You\" means an individual or entity exercising rights under this License who has not previously violated the terms of this License with respect to the Work, or who has received express permission from the Licensor to exercise rights under this License despite a previous violation.\n\n   2. Fair Use Rights. Nothing in this license is intended to reduce, limit, or restrict any rights arising from fair use, first sale or other limitations on the exclusive rights of the copyright owner under copyright law or other applicable laws.\n\n   3. License Grant. Subject to the terms and conditions of this License, Licensor hereby grants You a worldwide, royalty-free, non-exclusive, perpetual (for the duration of the applicable copyright) license to exercise the rights in the Work as stated below:\n\n      a. to reproduce the Work, to incorporate the Work into one or more Collective Works, and to reproduce the Work as incorporated in the Collective Works;\n\n      b. to distribute copies or phonorecords of, display publicly, perform publicly, and perform publicly by means of a digital audio transmission the Work including as incorporated in Collective Works;\n\n      The above rights may be exercised in all media and formats whether now known or hereafter devised. The above rights include the right to make such modifications as are technically necessary to exercise the rights in other media and formats. All rights not expressly granted by Licensor are hereby reserved.\n\n   4. Restrictions. The license granted in Section 3 above is expressly made subject to and limited by the following restrictions:\n\n      a. You may distribute, publicly display, publicly perform, or publicly digitally perform the Work only under the terms of this License, and You must include a copy of, or the Uniform Resource Identifier for, this License with every copy or phonorecord of the Work You distribute, publicly display, publicly perform, or publicly digitally perform. You may not offer or impose any terms on the Work that alter or restrict the terms of this License or the recipients' exercise of the rights granted hereunder. You may not sublicense the Work. You must keep intact all notices that refer to this License and to the disclaimer of warranties. You may not distribute, publicly display, publicly perform, or publicly digitally perform the Work with any technological measures that control access or use of the Work in a manner inconsistent with the terms of this License Agreement. The above applies to the Work as incorporated in a Collective Work, but this does not require the Collective Work apart from the Work itself to be made subject to the terms of this License. If You create a Collective Work, upon notice from any Licensor You must, to the extent practicable, remove from the Collective Work any reference to such Licensor or the Original Author, as requested.\n\n      b. You may not exercise any of the rights granted to You in Section 3 above in any manner that is primarily intended for or directed toward commercial advantage or private monetary compensation. The exchange of the Work for other copyrighted works by means of digital file-sharing or otherwise shall not be considered to be intended for or directed toward commercial advantage or private monetary compensation, provided there is no payment of any monetary compensation in connection with the exchange of copyrighted works.\n\n      c. If you distribute, publicly display, publicly perform, or publicly digitally perform the Work or any Collective Works, You must keep intact all copyright notices for the Work and give the Original Author credit reasonable to the medium or means You are utilizing by conveying the name (or pseudonym if applicable) of the Original Author if supplied; the title of the Work if supplied. Such credit may be implemented in any reasonable manner; provided, however, that in the case of a Collective Work, at a minimum such credit will appear where any other comparable authorship credit appears and in a manner at least as prominent as such other comparable authorship credit.\n\n   5. Representations, Warranties and Disclaimer\n\n      a. By offering the Work for public release under this License, Licensor represents and warrants that, to the best of Licensor's knowledge after reasonable inquiry:\n\n         i. Licensor has secured all rights in the Work necessary to grant the license rights hereunder and to permit the lawful exercise of the rights granted hereunder without You having any obligation to pay any royalties, compulsory license fees, residuals or any other payments;\n\n         ii. The Work does not infringe the copyright, trademark, publicity rights, common law rights or any other right of any third party or constitute defamation, invasion of privacy or other tortious injury to any third party.\n\n      b. EXCEPT AS EXPRESSLY STATED IN THIS LICENSE OR OTHERWISE AGREED IN WRITING OR REQUIRED BY APPLICABLE LAW, THE WORK IS LICENSED ON AN \"AS IS\" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES REGARDING THE CONTENTS OR ACCURACY OF THE WORK.\n\n   6. Limitation on Liability. EXCEPT TO THE EXTENT REQUIRED BY APPLICABLE LAW, AND EXCEPT FOR DAMAGES ARISING FROM LIABILITY TO A THIRD PARTY RESULTING FROM BREACH OF THE WARRANTIES IN SECTION 5, IN NO EVENT WILL LICENSOR BE LIABLE TO YOU ON ANY LEGAL THEORY FOR ANY SPECIAL, INCIDENTAL, CONSEQUENTIAL, PUNITIVE OR EXEMPLARY DAMAGES ARISING OUT OF THIS LICENSE OR THE USE OF THE WORK, EVEN IF LICENSOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\n   7. Termination\n\n      a. This License and the rights granted hereunder will terminate automatically upon any breach by You of the terms of this License. Individuals or entities who have received Collective Works from You under this License, however, will not have their licenses terminated provided such individuals or entities remain in full compliance with those licenses. Sections 1, 2, 5, 6, 7, and 8 will survive any termination of this License.\n\n      b. Subject to the above terms and conditions, the license granted here is perpetual (for the duration of the applicable copyright in the Work). Notwithstanding the above, Licensor reserves the right to release the Work under different license terms or to stop distributing the Work at any time; provided, however that any such election will not serve to withdraw this License (or any other license that has been, or is required to be, granted under the terms of this License), and this License will continue in full force and effect unless terminated as stated above.\n\n   8. Miscellaneous\n\n      a. Each time You distribute or publicly digitally perform the Work or a Collective Work, the Licensor offers to the recipient a license to the Work on the same terms and conditions as the license granted to You under this License.\n\n      b. If any provision of this License is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this License, and without further action by the parties to this agreement, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.\n\n      c. No term or provision of this License shall be deemed waived and no breach consented to unless such waiver or consent shall be in writing and signed by the party to be charged with such waiver or consent.\n\n      d. This License constitutes the entire agreement between the parties with respect to the Work licensed here. There are no understandings, agreements or representations with respect to the Work not specified here. Licensor shall not be bound by any additional provisions that may appear in any communication from You. This License may not be modified without the mutual written agreement of the Licensor and You.\n\nCreative Commons is not a party to this License, and makes no warranty whatsoever in connection with the Work. Creative Commons will not be liable to You or any party on any legal theory for any damages whatsoever, including without limitation any general, special, incidental or consequential damages arising in connection to this license. Notwithstanding the foregoing two (2) sentences, if Creative Commons has expressly identified itself as the Licensor hereunder, it shall have all rights and obligations of Licensor.\n\nExcept for the limited purpose of indicating to the public that the Work is licensed under the CCPL, neither party will use the trademark \"Creative Commons\" or any related trademark or logo of Creative Commons without the prior written consent of Creative Commons. Any permitted use will be in compliance with Creative Commons' then-current trademark usage guidelines, as may be published on its website or otherwise made available upon request from time to time.\n\nCreative Commons may be contacted at http://creativecommons.org/."],"licenseIds":["CC-BY-NC-ND-1.0"],"keywords":["attribution noderivs noncommercial","noderivs noncommercial 1","commons attribution noderivs noncommercial","attribution noderivs noncommercial 1","noderivs noncommercial 1 0","creative commons attribution noderivs noncommercial","commons attribution noderivs noncommercial 1","attribution noderivs noncommercial 1 0","noderivs noncommercial 1 0 creative"]},{"licenseTexts":["Creative Commons Attribution-NonCommercial-NoDerivs 2.0 CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE LEGAL SERVICES. DISTRIBUTION OF THIS LICENSE DOES NOT CREATE AN ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS INFORMATION ON AN \"AS-IS\" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES REGARDING THE INFORMATION PROVIDED, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM ITS USE.\n\nLicense\n\nTHE WORK (AS DEFINED BELOW) IS PROVIDED UNDER THE TERMS OF THIS CREATIVE COMMONS PUBLIC LICENSE (\"CCPL\" OR \"LICENSE\"). THE WORK IS PROTECTED BY COPYRIGHT AND/OR OTHER APPLICABLE LAW. ANY USE OF THE WORK OTHER THAN AS AUTHORIZED UNDER THIS LICENSE OR COPYRIGHT LAW IS PROHIBITED.\n\nBY EXERCISING ANY RIGHTS TO THE WORK PROVIDED HERE, YOU ACCEPT AND AGREE TO BE BOUND BY THE TERMS OF THIS LICENSE. THE LICENSOR GRANTS YOU THE RIGHTS CONTAINED HERE IN CONSIDERATION OF YOUR ACCEPTANCE OF SUCH TERMS AND CONDITIONS.\n\n   1. Definitions\n\n      a. \"Collective Work\" means a work, such as a periodical issue, anthology or encyclopedia, in which the Work in its entirety in unmodified form, along with a number of other contributions, constituting separate and independent works in themselves, are assembled into a collective whole. A work that constitutes a Collective Work will not be considered a Derivative Work (as defined below) for the purposes of this License.\n\n      b. \"Derivative Work\" means a work based upon the Work or upon the Work and other pre-existing works, such as a translation, musical arrangement, dramatization, fictionalization, motion picture version, sound recording, art reproduction, abridgment, condensation, or any other form in which the Work may be recast, transformed, or adapted, except that a work that constitutes a Collective Work will not be considered a Derivative Work for the purpose of this License. For the avoidance of doubt, where the Work is a musical composition or sound recording, the synchronization of the Work in timed-relation with a moving image (\"synching\") will be considered a Derivative Work for the purpose of this License.\n\n      c. \"Licensor\" means the individual or entity that offers the Work under the terms of this License.\n\n      d. \"Original Author\" means the individual or entity who created the Work.\n\n      e. \"Work\" means the copyrightable work of authorship offered under the terms of this License.\n\n      f. \"You\" means an individual or entity exercising rights under this License who has not previously violated the terms of this License with respect to the Work, or who has received express permission from the Licensor to exercise rights under this License despite a previous violation.\n\n   2. Fair Use Rights. Nothing in this license is intended to reduce, limit, or restrict any rights arising from fair use, first sale or other limitations on the exclusive rights of the copyright owner under copyright law or other applicable laws.\n\n   3. License Grant. Subject to the terms and conditions of this License, Licensor hereby grants You a worldwide, royalty-free, non-exclusive, perpetual (for the duration of the applicable copyright) license to exercise the rights in the Work as stated below:\n\n      a. to reproduce the Work, to incorporate the Work into one or more Collective Works, and to reproduce the Work as incorporated in the Collective Works;\n\n      b. to distribute copies or phonorecords of, display publicly, perform publicly, and perform publicly by means of a digital audio transmission the Work including as incorporated in Collective Works;\n\n   The above rights may be exercised in all media and formats whether now known or hereafter devised. The above rights include the right to make such modifications as are technically necessary to exercise the rights in other media and formats, but otherwise you have no rights to make Derivative Works. All rights not expressly granted by Licensor are hereby reserved, including but not limited to the rights set forth in Sections 4(d) and 4(e).\n\n   4. Restrictions.The license granted in Section 3 above is expressly made subject to and limited by the following restrictions:\n\n      a. You may distribute, publicly display, publicly perform, or publicly digitally perform the Work only under the terms of this License, and You must include a copy of, or the Uniform Resource Identifier for, this License with every copy or phonorecord of the Work You distribute, publicly display, publicly perform, or publicly digitally perform. You may not offer or impose any terms on the Work that alter or restrict the terms of this License or the recipients' exercise of the rights granted hereunder. You may not sublicense the Work. You must keep intact all notices that refer to this License and to the disclaimer of warranties. You may not distribute, publicly display, publicly perform, or publicly digitally perform the Work with any technological measures that control access or use of the Work in a manner inconsistent with the terms of this License Agreement. The above applies to the Work as incorporated in a Collective Work, but this does not require the Collective Work apart from the Work itself to be made subject to the terms of this License. If You create a Collective Work, upon notice from any Licensor You must, to the extent practicable, remove from the Collective Work any reference to such Licensor or the Original Author, as requested.\n\n      b. You may not exercise any of the rights granted to You in Section 3 above in any manner that is primarily intended for or directed toward commercial advantage or private monetary compensation. The exchange of the Work for other copyrighted works by means of digital file-sharing or otherwise shall not be considered to be intended for or directed toward commercial advantage or private monetary compensation, provided there is no payment of any monetary compensation in connection with the exchange of copyrighted works.\n\n      c. If you distribute, publicly display, publicly perform, or publicly digitally perform the Work, You must keep intact all copyright notices for the Work and give the Original Author credit reasonable to the medium or means You are utilizing by conveying the name (or pseudonym if applicable) of the Original Author if supplied; the title of the Work if supplied; and to the extent reasonably practicable, the Uniform Resource Identifier, if any, that Licensor specifies to be associated with the Work, unless such URI does not refer to the copyright notice or licensing information for the Work. Such credit may be implemented in any reasonable manner; provided, however, that in the case of a Collective Work, at a minimum such credit will appear where any other comparable authorship credit appears and in a manner at least as prominent as such other comparable authorship credit.\n\n      d. For the avoidance of doubt, where the Work is a musical composition:\n\n         i. Performancf Royalties Under Blanket Licenses. Licensor reserves the exclusive right to collect, whether individually or via a performance rights society (e.g. ASCAP, BMI, SESAC), royalties for the public performance or public digital performance (e.g. webcast) of the Work if that performance is primarily intended for or directed toward commercial advantage or private monetary compensation.\n\n         ii. Mechanical Rights and Statutory Royalties. Licensor reserves the exclusive right to collect, whether individually or via a music rights agency or designated agent (e.g. Harry Fox Agency), royalties for any phonorecord You create from the Work (\"cover version\") and distribute, subject to the compulsory license created by 17 USC Section 115 of the US Copyright Act (or the equivalent in other jurisdictions), if Your distribution of such cover version is primarily intended for or directed toward commercial advantage or private monetary compensation.\n\n      e. Webcasting Rights and Statutory Royalties. For the avoidance of doubt, where the Work is a sound recording, Licensor reserves the exclusive right to collect, whether individually or via a performance-rights society (e.g. SoundExchange), royalties for the public digital performance (e.g. webcast) of the Work, subject to the compulsory license created by 17 USC Section 114 of the US Copyright Act (or the equivalent in other jurisdictions), if Your public digital performance is primarily intended for or directed toward commercial advantage or private monetary compensation.\n\n   5. Representations, Warranties and Disclaimer\n\n   UNLESS OTHERWISE MUTUALLY AGREED BY THE PARTIES IN WRITING, LICENSOR OFFERS THE WORK AS-IS AND MAKES NO REPRESENTATIONS OR WARRANTIES OF ANY KIND CONCERNING THE WORK, EXPRESS, IMPLIED, STATUTORY OR OTHERWISE, INCLUDING, WITHOUT LIMITATION, WARRANTIES OF TITLE, MERCHANTIBILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT, OR THE ABSENCE OF LATENT OR OTHER DEFECTS, ACCURACY, OR THE PRESENCE OF ABSENCE OF ERRORS, WHETHER OR NOT DISCOVERABLE. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OF IMPLIED WARRANTIES, SO SUCH EXCLUSION MAY NOT APPLY TO YOU.\n\n   6. Limitation on Liability. EXCEPT TO THE EXTENT REQUIRED BY APPLICABLE LAW, IN NO EVENT WILL LICENSOR BE LIABLE TO YOU ON ANY LEGAL THEORY FOR ANY SPECIAL, INCIDENTAL, CONSEQUENTIAL, PUNITIVE OR EXEMPLARY DAMAGES ARISING OUT OF THIS LICENSE OR THE USE OF THE WORK, EVEN IF LICENSOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\n   7. Termination\n\n      a. This License and the rights granted hereunder will terminate automatically upon any breach by You of the terms of this License. Individuals or entities who have received Collective Works from You under this License, however, will not have their licenses terminated provided such individuals or entities remain in full compliance with those licenses. Sections 1, 2, 5, 6, 7, and 8 will survive any termination of this License.\n\n      b. Subject to the above terms and conditions, the license granted here is perpetual (for the duration of the applicable copyright in the Work). Notwithstanding the above, Licensor reserves the right to release the Work under different license terms or to stop distributing the Work at any time; provided, however that any such election will not serve to withdraw this License (or any other license that has been, or is required to be, granted under the terms of this License), and this License will continue in full force and effect unless terminated as stated above.\n\n   8. Miscellaneous\n\n      a. Each time You distribute or publicly digitally perform the Work or a Collective Work, the Licensor offers to the recipient a license to the Work on the same terms and conditions as the license granted to You under this License.\n\n      b. If any provision of this License is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this License, and without further action by the parties to this agreement, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.\n\n      c. No term or provision of this License shall be deemed waived and no breach consented to unless such waiver or consent shall be in writing and signed by the party to be charged with such waiver or consent.\n\n      d. This License constitutes the entire agreement between the parties with respect to the Work licensed here. There are no understandings, agreements or representations with respect to the Work not specified here. Licensor shall not be bound by any additional provisions that may appear in any communication from You. This License may not be modified without the mutual written agreement of the Licensor and You.\n\nCreative Commons is not a party to this License, and makes no warranty whatsoever in connection with the Work. Creative Commons will not be liable to You or any party on any legal theory for any damages whatsoever, including without limitation any general, special, incidental or consequential damages arising in connection to this license. Notwithstanding the foregoing two (2) sentences, if Creative Commons has expressly identified itself as the Licensor hereunder, it shall have all rights and obligations of Licensor.\n\nExcept for the limited purpose of indicating to the public that the Work is licensed under the CCPL, neither party will use the trademark \"Creative Commons\" or any related trademark or logo of Creative Commons without the prior written consent of Creative Commons. Any permitted use will be in compliance with Creative Commons' then-current trademark usage guidelines, as may be published on its website or otherwise made available upon request from time to time.\n\nCreative Commons may be contacted at http://creativecommons.org/."],"licenseIds":["CC-BY-NC-ND-2.0"],"keywords":["composition i performancf","i performancf royalties","performancf royalties under","noncommercial noderivs 2 0","musical composition i performancf","composition i performancf royalties","i performancf royalties under","performancf royalties under blanket","attribution noncommercial noderivs 2 0","noncommercial noderivs 2 0 creative","a musical composition i performancf","musical composition i performancf royalties","composition i performancf royalties under","i performancf royalties under blanket","performancf royalties under blanket licenses"]},{"licenseTexts":["Creative Commons Attribution-NonCommercial-NoDerivs 2.5 CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE LEGAL SERVICES. DISTRIBUTION OF THIS LICENSE DOES NOT CREATE AN ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS INFORMATION ON AN \"AS-IS\" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES REGARDING THE INFORMATION PROVIDED, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM ITS USE.\n\nLicense\n\nTHE WORK (AS DEFINED BELOW) IS PROVIDED UNDER THE TERMS OF THIS CREATIVE COMMONS PUBLIC LICENSE (\"CCPL\" OR \"LICENSE\"). THE WORK IS PROTECTED BY COPYRIGHT AND/OR OTHER APPLICABLE LAW. ANY USE OF THE WORK OTHER THAN AS AUTHORIZED UNDER THIS LICENSE OR COPYRIGHT LAW IS PROHIBITED.\n\nBY EXERCISING ANY RIGHTS TO THE WORK PROVIDED HERE, YOU ACCEPT AND AGREE TO BE BOUND BY THE TERMS OF THIS LICENSE. THE LICENSOR GRANTS YOU THE RIGHTS CONTAINED HERE IN CONSIDERATION OF YOUR ACCEPTANCE OF SUCH TERMS AND CONDITIONS.\n\n   1. Definitions\n\n      a. \"Collective Work\" means a work, such as a periodical issue, anthology or encyclopedia, in which the Work in its entirety in unmodified form, along with a number of other contributions, constituting separate and independent works in themselves, are assembled into a collective whole. A work that constitutes a Collective Work will not be considered a Derivative Work (as defined below) for the purposes of this License.\n\n      b. \"Derivative Work\" means a work based upon the Work or upon the Work and other pre-existing works, such as a translation, musical arrangement, dramatization, fictionalization, motion picture version, sound recording, art reproduction, abridgment, condensation, or any other form in which the Work may be recast, transformed, or adapted, except that a work that constitutes a Collective Work will not be considered a Derivative Work for the purpose of this License. For the avoidance of doubt, where the Work is a musical composition or sound recording, the synchronization of the Work in timed-relation with a moving image (\"synching\") will be considered a Derivative Work for the purpose of this License.\n\n      c. \"Licensor\" means the individual or entity that offers the Work under the terms of this License.\n\n      d. \"Original Author\" means the individual or entity who created the Work.\n\n      e. \"Work\" means the copyrightable work of authorship offered under the terms of this License.\n\n      f. \"You\" means an individual or entity exercising rights under this License who has not previously violated the terms of this License with respect to the Work, or who has received express permission from the Licensor to exercise rights under this License despite a previous violation.\n\n   2. Fair Use Rights. Nothing in this license is intended to reduce, limit, or restrict any rights arising from fair use, first sale or other limitations on the exclusive rights of the copyright owner under copyright law or other applicable laws.\n\n   3. License Grant. Subject to the terms and conditions of this License, Licensor hereby grants You a worldwide, royalty-free, non-exclusive, perpetual (for the duration of the applicable copyright) license to exercise the rights in the Work as stated below:\n\n      a. to reproduce the Work, to incorporate the Work into one or more Collective Works, and to reproduce the Work as incorporated in the Collective Works;\n\n      b. to distribute copies or phonorecords of, display publicly, perform publicly, and perform publicly by means of a digital audio transmission the Work including as incorporated in Collective Works;\n\n   The above rights may be exercised in all media and formats whether now known or hereafter devised. The above rights include the right to make such modifications as are technically necessary to exercise the rights in other media and formats, but otherwise you have no rights to make Derivative Works. All rights not expressly granted by Licensor are hereby reserved, including but not limited to the rights set forth in Sections 4(d) and 4(e).\n\n   4. Restrictions.The license granted in Section 3 above is expressly made subject to and limited by the following restrictions:\n\n      a. You may distribute, publicly display, publicly perform, or publicly digitally perform the Work only under the terms of this License, and You must include a copy of, or the Uniform Resource Identifier for, this License with every copy or phonorecord of the Work You distribute, publicly display, publicly perform, or publicly digitally perform. You may not offer or impose any terms on the Work that alter or restrict the terms of this License or the recipients' exercise of the rights granted hereunder. You may not sublicense the Work. You must keep intact all notices that refer to this License and to the disclaimer of warranties. You may not distribute, publicly display, publicly perform, or publicly digitally perform the Work with any technological measures that control access or use of the Work in a manner inconsistent with the terms of this License Agreement. The above applies to the Work as incorporated in a Collective Work, but this does not require the Collective Work apart from the Work itself to be made subject to the terms of this License. If You create a Collective Work, upon notice from any Licensor You must, to the extent practicable, remove from the Collective Work any credit as required by clause 4(c), as requested.\n\n      b. You may not exercise any of the rights granted to You in Section 3 above in any manner that is primarily intended for or directed toward commercial advantage or private monetary compensation. The exchange of the Work for other copyrighted works by means of digital file-sharing or otherwise shall not be considered to be intended for or directed toward commercial advantage or private monetary compensation, provided there is no payment of any monetary compensation in connection with the exchange of copyrighted works.\n\n      c. If you distribute, publicly display, publicly perform, or publicly digitally perform the Work, You must keep intact all copyright notices for the Work and provide, reasonable to the medium or means You are utilizing: (i) the name of the Original Author (or pseudonym, if applicable) if supplied, and/or (ii) if the Original Author and/or Licensor designate another party or parties (e.g. a sponsor institute, publishing entity, journal) for attribution in Licensor's copyright notice, terms of service or by other reasonable means, the name of such party or parties; the title of the Work if supplied; and to the extent reasonably practicable, the Uniform Resource Identifier, if any, that Licensor specifies to be associated with the Work, unless such URI does not refer to the copyright notice or licensing information for the Work. Such credit may be implemented in any reasonable manner; provided, however, that in the case of a Collective Work, at a minimum such credit will appear where any other comparable authorship credit appears and in a manner at least as prominent as such other comparable authorship credit.\n\n      d. For the avoidance of doubt, where the Work is a musical composition:\n\n         i. Performance Royalties Under Blanket Licenses. Licensor reserves the exclusive right to collect, whether individually or via a performance rights society (e.g. ASCAP, BMI, SESAC), royalties for the public performance or public digital performance (e.g. webcast) of the Work if that performance is primarily intended for or directed toward commercial advantage or private monetary compensation.\n\n         ii. Mechanical Rights and Statutory Royalties. Licensor reserves the exclusive right to collect, whether individually or via a music rights agency or designated agent (e.g. Harry Fox Agency), royalties for any phonorecord You create from the Work (\"cover version\") and distribute, subject to the compulsory license created by 17 USC Section 115 of the US Copyright Act (or the equivalent in other jurisdictions), if Your distribution of such cover version is primarily intended for or directed toward commercial advantage or private monetary compensation.\n\n      e. Webcasting Rights and Statutory Royalties. For the avoidance of doubt, where the Work is a sound recording, Licensor reserves the exclusive right to collect, whether individually or via a performance-rights society (e.g. SoundExchange), royalties for the public digital performance (e.g. webcast) of the Work, subject to the compulsory license created by 17 USC Section 114 of the US Copyright Act (or the equivalent in other jurisdictions), if Your public digital performance is primarily intended for or directed toward commercial advantage or private monetary compensation.\n\n   5. Representations, Warranties and Disclaimer\n\n   UNLESS OTHERWISE MUTUALLY AGREED BY THE PARTIES IN WRITING, LICENSOR OFFERS THE WORK AS-IS AND MAKES NO REPRESENTATIONS OR WARRANTIES OF ANY KIND CONCERNING THE WORK, EXPRESS, IMPLIED, STATUTORY OR OTHERWISE, INCLUDING, WITHOUT LIMITATION, WARRANTIES OF TITLE, MERCHANTIBILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT, OR THE ABSENCE OF LATENT OR OTHER DEFECTS, ACCURACY, OR THE PRESENCE OF ABSENCE OF ERRORS, WHETHER OR NOT DISCOVERABLE. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OF IMPLIED WARRANTIES, SO SUCH EXCLUSION MAY NOT APPLY TO YOU.\n\n   6. Limitation on Liability. EXCEPT TO THE EXTENT REQUIRED BY APPLICABLE LAW, IN NO EVENT WILL LICENSOR BE LIABLE TO YOU ON ANY LEGAL THEORY FOR ANY SPECIAL, INCIDENTAL, CONSEQUENTIAL, PUNITIVE OR EXEMPLARY DAMAGES ARISING OUT OF THIS LICENSE OR THE USE OF THE WORK, EVEN IF LICENSOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\n   7. Termination\n\n      a. This License and the rights granted hereunder will terminate automatically upon any breach by You of the terms of this License. Individuals or entities who have received Collective Works from You under this License, however, will not have their licenses terminated provided such individuals or entities remain in full compliance with those licenses. Sections 1, 2, 5, 6, 7, and 8 will survive any termination of this License.\n\n      b. Subject to the above terms and conditions, the license granted here is perpetual (for the duration of the applicable copyright in the Work). Notwithstanding the above, Licensor reserves the right to release the Work under different license terms or to stop distributing the Work at any time; provided, however that any such election will not serve to withdraw this License (or any other license that has been, or is required to be, granted under the terms of this License), and this License will continue in full force and effect unless terminated as stated above.\n\n   8. Miscellaneous\n\n      a. Each time You distribute or publicly digitally perform the Work or a Collective Work, the Licensor offers to the recipient a license to the Work on the same terms and conditions as the license granted to You under this License.\n\n      b. If any provision of this License is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this License, and without further action by the parties to this agreement, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.\n\n      c. No term or provision of this License shall be deemed waived and no breach consented to unless such waiver or consent shall be in writing and signed by the party to be charged with such waiver or consent.\n\n      d. This License constitutes the entire agreement between the parties with respect to the Work licensed here. There are no understandings, agreements or representations with respect to the Work not specified here. Licensor shall not be bound by any additional provisions that may appear in any communication from You. This License may not be modified without the mutual written agreement of the Licensor and You.\n\nCreative Commons is not a party to this License, and makes no warranty whatsoever in connection with the Work. Creative Commons will not be liable to You or any party on any legal theory for any damages whatsoever, including without limitation any general, special, incidental or consequential damages arising in connection to this license. Notwithstanding the foregoing two (2) sentences, if Creative Commons has expressly identified itself as the Licensor hereunder, it shall have all rights and obligations of Licensor.\n\nExcept for the limited purpose of indicating to the public that the Work is licensed under the CCPL, neither party will use the trademark \"Creative Commons\" or any related trademark or logo of Creative Commons without the prior written consent of Creative Commons. Any permitted use will be in compliance with Creative Commons' then-current trademark usage guidelines, as may be published on its website or otherwise made available upon request from time to time.\n\nCreative Commons may be contacted at http://creativecommons.org/."],"licenseIds":["CC-BY-NC-ND-2.5"],"keywords":["noncommercial noderivs 2 5","attribution noncommercial noderivs 2 5","noncommercial noderivs 2 5 creative"]},{"licenseTexts":["Creative Commons Attribution-NonCommercial-NoDerivs 3.0 Unported CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE LEGAL SERVICES. DISTRIBUTION OF THIS LICENSE DOES NOT CREATE AN ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS INFORMATION ON AN \"AS-IS\" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES REGARDING THE INFORMATION PROVIDED, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM ITS USE.\n\nLicense\n\nTHE WORK (AS DEFINED BELOW) IS PROVIDED UNDER THE TERMS OF THIS CREATIVE COMMONS PUBLIC LICENSE (\"CCPL\" OR \"LICENSE\"). THE WORK IS PROTECTED BY COPYRIGHT AND/OR OTHER APPLICABLE LAW. ANY USE OF THE WORK OTHER THAN AS AUTHORIZED UNDER THIS LICENSE OR COPYRIGHT LAW IS PROHIBITED.\n\nBY EXERCISING ANY RIGHTS TO THE WORK PROVIDED HERE, YOU ACCEPT AND AGREE TO BE BOUND BY THE TERMS OF THIS LICENSE. TO THE EXTENT THIS LICENSE MAY BE CONSIDERED TO BE A CONTRACT, THE LICENSOR GRANTS YOU THE RIGHTS CONTAINED HERE IN CONSIDERATION OF YOUR ACCEPTANCE OF SUCH TERMS AND CONDITIONS.\n\n   1. Definitions\n\n      a. \"Adaptation\" means a work based upon the Work, or upon the Work and other pre-existing works, such as a translation, adaptation, derivative work, arrangement of music or other alterations of a literary or artistic work, or phonogram or performance and includes cinematographic adaptations or any other form in which the Work may be recast, transformed, or adapted including in any form recognizably derived from the original, except that a work that constitutes a Collection will not be considered an Adaptation for the purpose of this License. For the avoidance of doubt, where the Work is a musical work, performance or phonogram, the synchronization of the Work in timed-relation with a moving image (\"synching\") will be considered an Adaptation for the purpose of this License.\n\n      b. \"Collection\" means a collection of literary or artistic works, such as encyclopedias and anthologies, or performances, phonograms or broadcasts, or other works or subject matter other than works listed in Section 1(f) below, which, by reason of the selection and arrangement of their contents, constitute intellectual creations, in which the Work is included in its entirety in unmodified form along with one or more other contributions, each constituting separate and independent works in themselves, which together are assembled into a collective whole. A work that constitutes a Collection will not be considered an Adaptation (as defined above) for the purposes of this License.\n\n      c. \"Distribute\" means to make available to the public the original and copies of the Work through sale or other transfer of ownership.\n\n      d. \"Licensor\" means the individual, individuals, entity or entities that offer(s) the Work under the terms of this License.\n\n      e. \"Original Author\" means, in the case of a literary or artistic work, the individual, individuals, entity or entities who created the Work or if no individual or entity can be identified, the publisher; and in addition (i) in the case of a performance the actors, singers, musicians, dancers, and other persons who act, sing, deliver, declaim, play in, interpret or otherwise perform literary or artistic works or expressions of folklore; (ii) in the case of a phonogram the producer being the person or legal entity who first fixes the sounds of a performance or other sounds; and, (iii) in the case of broadcasts, the organization that transmits the broadcast.\n\n      f. \"Work\" means the literary and/or artistic work offered under the terms of this License including without limitation any production in the literary, scientific and artistic domain, whatever may be the mode or form of its expression including digital form, such as a book, pamphlet and other writing; a lecture, address, sermon or other work of the same nature; a dramatic or dramatico-musical work; a choreographic work or entertainment in dumb show; a musical composition with or without words; a cinematographic work to which are assimilated works expressed by a process analogous to cinematography; a work of drawing, painting, architecture, sculpture, engraving or lithography; a photographic work to which are assimilated works expressed by a process analogous to photography; a work of applied art; an illustration, map, plan, sketch or three-dimensional work relative to geography, topography, architecture or science; a performance; a broadcast; a phonogram; a compilation of data to the extent it is protected as a copyrightable work; or a work performed by a variety or circus performer to the extent it is not otherwise considered a literary or artistic work.\n\n      g. \"You\" means an individual or entity exercising rights under this License who has not previously violated the terms of this License with respect to the Work, or who has received express permission from the Licensor to exercise rights under this License despite a previous violation.\n\n      h. \"Publicly Perform\" means to perform public recitations of the Work and to communicate to the public those public recitations, by any means or process, including by wire or wireless means or public digital performances; to make available to the public Works in such a way that members of the public may access these Works from a place and at a place individually chosen by them; to perform the Work to the public by any means or process and the communication to the public of the performances of the Work, including by public digital performance; to broadcast and rebroadcast the Work by any means including signs, sounds or images.\n\n      i. \"Reproduce\" means to make copies of the Work by any means including without limitation by sound or visual recordings and the right of fixation and reproducing fixations of the Work, including storage of a protected performance or phonogram in digital form or other electronic medium.\n\n   2. Fair Dealing Rights. Nothing in this License is intended to reduce, limit, or restrict any uses free from copyright or rights arising from limitations or exceptions that are provided for in connection with the copyright protection under copyright law or other applicable laws.\n\n   3. License Grant. Subject to the terms and conditions of this License, Licensor hereby grants You a worldwide, royalty-free, non-exclusive, perpetual (for the duration of the applicable copyright) license to exercise the rights in the Work as stated below:\n\n      a. to Reproduce the Work, to incorporate the Work into one or more Collections, and to Reproduce the Work as incorporated in the Collections; and,\n\n      b. to Distribute and Publicly Perform the Work including as incorporated in Collections.\n\n   The above rights may be exercised in all media and formats whether now known or hereafter devised. The above rights include the right to make such modifications as are technically necessary to exercise the rights in other media and formats, but otherwise you have no rights to make Adaptations. Subject to 8(f), all rights not expressly granted by Licensor are hereby reserved, including but not limited to the rights set forth in Section 4(d).\n\n   4. Restrictions. The license granted in Section 3 above is expressly made subject to and limited by the following restrictions:\n\n      a. You may Distribute or Publicly Perform the Work only under the terms of this License. You must include a copy of, or the Uniform Resource Identifier (URI) for, this License with every copy of the Work You Distribute or Publicly Perform. You may not offer or impose any terms on the Work that restrict the terms of this License or the ability of the recipient of the Work to exercise the rights granted to that recipient under the terms of the License. You may not sublicense the Work. You must keep intact all notices that refer to this License and to the disclaimer of warranties with every copy of the Work You Distribute or Publicly Perform. When You Distribute or Publicly Perform the Work, You may not impose any effective technological measures on the Work that restrict the ability of a recipient of the Work from You to exercise the rights granted to that recipient under the terms of the License. This Section 4(a) applies to the Work as incorporated in a Collection, but this does not require the Collection apart from the Work itself to be made subject to the terms of this License. If You create a Collection, upon notice from any Licensor You must, to the extent practicable, remove from the Collection any credit as required by Section 4(c), as requested.\n\n      b. You may not exercise any of the rights granted to You in Section 3 above in any manner that is primarily intended for or directed toward commercial advantage or private monetary compensation. The exchange of the Work for other copyrighted works by means of digital file-sharing or otherwise shall not be considered to be intended for or directed toward commercial advantage or private monetary compensation, provided there is no payment of any monetary compensation in connection with the exchange of copyrighted works.\n\n      c. If You Distribute, or Publicly Perform the Work or Collections, You must, unless a request has been made pursuant to Section 4(a), keep intact all copyright notices for the Work and provide, reasonable to the medium or means You are utilizing: (i) the name of the Original Author (or pseudonym, if applicable) if supplied, and/or if the Original Author and/or Licensor designate another party or parties (e.g., a sponsor institute, publishing entity, journal) for attribution (\"Attribution Parties\") in Licensor's copyright notice, terms of service or by other reasonable means, the name of such party or parties; (ii) the title of the Work if supplied; (iii) to the extent reasonably practicable, the URI, if any, that Licensor specifies to be associated with the Work, unless such URI does not refer to the copyright notice or licensing information for the Work. The credit required by this Section 4(c) may be implemented in any reasonable manner; provided, however, that in the case of a Collection, at a minimum such credit will appear, if a credit for all contributing authors of Collection appears, then as part of these credits and in a manner at least as prominent as the credits for the other contributing authors. For the avoidance of doubt, You may only use the credit required by this Section for the purpose of attribution in the manner set out above and, by exercising Your rights under this License, You may not implicitly or explicitly assert or imply any connection with, sponsorship or endorsement by the Original Author, Licensor and/or Attribution Parties, as appropriate, of You or Your use of the Work, without the separate, express prior written permission of the Original Author, Licensor and/or Attribution Parties.\n\n      d. For the avoidance of doubt:\n\n         i. Non-waivable Compulsory License Schemes. In those jurisdictions in which the right to collect royalties through any statutory or compulsory licensing scheme cannot be waived, the Licensor reserves the exclusive right to collect such royalties for any exercise by You of the rights granted under this License;\n\n         ii. Waivable Compulsory License Schemes. In those jurisdictions in which the right to collect royalties through any statutory or compulsory licensing scheme can be waived, the Licensor reserves the exclusive right to collect such royalties for any exercise by You of the rights granted under this License if Your exercise of such rights is for a purpose or use which is otherwise than noncommercial as permitted under Section 4(b) and otherwise waives the right to collect royalties through any statutory or compulsory licensing scheme; and,\n\n         iii. Voluntary License Schemes. The Licensor reserves the right to collect royalties, whether individually or, in the event that the Licensor is a member of a collecting society that administers voluntary licensing schemes, via that society, from any exercise by You of the rights granted under this License that is for a purpose or use which is otherwise than noncommercial as permitted under Section 4(b).\n\n      e. Except as otherwise agreed in writing by the Licensor or as may be otherwise permitted by applicable law, if You Reproduce, Distribute or Publicly Perform the Work either by itself or as part of any Collections, You must not distort, mutilate, modify or take other derogatory action in relation to the Work which would be prejudicial to the Original Author's honor or reputation.\n\n   5. Representations, Warranties and Disclaimer\n\n   UNLESS OTHERWISE MUTUALLY AGREED BY THE PARTIES IN WRITING, LICENSOR OFFERS THE WORK AS-IS AND MAKES NO REPRESENTATIONS OR WARRANTIES OF ANY KIND CONCERNING THE WORK, EXPRESS, IMPLIED, STATUTORY OR OTHERWISE, INCLUDING, WITHOUT LIMITATION, WARRANTIES OF TITLE, MERCHANTIBILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT, OR THE ABSENCE OF LATENT OR OTHER DEFECTS, ACCURACY, OR THE PRESENCE OF ABSENCE OF ERRORS, WHETHER OR NOT DISCOVERABLE. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OF IMPLIED WARRANTIES, SO SUCH EXCLUSION MAY NOT APPLY TO YOU.\n\n   6. Limitation on Liability. EXCEPT TO THE EXTENT REQUIRED BY APPLICABLE LAW, IN NO EVENT WILL LICENSOR BE LIABLE TO YOU ON ANY LEGAL THEORY FOR ANY SPECIAL, INCIDENTAL, CONSEQUENTIAL, PUNITIVE OR EXEMPLARY DAMAGES ARISING OUT OF THIS LICENSE OR THE USE OF THE WORK, EVEN IF LICENSOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\n   7. Termination\n\n      a. This License and the rights granted hereunder will terminate automatically upon any breach by You of the terms of this License. Individuals or entities who have received Collections from You under this License, however, will not have their licenses terminated provided such individuals or entities remain in full compliance with those licenses. Sections 1, 2, 5, 6, 7, and 8 will survive any termination of this License.\n\n      b. Subject to the above terms and conditions, the license granted here is perpetual (for the duration of the applicable copyright in the Work). Notwithstanding the above, Licensor reserves the right to release the Work under different license terms or to stop distributing the Work at any time; provided, however that any such election will not serve to withdraw this License (or any other license that has been, or is required to be, granted under the terms of this License), and this License will continue in full force and effect unless terminated as stated above.\n\n   8. Miscellaneous\n\n      a. Each time You Distribute or Publicly Perform the Work or a Collection, the Licensor offers to the recipient a license to the Work on the same terms and conditions as the license granted to You under this License.\n\n      b. If any provision of this License is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this License, and without further action by the parties to this agreement, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.\n\n      c. No term or provision of this License shall be deemed waived and no breach consented to unless such waiver or consent shall be in writing and signed by the party to be charged with such waiver or consent.\n\n      d. This License constitutes the entire agreement between the parties with respect to the Work licensed here. There are no understandings, agreements or representations with respect to the Work not specified here. Licensor shall not be bound by any additional provisions that may appear in any communication from You. This License may not be modified without the mutual written agreement of the Licensor and You.\n\n      e. The rights granted under, and the subject matter referenced, in this License were drafted utilizing the terminology of the Berne Convention for the Protection of Literary and Artistic Works (as amended on September 28, 1979), the Rome Convention of 1961, the WIPO Copyright Treaty of 1996, the WIPO Performances and Phonograms Treaty of 1996 and the Universal Copyright Convention (as revised on July 24, 1971). These rights and subject matter take effect in the relevant jurisdiction in which the License terms are sought to be enforced according to the corresponding provisions of the implementation of those treaty provisions in the applicable national law. If the standard suite of rights granted under applicable copyright law includes additional rights not granted under this License, such additional rights are deemed to be included in the License; this License is not intended to restrict the license of any rights under applicable law.\n\nCreative Commons Notice\n\nCreative Commons is not a party to this License, and makes no warranty whatsoever in connection with the Work. Creative Commons will not be liable to You or any party on any legal theory for any damages whatsoever, including without limitation any general, special, incidental or consequential damages arising in connection to this license. Notwithstanding the foregoing two (2) sentences, if Creative Commons has expressly identified itself as the Licensor hereunder, it shall have all rights and obligations of Licensor.\n\nExcept for the limited purpose of indicating to the public that the Work is licensed under the CCPL, Creative Commons does not authorize the use by either party of the trademark \"Creative Commons\" or any related trademark or logo of Creative Commons without the prior written consent of Creative Commons. Any permitted use will be in compliance with Creative Commons' then-current trademark usage guidelines, as may be published on its website or otherwise made available upon request from time to time. For the avoidance of doubt, this trademark restriction does not form part of this License.\n\nCreative Commons may be contacted at http://creativecommons.org/."],"licenseIds":["CC-BY-NC-ND-3.0"],"keywords":["noncommercial noderivs 3","in collections the","collections the above","subject to 8","to 8 f","authors of collection","of collection appears","4 b e","b e except","attribution noncommercial noderivs 3","noncommercial noderivs 3 0","incorporated in collections the","in collections the above","collections the above rights","adaptations subject to 8","subject to 8 f","to 8 f all","contributing authors of collection","authors of collection appears","of collection appears then","section 4 b e","4 b e except","b e except as","commons attribution noncommercial noderivs 3","attribution noncommercial noderivs 3 0","noncommercial noderivs 3 0 unported","as incorporated in collections the","incorporated in collections the above","in collections the above rights","collections the above rights may","make adaptations subject to 8","adaptations subject to 8 f","subject to 8 f all","to 8 f all rights","all contributing authors of collection","contributing authors of collection appears","authors of collection appears then","of collection appears then as","under section 4 b e","section 4 b e except","4 b e except as","b e except as otherwise"]},{"licenseTexts":["Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Creative Commons Corporation (\"Creative Commons\") is not a law firm and does not provide legal services or legal advice. Distribution of Creative Commons public licenses does not create a lawyer-client or other relationship. Creative Commons makes its licenses and related information available on an \"as-is\" basis. Creative Commons gives no warranties regarding its licenses, any material licensed under their terms and conditions, or any related information. Creative Commons disclaims all liability for damages resulting from their use to the fullest extent possible.\n\nUsing Creative Commons Public Licenses\n\nCreative Commons public licenses provide a standard set of terms and conditions that creators and other rights holders may use to share original works of authorship and other material subject to copyright and certain other rights specified in the public license below. The following considerations are for informational purposes only, are not exhaustive, and do not form part of our licenses.\n\nConsiderations for licensors: Our public licenses are intended for use by those authorized to give the public permission to use material in ways otherwise restricted by copyright and certain other rights. Our licenses are irrevocable. Licensors should read and understand the terms and conditions of the license they choose before applying it. Licensors should also secure all rights necessary before applying our licenses so that the public can reuse the material as expected. Licensors should clearly mark any material not subject to the license. This includes other CC-licensed material, or material used under an exception or limitation to copyright. More considerations for licensors : wiki.creativecommons.org/Considerations_for_licensors\n\nConsiderations for the public: By using one of our public licenses, a licensor grants the public permission to use the licensed material under specified terms and conditions. If the licensor's permission is not necessary for any reason–for example, because of any applicable exception or limitation to copyright–then that use is not regulated by the license. Our licenses grant only permissions under copyright and certain other rights that a licensor has authority to grant. Use of the licensed material may still be restricted for other reasons, including because others have copyright or other rights in the material. A licensor may make special requests, such as asking that all changes be marked or described. Although not required by our licenses, you are encouraged to respect those requests where reasonable. More considerations for the public : wiki.creativecommons.org/Considerations_for_licensees\n\nCreative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License\n\nBy exercising the Licensed Rights (defined below), You accept and agree to be bound by the terms and conditions of this Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License (\"Public License\"). To the extent this Public License may be interpreted as a contract, You are granted the Licensed Rights in consideration of Your acceptance of these terms and conditions, and the Licensor grants You such rights in consideration of benefits the Licensor receives from making the Licensed Material available under these terms and conditions.\n\n   \n\n   Section 1 – Definitions.\n\n      a. Adapted Material means material subject to Copyright and Similar Rights that is derived from or based upon the Licensed Material and in which the Licensed Material is translated, altered, arranged, transformed, or otherwise modified in a manner requiring permission under the Copyright and Similar Rights held by the Licensor. For purposes of this Public License, where the Licensed Material is a musical work, performance, or sound recording, Adapted Material is always produced where the Licensed Material is synched in timed relation with a moving image.\n\n      b. Copyright and Similar Rights means copyright and/or similar rights closely related to copyright including, without limitation, performance, broadcast, sound recording, and Sui Generis Database Rights, without regard to how the rights are labeled or categorized. For purposes of this Public License, the rights specified in Section 2(b)(1)-(2) are not Copyright and Similar Rights.\n\n      c. Effective Technological Measures means those measures that, in the absence of proper authority, may not be circumvented under laws fulfilling obligations under Article 11 of the WIPO Copyright Treaty adopted on December 20, 1996, and/or similar international agreements.\n\n      d. Exceptions and Limitations means fair use, fair dealing, and/or any other exception or limitation to Copyright and Similar Rights that applies to Your use of the Licensed Material.\n\n      e. Licensed Material means the artistic or literary work, database, or other material to which the Licensor applied this Public License.\n\n      f. Licensed Rights means the rights granted to You subject to the terms and conditions of this Public License, which are limited to all Copyright and Similar Rights that apply to Your use of the Licensed Material and that the Licensor has authority to license.\n\n      g. Licensor means the individual(s) or entity(ies) granting rights under this Public License.\n\n      h. NonCommercial means not primarily intended for or directed towards commercial advantage or monetary compensation. For purposes of this Public License, the exchange of the Licensed Material for other material subject to Copyright and Similar Rights by digital file-sharing or similar means is NonCommercial provided there is no payment of monetary compensation in connection with the exchange.\n\n      i. Share means to provide material to the public by any means or process that requires permission under the Licensed Rights, such as reproduction, public display, public performance, distribution, dissemination, communication, or importation, and to make material available to the public including in ways that members of the public may access the material from a place and at a time individually chosen by them.\n\n      j. Sui Generis Database Rights means rights other than copyright resulting from Directive 96/9/EC of the European Parliament and of the Council of 11 March 1996 on the legal protection of databases, as amended and/or succeeded, as well as other essentially equivalent rights anywhere in the world.\n\n      k. You means the individual or entity exercising the Licensed Rights under this Public License. Your has a corresponding meaning.\n\n   \n\n   Section 2 – Scope.\n\n      a. License grant.\n\n         1. Subject to the terms and conditions of this Public License, the Licensor hereby grants You a worldwide, royalty-free, non-sublicensable, non-exclusive, irrevocable license to exercise the Licensed Rights in the Licensed Material to:\n\n            A. reproduce and Share the Licensed Material, in whole or in part, for NonCommercial purposes only; and\n\n            B. produce and reproduce, but not Share, Adapted Material for NonCommercial purposes only.\n\n         2. Exceptions and Limitations. For the avoidance of doubt, where Exceptions and Limitations apply to Your use, this Public License does not apply, and You do not need to comply with its terms and conditions.\n\n         3. Term. The term of this Public License is specified in Section 6(a).\n\n         4. Media and formats; technical modifications allowed. The Licensor authorizes You to exercise the Licensed Rights in all media and formats whether now known or hereafter created, and to make technical modifications necessary to do so. The Licensor waives and/or agrees not to assert any right or authority to forbid You from making technical modifications necessary to exercise the Licensed Rights, including technical modifications necessary to circumvent Effective Technological Measures. For purposes of this Public License, simply making modifications authorized by this Section 2(a)(4) never produces Adapted Material.\n\n         5. Downstream recipients.\n\n            A. Offer from the Licensor – Licensed Material. Every recipient of the Licensed Material automatically receives an offer from the Licensor to exercise the Licensed Rights under the terms and conditions of this Public License.\n\n            B. No downstream restrictions. You may not offer or impose any additional or different terms or conditions on, or apply any Effective Technological Measures to, the Licensed Material if doing so restricts exercise of the Licensed Rights by any recipient of the Licensed Material.\n\n         6. No endorsement. Nothing in this Public License constitutes or may be construed as permission to assert or imply that You are, or that Your use of the Licensed Material is, connected with, or sponsored, endorsed, or granted official status by, the Licensor or others designated to receive attribution as provided in Section 3(a)(1)(A)(i).\n\n      b. Other rights.\n\n         1. Moral rights, such as the right of integrity, are not licensed under this Public License, nor are publicity, privacy, and/or other similar personality rights; however, to the extent possible, the Licensor waives and/or agrees not to assert any such rights held by the Licensor to the limited extent necessary to allow You to exercise the Licensed Rights, but not otherwise.\n\n         2. Patent and trademark rights are not licensed under this Public License.\n\n         3. To the extent possible, the Licensor waives any right to collect royalties from You for the exercise of the Licensed Rights, whether directly or through a collecting society under any voluntary or waivable statutory or compulsory licensing scheme. In all other cases the Licensor expressly reserves any right to collect such royalties, including when the Licensed Material is used other than for NonCommercial purposes.\n\n   \n\n   Section 3 – License Conditions.\n\n   Your exercise of the Licensed Rights is expressly made subject to the following conditions.\n\n      a. Attribution.\n\n         1. If You Share the Licensed Material, You must:\n\n            A. retain the following if it is supplied by the Licensor with the Licensed Material:\n\n               i. identification of the creator(s) of the Licensed Material and any others designated to receive attribution, in any reasonable manner requested by the Licensor (including by pseudonym if designated);\n\n               ii. a copyright notice;\n\n               iii. a notice that refers to this Public License;\n\n               iv. a notice that refers to the disclaimer of warranties;\n\n               v. a URI or hyperlink to the Licensed Material to the extent reasonably practicable;\n\n            B. indicate if You modified the Licensed Material and retain an indication of any previous modifications; and\n\n            C. indicate the Licensed Material is licensed under this Public License, and include the text of, or the URI or hyperlink to, this Public License.\n\n         For the avoidance of doubt, You do not have permission under this Public License to Share Adapted Material.\n\n         2. You may satisfy the conditions in Section 3(a)(1) in any reasonable manner based on the medium, means, and context in which You Share the Licensed Material. For example, it may be reasonable to satisfy the conditions by providing a URI or hyperlink to a resource that includes the required information.\n\n         3. If requested by the Licensor, You must remove any of the information required by Section 3(a)(1)(A) to the extent reasonably practicable.\n\n   \n\n   Section 4 – Sui Generis Database Rights.\n\n   Where the Licensed Rights include Sui Generis Database Rights that apply to Your use of the Licensed Material:\n\n      a. for the avoidance of doubt, Section 2(a)(1) grants You the right to extract, reuse, reproduce, and Share all or a substantial portion of the contents of the database for NonCommercial purposes only and provided You do not Share Adapted Material;\n\n      b. if You include all or a substantial portion of the database contents in a database in which You have Sui Generis Database Rights, then the database in which You have Sui Generis Database Rights (but not its individual contents) is Adapted Material; and\n\n      c. You must comply with the conditions in Section 3(a) if You Share all or a substantial portion of the contents of the database.\n\n   For the avoidance of doubt, this Section 4 supplements and does not replace Your obligations under this Public License where the Licensed Rights include other Copyright and Similar Rights.\n\n   \n\n   Section 5 – Disclaimer of Warranties and Limitation of Liability.\n\n      a. Unless otherwise separately undertaken by the Licensor, to the extent possible, the Licensor offers the Licensed Material as-is and as-available, and makes no representations or warranties of any kind concerning the Licensed Material, whether express, implied, statutory, or other. This includes, without limitation, warranties of title, merchantability, fitness for a particular purpose, non-infringement, absence of latent or other defects, accuracy, or the presence or absence of errors, whether or not known or discoverable. Where disclaimers of warranties are not allowed in full or in part, this disclaimer may not apply to You.\n\n      b. To the extent possible, in no event will the Licensor be liable to You on any legal theory (including, without limitation, negligence) or otherwise for any direct, special, indirect, incidental, consequential, punitive, exemplary, or other losses, costs, expenses, or damages arising out of this Public License or use of the Licensed Material, even if the Licensor has been advised of the possibility of such losses, costs, expenses, or damages. Where a limitation of liability is not allowed in full or in part, this limitation may not apply to You.\n\n      c. The disclaimer of warranties and limitation of liability provided above shall be interpreted in a manner that, to the extent possible, most closely approximates an absolute disclaimer and waiver of all liability.\n\n   \n\n   Section 6 – Term and Termination.\n\n      a. This Public License applies for the term of the Copyright and Similar Rights licensed here. However, if You fail to comply with this Public License, then Your rights under this Public License terminate automatically.\n\n      b. Where Your right to use the Licensed Material has terminated under Section 6(a), it reinstates:\n\n         1. automatically as of the date the violation is cured, provided it is cured within 30 days of Your discovery of the violation; or\n\n         2. upon express reinstatement by the Licensor.\n\n      For the avoidance of doubt, this Section 6(b) does not affect any right the Licensor may have to seek remedies for Your violations of this Public License.\n\n      c. For the avoidance of doubt, the Licensor may also offer the Licensed Material under separate terms or conditions or stop distributing the Licensed Material at any time; however, doing so will not terminate this Public License.\n\n      d. Sections 1, 5, 6, 7, and 8 survive termination of this Public License.\n\n   \n\n   Section 7 – Other Terms and Conditions.\n\n      a. The Licensor shall not be bound by any additional or different terms or conditions communicated by You unless expressly agreed.\n\n      b. Any arrangements, understandings, or agreements regarding the Licensed Material not stated herein are separate from and independent of the terms and conditions of this Public License.\n\n   \n\n   Section 8 – Interpretation.\n\n      a. For the avoidance of doubt, this Public License does not, and shall not be interpreted to, reduce, limit, restrict, or impose conditions on any use of the Licensed Material that could lawfully be made without permission under this Public License.\n\n      b. To the extent possible, if any provision of this Public License is deemed unenforceable, it shall be automatically reformed to the minimum extent necessary to make it enforceable. If the provision cannot be reformed, it shall be severed from this Public License without affecting the enforceability of the remaining terms and conditions.\n\n      c. No term or condition of this Public License will be waived and no failure to comply consented to unless expressly agreed to by the Licensor.\n\n      d. Nothing in this Public License constitutes or may be interpreted as a limitation upon, or waiver of, any privileges and immunities that apply to the Licensor or You, including from the legal processes of any jurisdiction or authority.\n\nCreative Commons is not a party to its public licenses. Notwithstanding, Creative Commons may elect to apply one of its public licenses to material it publishes and in those instances will be considered the \"Licensor.\" The text of the Creative Commons public licenses is dedicated to the public domain under the CC0 Public Domain Dedication. Except for the limited purpose of indicating that material is shared under a Creative Commons public license or as otherwise permitted by the Creative Commons policies published at creativecommons.org/policies, Creative Commons does not authorize the use of the trademark \"Creative Commons\" or any other trademark or logo of Creative Commons without its prior written consent including, without limitation, in connection with any unauthorized modifications to any of its public licenses or any other arrangements, understandings, or agreements concerning use of licensed material. For the avoidance of doubt, this paragraph does not form part of the public licenses.\n\nCreative Commons may be contacted at creativecommons.org."],"licenseIds":["CC-BY-NC-ND-4.0"],"keywords":["license h noncommercial","h noncommercial means","the exchange i","exchange i share","material 2 you","only and provided","and provided you","public license h noncommercial","license h noncommercial means","h noncommercial means not","with the exchange i","the exchange i share","exchange i share means","this public license for","public license for the","adapted material 2 you","material 2 you may","purposes only and provided","only and provided you","and provided you do","this public license h noncommercial","public license h noncommercial means","license h noncommercial means not","h noncommercial means not primarily","connection with the exchange i","with the exchange i share","the exchange i share means","exchange i share means to","only and b produce and","not share adapted material for","to this public license for","this public license for the","public license for the avoidance","to share adapted material 2","share adapted material 2 you","adapted material 2 you may","material 2 you may satisfy","noncommercial purposes only and provided","purposes only and provided you","only and provided you do","and provided you do not"]},{"licenseTexts":["Creative Commons Attribution-NonCommercial-ShareAlike 1.0 CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE LEGAL SERVICES. DISTRIBUTION OF THIS DRAFT LICENSE DOES NOT CREATE AN ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS INFORMATION ON AN \"AS-IS\" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES REGARDING THE INFORMATION PROVIDED, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM ITS USE.\n\nLicense\n\nTHE WORK (AS DEFINED BELOW) IS PROVIDED UNDER THE TERMS OF THIS CREATIVE COMMONS PUBLIC LICENSE (\"CCPL\" OR \"LICENSE\"). THE WORK IS PROTECTED BY COPYRIGHT AND/OR OTHER APPLICABLE LAW. ANY USE OF THE WORK OTHER THAN AS AUTHORIZED UNDER THIS LICENSE IS PROHIBITED.\n\nBY EXERCISING ANY RIGHTS TO THE WORK PROVIDED HERE, YOU ACCEPT AND AGREE TO BE BOUND BY THE TERMS OF THIS LICENSE. THE LICENSOR GRANTS YOU THE RIGHTS CONTAINED HERE IN CONSIDERATION OF YOUR ACCEPTANCE OF SUCH TERMS AND CONDITIONS.\n\n   1. Definitions\n\n      a. \"Collective Work\" means a work, such as a periodical issue, anthology or encyclopedia, in which the Work in its entirety in unmodified form, along with a number of other contributions, constituting separate and independent works in themselves, are assembled into a collective whole. A work that constitutes a Collective Work will not be considered a Derivative Work (as defined below) for the purposes of this License.\n\n      b. \"Derivative Work\" means a work based upon the Work or upon the Work and other pre-existing works, such as a translation, musical arrangement, dramatization, fictionalization, motion picture version, sound recording, art reproduction, abridgment, condensation, or any other form in which the Work may be recast, transformed, or adapted, except that a work that constitutes a Collective Work will not be considered a Derivative Work for the purpose of this License.\n\n      c. \"Licensor\" means the individual or entity that offers the Work under the terms of this License.\n\n      d. \"Original Author\" means the individual or entity who created the Work.\n\n      e. \"Work\" means the copyrightable work of authorship offered under the terms of this License.\n\n      f. \"You\" means an individual or entity exercising rights under this License who has not previously violated the terms of this License with respect to the Work, or who has received express permission from the Licensor to exercise rights under this License despite a previous violation.\n\n   2. Fair Use Rights. Nothing in this license is intended to reduce, limit, or restrict any rights arising from fair use, first sale or other limitations on the exclusive rights of the copyright owner under copyright law or other applicable laws.\n\n   3. License Grant. Subject to the terms and conditions of this License, Licensor hereby grants You a worldwide, royalty-free, non-exclusive, perpetual (for the duration of the applicable copyright) license to exercise the rights in the Work as stated below:\n\n      a. to reproduce the Work, to incorporate the Work into one or more Collective Works, and to reproduce the Work as incorporated in the Collective Works;\n\n      b. to create and reproduce Derivative Works;\n\n      c. to distribute copies or phonorecords of, display publicly, perform publicly, and perform publicly by means of a digital audio transmission the Work including as incorporated in Collective Works;\n\n      d. to distribute copies or phonorecords of, display publicly, perform publicly, and perform publicly by means of a digital audio transmission Derivative Works;\n\n   The above rights may be exercised in all media and formats whether now known or hereafter devised. The above rights include the right to make such modifications as are technically necessary to exercise the rights in other media and formats. All rights not expressly granted by Licensor are hereby reserved.\n\n   4. Restrictions. The license granted in Section 3 above is expressly made subject to and limited by the following restrictions:\n\n      a. You may distribute, publicly display, publicly perform, or publicly digitally perform the Work only under the terms of this License, and You must include a copy of, or the Uniform Resource Identifier for, this License with every copy or phonorecord of the Work You distribute, publicly display, publicly perform, or publicly digitally perform. You may not offer or impose any terms on the Work that alter or restrict the terms of this License or the recipients' exercise of the rights granted hereunder. You may not sublicense the Work. You must keep intact all notices that refer to this License and to the disclaimer of warranties. You may not distribute, publicly display, publicly perform, or publicly digitally perform the Work with any technological measures that control access or use of the Work in a manner inconsistent with the terms of this License Agreement. The above applies to the Work as incorporated in a Collective Work, but this does not require the Collective Work apart from the Work itself to be made subject to the terms of this License. If You create a Collective Work, upon notice from any Licensor You must, to the extent practicable, remove from the Collective Work any reference to such Licensor or the Original Author, as requested. If You create a Derivative Work, upon notice from any Licensor You must, to the extent practicable, remove from the Derivative Work any reference to such Licensor or the Original Author, as requested.\n\n      b. You may distribute, publicly display, publicly perform, or publicly digitally perform a Derivative Work only under the terms of this License, and You must include a copy of, or the Uniform Resource Identifier for, this License with every copy or phonorecord of each Derivative Work You distribute, publicly display, publicly perform, or publicly digitally perform. You may not offer or impose any terms on the Derivative Works that alter or restrict the terms of this License or the recipients' exercise of the rights granted hereunder, and You must keep intact all notices that refer to this License and to the disclaimer of warranties. You may not distribute, publicly display, publicly perform, or publicly digitally perform the Derivative Work with any technological measures that control access or use of the Work in a manner inconsistent with the terms of this License Agreement. The above applies to the Derivative Work as incorporated in a Collective Work, but this does not require the Collective Work apart from the Derivative Work itself to be made subject to the terms of this License.\n\n      c. You may not exercise any of the rights granted to You in Section 3 above in any manner that is primarily intended for or directed toward commercial advantage or private monetary compensation. The exchange of the Work for other copyrighted works by means of digital file-sharing or otherwise shall not be considered to be intended for or directed toward commercial advantage or private monetary compensation, provided there is no payment of any monetary compensation in connection with the exchange of copyrighted works.\n\n      d. If you distribute, publicly display, publicly perform, or publicly digitally perform the Work or any Derivative Works or Collective Works, You must keep intact all copyright notices for the Work and give the Original Author credit reasonable to the medium or means You are utilizing by conveying the name (or pseudonym if applicable) of the Original Author if supplied; the title of the Work if supplied; in the case of a Derivative Work, a credit identifying the use of the Work in the Derivative Work (e.g., \"French translation of the Work by Original Author,\" or \"Screenplay based on original Work by Original Author\"). Such credit may be implemented in any reasonable manner; provided, however, that in the case of a Derivative Work or Collective Work, at a minimum such credit will appear where any other comparable authorship credit appears and in a manner at least as prominent as such other comparable authorship credit.\n\n   5. Representations, Warranties and Disclaimer\n\n      a. By offering the Work for public release under this License, Licensor represents and warrants that, to the best of Licensor's knowledge after reasonable inquiry:\n\n         i. Licensor has secured all rights in the Work necessary to grant the license rights hereunder and to permit the lawful exercise of the rights granted hereunder without You having any obligation to pay any royalties, compulsory license fees, residuals or any other payments;\n\n         ii. The Work does not infringe the copyright, trademark, publicity rights, common law rights or any other right of any third party or constitute defamation, invasion of privacy or other tortious injury to any third party.\n\n      b. EXCEPT AS EXPRESSLY STATED IN THIS LICENSE OR OTHERWISE AGREED IN WRITING OR REQUIRED BY APPLICABLE LAW, THE WORK IS LICENSED ON AN \"AS IS\" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES REGARDING THE CONTENTS OR ACCURACY OF THE WORK.\n\n   6. Limitation on Liability. EXCEPT TO THE EXTENT REQUIRED BY APPLICABLE LAW, AND EXCEPT FOR DAMAGES ARISING FROM LIABILITY TO A THIRD PARTY RESULTING FROM BREACH OF THE WARRANTIES IN SECTION 5, IN NO EVENT WILL LICENSOR BE LIABLE TO YOU ON ANY LEGAL THEORY FOR ANY SPECIAL, INCIDENTAL, CONSEQUENTIAL, PUNITIVE OR EXEMPLARY DAMAGES ARISING OUT OF THIS LICENSE OR THE USE OF THE WORK, EVEN IF LICENSOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\n   7. Termination\n\n      a. This License and the rights granted hereunder will terminate automatically upon any breach by You of the terms of this License. Individuals or entities who have received Derivative Works or Collective Works from You under this License, however, will not have their licenses terminated provided such individuals or entities remain in full compliance with those licenses. Sections 1, 2, 5, 6, 7, and 8 will survive any termination of this License.\n\n      b. Subject to the above terms and conditions, the license granted here is perpetual (for the duration of the applicable copyright in the Work). Notwithstanding the above, Licensor reserves the right to release the Work under different license terms or to stop distributing the Work at any time; provided, however that any such election will not serve to withdraw this License (or any other license that has been, or is required to be, granted under the terms of this License), and this License will continue in full force and effect unless terminated as stated above.\n\n   8. Miscellaneous\n\n      a. Each time You distribute or publicly digitally perform the Work or a Collective Work, the Licensor offers to the recipient a license to the Work on the same terms and conditions as the license granted to You under this License.\n\n      b. Each time You distribute or publicly digitally perform a Derivative Work, Licensor offers to the recipient a license to the original Work on the same terms and conditions as the license granted to You under this License.\n\n      c. If any provision of this License is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this License, and without further action by the parties to this agreement, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.\n\n      d. No term or provision of this License shall be deemed waived and no breach consented to unless such waiver or consent shall be in writing and signed by the party to be charged with such waiver or consent.\n\n      e. This License constitutes the entire agreement between the parties with respect to the Work licensed here. There are no understandings, agreements or representations with respect to the Work not specified here. Licensor shall not be bound by any additional provisions that may appear in any communication from You. This License may not be modified without the mutual written agreement of the Licensor and You.\n\nCreative Commons is not a party to this License, and makes no warranty whatsoever in connection with the Work. Creative Commons will not be liable to You or any party on any legal theory for any damages whatsoever, including without limitation any general, special, incidental or consequential damages arising in connection to this license. Notwithstanding the foregoing two (2) sentences, if Creative Commons has expressly identified itself as the Licensor hereunder, it shall have all rights and obligations of Licensor.\n\nExcept for the limited purpose of indicating to the public that the Work is licensed under the CCPL, neither party will use the trademark \"Creative Commons\" or any related trademark or logo of Creative Commons without the prior written consent of Creative Commons. Any permitted use will be in compliance with Creative Commons' then-current trademark usage guidelines, as may be published on its website or otherwise made available upon request from time to time.\n\nCreative Commons may be contacted at http://creativecommons.org/."],"licenseIds":["CC-BY-NC-SA-1.0"],"keywords":["noncommercial sharealike 1","attribution noncommercial sharealike 1","noncommercial sharealike 1 0","commons attribution noncommercial sharealike 1","attribution noncommercial sharealike 1 0","noncommercial sharealike 1 0 creative"]},{"licenseTexts":["Creative Commons Attribution-NonCommercial-ShareAlike 2.0 CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE LEGAL SERVICES. DISTRIBUTION OF THIS LICENSE DOES NOT CREATE AN ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS INFORMATION ON AN \"AS-IS\" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES REGARDING THE INFORMATION PROVIDED, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM ITS USE.\n\nLicense\n\nTHE WORK (AS DEFINED BELOW) IS PROVIDED UNDER THE TERMS OF THIS CREATIVE COMMONS PUBLIC LICENSE (\"CCPL\" OR \"LICENSE\"). THE WORK IS PROTECTED BY COPYRIGHT AND/OR OTHER APPLICABLE LAW. ANY USE OF THE WORK OTHER THAN AS AUTHORIZED UNDER THIS LICENSE OR COPYRIGHT LAW IS PROHIBITED.\n\nBY EXERCISING ANY RIGHTS TO THE WORK PROVIDED HERE, YOU ACCEPT AND AGREE TO BE BOUND BY THE TERMS OF THIS LICENSE. THE LICENSOR GRANTS YOU THE RIGHTS CONTAINED HERE IN CONSIDERATION OF YOUR ACCEPTANCE OF SUCH TERMS AND CONDITIONS.\n\n   1. Definitions\n\n      a. \"Collective Work\" means a work, such as a periodical issue, anthology or encyclopedia, in which the Work in its entirety in unmodified form, along with a number of other contributions, constituting separate and independent works in themselves, are assembled into a collective whole. A work that constitutes a Collective Work will not be considered a Derivative Work (as defined below) for the purposes of this License.\n\n      b. \"Derivative Work\" means a work based upon the Work or upon the Work and other pre-existing works, such as a translation, musical arrangement, dramatization, fictionalization, motion picture version, sound recording, art reproduction, abridgment, condensation, or any other form in which the Work may be recast, transformed, or adapted, except that a work that constitutes a Collective Work will not be considered a Derivative Work for the purpose of this License. For the avoidance of doubt, where the Work is a musical composition or sound recording, the synchronization of the Work in timed-relation with a moving image (\"synching\") will be considered a Derivative Work for the purpose of this License.\n\n      c. \"Licensor\" means the individual or entity that offers the Work under the terms of this License.\n\n      d. \"Original Author\" means the individual or entity who created the Work.\n\n      e. \"Work\" means the copyrightable work of authorship offered under the terms of this License.\n\n      f. \"You\" means an individual or entity exercising rights under this License who has not previously violated the terms of this License with respect to the Work, or who has received express permission from the Licensor to exercise rights under this License despite a previous violation.\n\n      g. \"License Elements\" means the following high-level license attributes as selected by Licensor and indicated in the title of this License: Attribution, Noncommercial, ShareAlike.\n\n   2. Fair Use Rights. Nothing in this license is intended to reduce, limit, or restrict any rights arising from fair use, first sale or other limitations on the exclusive rights of the copyright owner under copyright law or other applicable laws.\n\n   3. License Grant. Subject to the terms and conditions of this License, Licensor hereby grants You a worldwide, royalty-free, non-exclusive, perpetual (for the duration of the applicable copyright) license to exercise the rights in the Work as stated below:\n\n      a. to reproduce the Work, to incorporate the Work into one or more Collective Works, and to reproduce the Work as incorporated in the Collective Works;\n\n      b. to create and reproduce Derivative Works;\n\n      c. to distribute copies or phonorecords of, display publicly, perform publicly, and perform publicly by means of a digital audio transmission the Work including as incorporated in Collective Works;\n\n      d. to distribute copies or phonorecords of, display publicly, perform publicly, and perform publicly by means of a digital audio transmission Derivative Works;\n\n      The above rights may be exercised in all media and formats whether now known or hereafter devised. The above rights include the right to make such modifications as are technically necessary to exercise the rights in other media and formats. All rights not expressly granted by Licensor are hereby reserved, including but not limited to the rights set forth in Sections 4(e) and 4(f).\n\n   4. Restrictions. The license granted in Section 3 above is expressly made subject to and limited by the following restrictions:\n\n      a. You may distribute, publicly display, publicly perform, or publicly digitally perform the Work only under the terms of this License, and You must include a copy of, or the Uniform Resource Identifier for, this License with every copy or phonorecord of the Work You distribute, publicly display, publicly perform, or publicly digitally perform. You may not offer or impose any terms on the Work that alter or restrict the terms of this License or the recipients' exercise of the rights granted hereunder. You may not sublicense the Work. You must keep intact all notices that refer to this License and to the disclaimer of warranties. You may not distribute, publicly display, publicly perform, or publicly digitally perform the Work with any technological measures that control access or use of the Work in a manner inconsistent with the terms of this License Agreement. The above applies to the Work as incorporated in a Collective Work, but this does not require the Collective Work apart from the Work itself to be made subject to the terms of this License. If You create a Collective Work, upon notice from any Licensor You must, to the extent practicable, remove from the Collective Work any reference to such Licensor or the Original Author, as requested. If You create a Derivative Work, upon notice from any Licensor You must, to the extent practicable, remove from the Derivative Work any reference to such Licensor or the Original Author, as requested.\n\n      b. You may distribute, publicly display, publicly perform, or publicly digitally perform a Derivative Work only under the terms of this License, a later version of this License with the same License Elements as this License, or a Creative Commons iCommons license that contains the same License Elements as this License (e.g. Attribution-NonCommercial-ShareAlike 2.0 Japan). You must include a copy of, or the Uniform Resource Identifier for, this License or other license specified in the previous sentence with every copy or phonorecord of each Derivative Work You distribute, publicly display, publicly perform, or publicly digitally perform. You may not offer or impose any terms on the Derivative Works that alter or restrict the terms of this License or the recipients' exercise of the rights granted hereunder, and You must keep intact all notices that refer to this License and to the disclaimer of warranties. You may not distribute, publicly display, publicly perform, or publicly digitally perform the Derivative Work with any technological measures that control access or use of the Work in a manner inconsistent with the terms of this License Agreement. The above applies to the Derivative Work as incorporated in a Collective Work, but this does not require the Collective Work apart from the Derivative Work itself to be made subject to the terms of this License.\n\n      c. You may not exercise any of the rights granted to You in Section 3 above in any manner that is primarily intended for or directed toward commercial advantage or private monetary compensation. The exchange of the Work for other copyrighted works by means of digital file-sharing or otherwise shall not be considered to be intended for or directed toward commercial advantage or private monetary compensation, provided there is no payment of any monetary compensation in connection with the exchange of copyrighted works.\n\n      d. If you distribute, publicly display, publicly perform, or publicly digitally perform the Work or any Derivative Works or Collective Works, You must keep intact all copyright notices for the Work and give the Original Author credit reasonable to the medium or means You are utilizing by conveying the name (or pseudonym if applicable) of the Original Author if supplied; the title of the Work if supplied; to the extent reasonably practicable, the Uniform Resource Identifier, if any, that Licensor specifies to be associated with the Work, unless such URI does not refer to the copyright notice or licensing information for the Work; and in the case of a Derivative Work, a credit identifying the use of the Work in the Derivative Work (e.g., \"French translation of the Work by Original Author,\" or \"Screenplay based on original Work by Original Author\"). Such credit may be implemented in any reasonable manner; provided, however, that in the case of a Derivative Work or Collective Work, at a minimum such credit will appear where any other comparable authorship credit appears and in a manner at least as prominent as such other comparable authorship credit.\n\n      e. For the avoidance of doubt, where the Work is a musical composition:\n\n         i. Performance Royalties Under Blanket Licenses. Licensor reserves the exclusive right to collect, whether individually or via a performance rights society (e.g. ASCAP, BMI, SESAC), royalties for the public performance or public digital performance (e.g. webcast) of the Work if that performance is primarily intended for or directed toward commercial advantage or private monetary compensation.\n\n         ii. Mechanical Rights and Statutory Royalties. Licensor reserves the exclusive right to collect, whether individually or via a music rights agency or designated agent (e.g. Harry Fox Agency), royalties for any phonorecord You create from the Work (\"cover version\") and distribute, subject to the compulsory license created by 17 USC Section 115 of the US Copyright Act (or the equivalent in other jurisdictions), if Your distribution of such cover version is primarily intended for or directed toward commercial advantage or private monetary compensation.\n\n      f. Webcasting Rights and Statutory Royalties. For the avoidance of doubt, where the Work is a sound recording, Licensor reserves the exclusive right to collect, whether individually or via a performance-rights society (e.g. SoundExchange), royalties for the public digital performance (e.g. webcast) of the Work, subject to the compulsory license created by 17 USC Section 114 of the US Copyright Act (or the equivalent in other jurisdictions), if Your public digital performance is primarily intended for or directed toward commercial advantage or private monetary compensation.\n\n   5. Representations, Warranties and Disclaimer\n\n   UNLESS OTHERWISE MUTUALLY AGREED TO BY THE PARTIES IN WRITING, LICENSOR OFFERS THE WORK AS-IS AND MAKES NO REPRESENTATIONS OR WARRANTIES OF ANY KIND CONCERNING THE WORK, EXPRESS, IMPLIED, STATUTORY OR OTHERWISE, INCLUDING, WITHOUT LIMITATION, WARRANTIES OF TITLE, MERCHANTIBILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT, OR THE ABSENCE OF LATENT OR OTHER DEFECTS, ACCURACY, OR THE PRESENCE OF ABSENCE OF ERRORS, WHETHER OR NOT DISCOVERABLE. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OF IMPLIED WARRANTIES, SO SUCH EXCLUSION MAY NOT APPLY TO YOU.\n\n   6. Limitation on Liability. EXCEPT TO THE EXTENT REQUIRED BY APPLICABLE LAW, IN NO EVENT WILL LICENSOR BE LIABLE TO YOU ON ANY LEGAL THEORY FOR ANY SPECIAL, INCIDENTAL, CONSEQUENTIAL, PUNITIVE OR EXEMPLARY DAMAGES ARISING OUT OF THIS LICENSE OR THE USE OF THE WORK, EVEN IF LICENSOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\n   7. Termination\n\n      a. This License and the rights granted hereunder will terminate automatically upon any breach by You of the terms of this License. Individuals or entities who have received Derivative Works or Collective Works from You under this License, however, will not have their licenses terminated provided such individuals or entities remain in full compliance with those licenses. Sections 1, 2, 5, 6, 7, and 8 will survive any termination of this License.\n\n      b. Subject to the above terms and conditions, the license granted here is perpetual (for the duration of the applicable copyright in the Work). Notwithstanding the above, Licensor reserves the right to release the Work under different license terms or to stop distributing the Work at any time; provided, however that any such election will not serve to withdraw this License (or any other license that has been, or is required to be, granted under the terms of this License), and this License will continue in full force and effect unless terminated as stated above.\n\n   8. Miscellaneous\n\n      a. Each time You distribute or publicly digitally perform the Work or a Collective Work, the Licensor offers to the recipient a license to the Work on the same terms and conditions as the license granted to You under this License.\n\n      b. Each time You distribute or publicly digitally perform a Derivative Work, Licensor offers to the recipient a license to the original Work on the same terms and conditions as the license granted to You under this License.\n\n      c. If any provision of this License is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this License, and without further action by the parties to this agreement, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.\n\n      d. No term or provision of this License shall be deemed waived and no breach consented to unless such waiver or consent shall be in writing and signed by the party to be charged with such waiver or consent.\n\n      e. This License constitutes the entire agreement between the parties with respect to the Work licensed here. There are no understandings, agreements or representations with respect to the Work not specified here. Licensor shall not be bound by any additional provisions that may appear in any communication from You. This License may not be modified without the mutual written agreement of the Licensor and You.\n\nCreative Commons is not a party to this License, and makes no warranty whatsoever in connection with the Work. Creative Commons will not be liable to You or any party on any legal theory for any damages whatsoever, including without limitation any general, special, incidental or consequential damages arising in connection to this license. Notwithstanding the foregoing two (2) sentences, if Creative Commons has expressly identified itself as the Licensor hereunder, it shall have all rights and obligations of Licensor.\n\nExcept for the limited purpose of indicating to the public that the Work is licensed under the CCPL, neither party will use the trademark \"Creative Commons\" or any related trademark or logo of Creative Commons without the prior written consent of Creative Commons. Any permitted use will be in compliance with Creative Commons' then-current trademark usage guidelines, as may be published on its website or otherwise made available upon request from time to time.\n\nCreative Commons may be contacted at http://creativecommons.org/."],"licenseIds":["CC-BY-NC-SA-2.0"],"keywords":["noncommercial sharealike 2 0 creative","noncommercial sharealike 2 0 japan"]},{"licenseTexts":["Creative Commons Attribution-NonCommercial-ShareAlike 2.5 CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE LEGAL SERVICES. DISTRIBUTION OF THIS LICENSE DOES NOT CREATE AN ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS INFORMATION ON AN \"AS-IS\" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES REGARDING THE INFORMATION PROVIDED, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM ITS USE.\n\nLicense\n\nTHE WORK (AS DEFINED BELOW) IS PROVIDED UNDER THE TERMS OF THIS CREATIVE COMMONS PUBLIC LICENSE (\"CCPL\" OR \"LICENSE\"). THE WORK IS PROTECTED BY COPYRIGHT AND/OR OTHER APPLICABLE LAW. ANY USE OF THE WORK OTHER THAN AS AUTHORIZED UNDER THIS LICENSE OR COPYRIGHT LAW IS PROHIBITED.\n\nBY EXERCISING ANY RIGHTS TO THE WORK PROVIDED HERE, YOU ACCEPT AND AGREE TO BE BOUND BY THE TERMS OF THIS LICENSE. THE LICENSOR GRANTS YOU THE RIGHTS CONTAINED HERE IN CONSIDERATION OF YOUR ACCEPTANCE OF SUCH TERMS AND CONDITIONS.\n\n   1. Definitions\n\n      a. \"Collective Work\" means a work, such as a periodical issue, anthology or encyclopedia, in which the Work in its entirety in unmodified form, along with a number of other contributions, constituting separate and independent works in themselves, are assembled into a collective whole. A work that constitutes a Collective Work will not be considered a Derivative Work (as defined below) for the purposes of this License.\n\n      b. \"Derivative Work\" means a work based upon the Work or upon the Work and other pre-existing works, such as a translation, musical arrangement, dramatization, fictionalization, motion picture version, sound recording, art reproduction, abridgment, condensation, or any other form in which the Work may be recast, transformed, or adapted, except that a work that constitutes a Collective Work will not be considered a Derivative Work for the purpose of this License. For the avoidance of doubt, where the Work is a musical composition or sound recording, the synchronization of the Work in timed-relation with a moving image (\"synching\") will be considered a Derivative Work for the purpose of this License.\n\n      c. \"Licensor\" means the individual or entity that offers the Work under the terms of this License.\n\n      d. \"Original Author\" means the individual or entity who created the Work.\n\n      e. \"Work\" means the copyrightable work of authorship offered under the terms of this License.\n\n      f. \"You\" means an individual or entity exercising rights under this License who has not previously violated the terms of this License with respect to the Work, or who has received express permission from the Licensor to exercise rights under this License despite a previous violation.\n\n      g. \"License Elements\" means the following high-level license attributes as selected by Licensor and indicated in the title of this License: Attribution, Noncommercial, ShareAlike.\n\n   2. Fair Use Rights. Nothing in this license is intended to reduce, limit, or restrict any rights arising from fair use, first sale or other limitations on the exclusive rights of the copyright owner under copyright law or other applicable laws.\n\n   3. License Grant. Subject to the terms and conditions of this License, Licensor hereby grants You a worldwide, royalty-free, non-exclusive, perpetual (for the duration of the applicable copyright) license to exercise the rights in the Work as stated below:\n\n      a. to reproduce the Work, to incorporate the Work into one or more Collective Works, and to reproduce the Work as incorporated in the Collective Works;\n\n      b. to create and reproduce Derivative Works;\n\n      c. to distribute copies or phonorecords of, display publicly, perform publicly, and perform publicly by means of a digital audio transmission the Work including as incorporated in Collective Works;\n\n      d. to distribute copies or phonorecords of, display publicly, perform publicly, and perform publicly by means of a digital audio transmission Derivative Works;\n\n   The above rights may be exercised in all media and formats whether now known or hereafter devised. The above rights include the right to make such modifications as are technically necessary to exercise the rights in other media and formats. All rights not expressly granted by Licensor are hereby reserved, including but not limited to the rights set forth in Sections 4(e) and 4(f).\n\n   4. Restrictions. The license granted in Section 3 above is expressly made subject to and limited by the following restrictions:\n\n      a. You may distribute, publicly display, publicly perform, or publicly digitally perform the Work only under the terms of this License, and You must include a copy of, or the Uniform Resource Identifier for, this License with every copy or phonorecord of the Work You distribute, publicly display, publicly perform, or publicly digitally perform. You may not offer or impose any terms on the Work that alter or restrict the terms of this License or the recipients' exercise of the rights granted hereunder. You may not sublicense the Work. You must keep intact all notices that refer to this License and to the disclaimer of warranties. You may not distribute, publicly display, publicly perform, or publicly digitally perform the Work with any technological measures that control access or use of the Work in a manner inconsistent with the terms of this License Agreement. The above applies to the Work as incorporated in a Collective Work, but this does not require the Collective Work apart from the Work itself to be made subject to the terms of this License. If You create a Collective Work, upon notice from any Licensor You must, to the extent practicable, remove from the Collective Work any credit as required by clause 4(d), as requested. If You create a Derivative Work, upon notice from any Licensor You must, to the extent practicable, remove from the Derivative Work any credit as required by clause 4(d), as requested.\n\n      b. You may distribute, publicly display, publicly perform, or publicly digitally perform a Derivative Work only under the terms of this License, a later version of this License with the same License Elements as this License, or a Creative Commons iCommons license that contains the same License Elements as this License (e.g. Attribution-NonCommercial-ShareAlike 2.5 Japan). You must include a copy of, or the Uniform Resource Identifier for, this License or other license specified in the previous sentence with every copy or phonorecord of each Derivative Work You distribute, publicly display, publicly perform, or publicly digitally perform. You may not offer or impose any terms on the Derivative Works that alter or restrict the terms of this License or the recipients' exercise of the rights granted hereunder, and You must keep intact all notices that refer to this License and to the disclaimer of warranties. You may not distribute, publicly display, publicly perform, or publicly digitally perform the Derivative Work with any technological measures that control access or use of the Work in a manner inconsistent with the terms of this License Agreement. The above applies to the Derivative Work as incorporated in a Collective Work, but this does not require the Collective Work apart from the Derivative Work itself to be made subject to the terms of this License.\n\n      c. You may not exercise any of the rights granted to You in Section 3 above in any manner that is primarily intended for or directed toward commercial advantage or private monetary compensation. The exchange of the Work for other copyrighted works by means of digital file-sharing or otherwise shall not be considered to be intended for or directed toward commercial advantage or private monetary compensation, provided there is no payment of any monetary compensation in connection with the exchange of copyrighted works.\n\n      d. If you distribute, publicly display, publicly perform, or publicly digitally perform the Work or any Derivative Works or Collective Works, You must keep intact all copyright notices for the Work and provide, reasonable to the medium or means You are utilizing: (i) the name of the Original Author (or pseudonym, if applicable) if supplied, and/or (ii) if the Original Author and/or Licensor designate another party or parties (e.g. a sponsor institute, publishing entity, journal) for attribution in Licensor's copyright notice, terms of service or by other reasonable means, the name of such party or parties; the title of the Work if supplied; to the extent reasonably practicable, the Uniform Resource Identifier, if any, that Licensor specifies to be associated with the Work, unless such URI does not refer to the copyright notice or licensing information for the Work; and in the case of a Derivative Work, a credit identifying the use of the Work in the Derivative Work (e.g., \"French translation of the Work by Original Author,\" or \"Screenplay based on original Work by Original Author\"). Such credit may be implemented in any reasonable manner; provided, however, that in the case of a Derivative Work or Collective Work, at a minimum such credit will appear where any other comparable authorship credit appears and in a manner at least as prominent as such other comparable authorship credit.\n\n      e. For the avoidance of doubt, where the Work is a musical composition:\n\n         i. Performance Royalties Under Blanket Licenses. Licensor reserves the exclusive right to collect, whether individually or via a performance rights society (e.g. ASCAP, BMI, SESAC), royalties for the public performance or public digital performance (e.g. webcast) of the Work if that performance is primarily intended for or directed toward commercial advantage or private monetary compensation.\n\n         ii. Mechanical Rights and Statutory Royalties. Licensor reserves the exclusive right to collect, whether individually or via a music rights agency or designated agent (e.g. Harry Fox Agency), royalties for any phonorecord You create from the Work (\"cover version\") and distribute, subject to the compulsory license created by 17 USC Section 115 of the US Copyright Act (or the equivalent in other jurisdictions), if Your distribution of such cover version is primarily intended for or directed toward commercial advantage or private monetary compensation.\n\n      f. Webcasting Rights and Statutory Royalties. For the avoidance of doubt, where the Work is a sound recording, Licensor reserves the exclusive right to collect, whether individually or via a performance-rights society (e.g. SoundExchange), royalties for the public digital performance (e.g. webcast) of the Work, subject to the compulsory license created by 17 USC Section 114 of the US Copyright Act (or the equivalent in other jurisdictions), if Your public digital performance is primarily intended for or directed toward commercial advantage or private monetary compensation.\n\n   5. Representations, Warranties and Disclaimer\n\n   UNLESS OTHERWISE MUTUALLY AGREED TO BY THE PARTIES IN WRITING, LICENSOR OFFERS THE WORK AS-IS AND MAKES NO REPRESENTATIONS OR WARRANTIES OF ANY KIND CONCERNING THE WORK, EXPRESS, IMPLIED, STATUTORY OR OTHERWISE, INCLUDING, WITHOUT LIMITATION, WARRANTIES OF TITLE, MERCHANTIBILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT, OR THE ABSENCE OF LATENT OR OTHER DEFECTS, ACCURACY, OR THE PRESENCE OF ABSENCE OF ERRORS, WHETHER OR NOT DISCOVERABLE. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OF IMPLIED WARRANTIES, SO SUCH EXCLUSION MAY NOT APPLY TO YOU.\n\n   6. Limitation on Liability. EXCEPT TO THE EXTENT REQUIRED BY APPLICABLE LAW, IN NO EVENT WILL LICENSOR BE LIABLE TO YOU ON ANY LEGAL THEORY FOR ANY SPECIAL, INCIDENTAL, CONSEQUENTIAL, PUNITIVE OR EXEMPLARY DAMAGES ARISING OUT OF THIS LICENSE OR THE USE OF THE WORK, EVEN IF LICENSOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\n   7. Termination\n\n      a. This License and the rights granted hereunder will terminate automatically upon any breach by You of the terms of this License. Individuals or entities who have received Derivative Works or Collective Works from You under this License, however, will not have their licenses terminated provided such individuals or entities remain in full compliance with those licenses. Sections 1, 2, 5, 6, 7, and 8 will survive any termination of this License.\n\n      b. Subject to the above terms and conditions, the license granted here is perpetual (for the duration of the applicable copyright in the Work). Notwithstanding the above, Licensor reserves the right to release the Work under different license terms or to stop distributing the Work at any time; provided, however that any such election will not serve to withdraw this License (or any other license that has been, or is required to be, granted under the terms of this License), and this License will continue in full force and effect unless terminated as stated above.\n\n   8. Miscellaneous\n\n      a. Each time You distribute or publicly digitally perform the Work or a Collective Work, the Licensor offers to the recipient a license to the Work on the same terms and conditions as the license granted to You under this License.\n\n      b. Each time You distribute or publicly digitally perform a Derivative Work, Licensor offers to the recipient a license to the original Work on the same terms and conditions as the license granted to You under this License.\n\n      c. If any provision of this License is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this License, and without further action by the parties to this agreement, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.\n\n      d. No term or provision of this License shall be deemed waived and no breach consented to unless such waiver or consent shall be in writing and signed by the party to be charged with such waiver or consent.\n\n      e. This License constitutes the entire agreement between the parties with respect to the Work licensed here. There are no understandings, agreements or representations with respect to the Work not specified here. Licensor shall not be bound by any additional provisions that may appear in any communication from You. This License may not be modified without the mutual written agreement of the Licensor and You.\n\nCreative Commons is not a party to this License, and makes no warranty whatsoever in connection with the Work. Creative Commons will not be liable to You or any party on any legal theory for any damages whatsoever, including without limitation any general, special, incidental or consequential damages arising in connection to this license. Notwithstanding the foregoing two (2) sentences, if Creative Commons has expressly identified itself as the Licensor hereunder, it shall have all rights and obligations of Licensor.\n\nExcept for the limited purpose of indicating to the public that the Work is licensed under the CCPL, neither party will use the trademark \"Creative Commons\" or any related trademark or logo of Creative Commons without the prior written consent of Creative Commons. Any permitted use will be in compliance with Creative Commons' then-current trademark usage guidelines, as may be published on its website or otherwise made available upon request from time to time.\n\nCreative Commons may be contacted at http://creativecommons.org/."],"licenseIds":["CC-BY-NC-SA-2.5"],"keywords":["noncommercial sharealike 2 5 creative","noncommercial sharealike 2 5 japan"]},{"licenseTexts":["Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE LEGAL SERVICES. DISTRIBUTION OF THIS LICENSE DOES NOT CREATE AN ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS INFORMATION ON AN \"AS-IS\" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES REGARDING THE INFORMATION PROVIDED, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM ITS USE.\n\nLicense\n\nTHE WORK (AS DEFINED BELOW) IS PROVIDED UNDER THE TERMS OF THIS CREATIVE COMMONS PUBLIC LICENSE (\"CCPL\" OR \"LICENSE\"). THE WORK IS PROTECTED BY COPYRIGHT AND/OR OTHER APPLICABLE LAW. ANY USE OF THE WORK OTHER THAN AS AUTHORIZED UNDER THIS LICENSE OR COPYRIGHT LAW IS PROHIBITED.\n\nBY EXERCISING ANY RIGHTS TO THE WORK PROVIDED HERE, YOU ACCEPT AND AGREE TO BE BOUND BY THE TERMS OF THIS LICENSE. TO THE EXTENT THIS LICENSE MAY BE CONSIDERED TO BE A CONTRACT, THE LICENSOR GRANTS YOU THE RIGHTS CONTAINED HERE IN CONSIDERATION OF YOUR ACCEPTANCE OF SUCH TERMS AND CONDITIONS.\n\n   1. Definitions\n\n      a. \"Adaptation\" means a work based upon the Work, or upon the Work and other pre-existing works, such as a translation, adaptation, derivative work, arrangement of music or other alterations of a literary or artistic work, or phonogram or performance and includes cinematographic adaptations or any other form in which the Work may be recast, transformed, or adapted including in any form recognizably derived from the original, except that a work that constitutes a Collection will not be considered an Adaptation for the purpose of this License. For the avoidance of doubt, where the Work is a musical work, performance or phonogram, the synchronization of the Work in timed-relation with a moving image (\"synching\") will be considered an Adaptation for the purpose of this License.\n\n      b. \"Collection\" means a collection of literary or artistic works, such as encyclopedias and anthologies, or performances, phonograms or broadcasts, or other works or subject matter other than works listed in Section 1(g) below, which, by reason of the selection and arrangement of their contents, constitute intellectual creations, in which the Work is included in its entirety in unmodified form along with one or more other contributions, each constituting separate and independent works in themselves, which together are assembled into a collective whole. A work that constitutes a Collection will not be considered an Adaptation (as defined above) for the purposes of this License.\n\n      c. \"Distribute\" means to make available to the public the original and copies of the Work or Adaptation, as appropriate, through sale or other transfer of ownership.\n\n      d. \"License Elements\" means the following high-level license attributes as selected by Licensor and indicated in the title of this License: Attribution, Noncommercial, ShareAlike.\n\n      e. \"Licensor\" means the individual, individuals, entity or entities that offer(s) the Work under the terms of this License.\n\n      f. \"Original Author\" means, in the case of a literary or artistic work, the individual, individuals, entity or entities who created the Work or if no individual or entity can be identified, the publisher; and in addition (i) in the case of a performance the actors, singers, musicians, dancers, and other persons who act, sing, deliver, declaim, play in, interpret or otherwise perform literary or artistic works or expressions of folklore; (ii) in the case of a phonogram the producer being the person or legal entity who first fixes the sounds of a performance or other sounds; and, (iii) in the case of broadcasts, the organization that transmits the broadcast.\n\n      g. \"Work\" means the literary and/or artistic work offered under the terms of this License including without limitation any production in the literary, scientific and artistic domain, whatever may be the mode or form of its expression including digital form, such as a book, pamphlet and other writing; a lecture, address, sermon or other work of the same nature; a dramatic or dramatico-musical work; a choreographic work or entertainment in dumb show; a musical composition with or without words; a cinematographic work to which are assimilated works expressed by a process analogous to cinematography; a work of drawing, painting, architecture, sculpture, engraving or lithography; a photographic work to which are assimilated works expressed by a process analogous to photography; a work of applied art; an illustration, map, plan, sketch or three-dimensional work relative to geography, topography, architecture or science; a performance; a broadcast; a phonogram; a compilation of data to the extent it is protected as a copyrightable work; or a work performed by a variety or circus performer to the extent it is not otherwise considered a literary or artistic work.\n\n      h. \"You\" means an individual or entity exercising rights under this License who has not previously violated the terms of this License with respect to the Work, or who has received express permission from the Licensor to exercise rights under this License despite a previous violation.\n\n      i. \"Publicly Perform\" means to perform public recitations of the Work and to communicate to the public those public recitations, by any means or process, including by wire or wireless means or public digital performances; to make available to the public Works in such a way that members of the public may access these Works from a place and at a place individually chosen by them; to perform the Work to the public by any means or process and the communication to the public of the performances of the Work, including by public digital performance; to broadcast and rebroadcast the Work by any means including signs, sounds or images.\n\n      j. \"Reproduce\" means to make copies of the Work by any means including without limitation by sound or visual recordings and the right of fixation and reproducing fixations of the Work, including storage of a protected performance or phonogram in digital form or other electronic medium.\n\n   2. Fair Dealing Rights. Nothing in this License is intended to reduce, limit, or restrict any uses free from copyright or rights arising from limitations or exceptions that are provided for in connection with the copyright protection under copyright law or other applicable laws.\n\n   3. License Grant. Subject to the terms and conditions of this License, Licensor hereby grants You a worldwide, royalty-free, non-exclusive, perpetual (for the duration of the applicable copyright) license to exercise the rights in the Work as stated below:\n\n      a. to Reproduce the Work, to incorporate the Work into one or more Collections, and to Reproduce the Work as incorporated in the Collections;\n\n      b. to create and Reproduce Adaptations provided that any such Adaptation, including any translation in any medium, takes reasonable steps to clearly label, demarcate or otherwise identify that changes were made to the original Work. For example, a translation could be marked \"The original work was translated from English to Spanish,\" or a modification could indicate \"The original work has been modified.\";\n\n      c. to Distribute and Publicly Perform the Work including as incorporated in Collections; and,\n\n      d. to Distribute and Publicly Perform Adaptations.\n\n      The above rights may be exercised in all media and formats whether now known or hereafter devised. The above rights include the right to make such modifications as are technically necessary to exercise the rights in other media and formats. Subject to Section 8(f), all rights not expressly granted by Licensor are hereby reserved, including but not limited to the rights described in Section 4(e).\n\n   4. Restrictions. The license granted in Section 3 above is expressly made subject to and limited by the following restrictions:\n\n      a. You may Distribute or Publicly Perform the Work only under the terms of this License. You must include a copy of, or the Uniform Resource Identifier (URI) for, this License with every copy of the Work You Distribute or Publicly Perform. You may not offer or impose any terms on the Work that restrict the terms of this License or the ability of the recipient of the Work to exercise the rights granted to that recipient under the terms of the License. You may not sublicense the Work. You must keep intact all notices that refer to this License and to the disclaimer of warranties with every copy of the Work You Distribute or Publicly Perform. When You Distribute or Publicly Perform the Work, You may not impose any effective technological measures on the Work that restrict the ability of a recipient of the Work from You to exercise the rights granted to that recipient under the terms of the License. This Section 4(a) applies to the Work as incorporated in a Collection, but this does not require the Collection apart from the Work itself to be made subject to the terms of this License. If You create a Collection, upon notice from any Licensor You must, to the extent practicable, remove from the Collection any credit as required by Section 4(d), as requested. If You create an Adaptation, upon notice from any Licensor You must, to the extent practicable, remove from the Adaptation any credit as required by Section 4(d), as requested.\n\n      b. You may Distribute or Publicly Perform an Adaptation only under: (i) the terms of this License; (ii) a later version of this License with the same License Elements as this License; (iii) a Creative Commons jurisdiction license (either this or a later license version) that contains the same License Elements as this License (e.g., Attribution-NonCommercial-ShareAlike 3.0 US) (\"Applicable License\"). You must include a copy of, or the URI, for Applicable License with every copy of each Adaptation You Distribute or Publicly Perform. You may not offer or impose any terms on the Adaptation that restrict the terms of the Applicable License or the ability of the recipient of the Adaptation to exercise the rights granted to that recipient under the terms of the Applicable License. You must keep intact all notices that refer to the Applicable License and to the disclaimer of warranties with every copy of the Work as included in the Adaptation You Distribute or Publicly Perform. When You Distribute or Publicly Perform the Adaptation, You may not impose any effective technological measures on the Adaptation that restrict the ability of a recipient of the Adaptation from You to exercise the rights granted to that recipient under the terms of the Applicable License. This Section 4(b) applies to the Adaptation as incorporated in a Collection, but this does not require the Collection apart from the Adaptation itself to be made subject to the terms of the Applicable License.\n\n      c. You may not exercise any of the rights granted to You in Section 3 above in any manner that is primarily intended for or directed toward commercial advantage or private monetary compensation. The exchange of the Work for other copyrighted works by means of digital file-sharing or otherwise shall not be considered to be intended for or directed toward commercial advantage or private monetary compensation, provided there is no payment of any monetary compensation in con-nection with the exchange of copyrighted works.\n\n      d. If You Distribute, or Publicly Perform the Work or any Adaptations or Collections, You must, unless a request has been made pursuant to Section 4(a), keep intact all copyright notices for the Work and provide, reasonable to the medium or means You are utilizing: (i) the name of the Original Author (or pseudonym, if applicable) if supplied, and/or if the Original Author and/or Licensor designate another party or parties (e.g., a sponsor institute, publishing entity, journal) for attribution (\"Attribution Parties\") in Licensor's copyright notice, terms of service or by other reasonable means, the name of such party or parties; (ii) the title of the Work if supplied; (iii) to the extent reasonably practicable, the URI, if any, that Licensor specifies to be associated with the Work, unless such URI does not refer to the copyright notice or licensing information for the Work; and, (iv) consistent with Section 3(b), in the case of an Adaptation, a credit identifying the use of the Work in the Adaptation (e.g., \"French translation of the Work by Original Author,\" or \"Screenplay based on original Work by Original Author\"). The credit required by this Section 4(d) may be implemented in any reasonable manner; provided, however, that in the case of a Adaptation or Collection, at a minimum such credit will appear, if a credit for all contributing authors of the Adaptation or Collection appears, then as part of these credits and in a manner at least as prominent as the credits for the other contributing authors. For the avoidance of doubt, You may only use the credit required by this Section for the purpose of attribution in the manner set out above and, by exercising Your rights under this License, You may not implicitly or explicitly assert or imply any connection with, sponsorship or endorsement by the Original Author, Licensor and/or Attribution Parties, as appropriate, of You or Your use of the Work, without the separate, express prior written permission of the Original Author, Licensor and/or Attribution Parties.\n\n      e. For the avoidance of doubt:\n\n         i. Non-waivable Compulsory License Schemes. In those jurisdictions in which the right to collect royalties through any statutory or compulsory licensing scheme cannot be waived, the Licensor reserves the exclusive right to collect such royalties for any exercise by You of the rights granted under this License;\n\n         ii. Waivable Compulsory License Schemes. In those jurisdictions in which the right to collect royalties through any statutory or compulsory licensing scheme can be waived, the Licensor reserves the exclusive right to collect such royalties for any exercise by You of the rights granted under this License if Your exercise of such rights is for a purpose or use which is otherwise than noncommercial as permitted under Section 4(c) and otherwise waives the right to collect royalties through any statutory or compulsory licensing scheme; and,\n\n         iii. Voluntary License Schemes. The Licensor reserves the right to collect royalties, whether individually or, in the event that the Licensor is a member of a collecting society that administers voluntary licensing schemes, via that society, from any exercise by You of the rights granted under this License that is for a purpose or use which is otherwise than noncommercial as permitted under Section 4(c).\n\n      f. Except as otherwise agreed in writing by the Licensor or as may be otherwise permitted by applicable law, if You Reproduce, Distribute or Publicly Perform the Work either by itself or as part of any Adaptations or Collections, You must not distort, mutilate, modify or take other derogatory action in relation to the Work which would be prejudicial to the Original Author's honor or reputation. Licensor agrees that in those jurisdictions (e.g. Japan), in which any exercise of the right granted in Section 3(b) of this License (the right to make Adaptations) would be deemed to be a distortion, mutilation, modification or other derogatory action prejudicial to the Original Author's honor and reputation, the Licensor will waive or not assert, as appropriate, this Section, to the fullest extent permitted by the applicable national law, to enable You to reasonably exercise Your right under Section 3(b) of this License (right to make Adaptations) but not otherwise.\n\n   5. Representations, Warranties and Disclaimer\n\n   UNLESS OTHERWISE MUTUALLY AGREED TO BY THE PARTIES IN WRITING AND TO THE FULLEST EXTENT PERMITTED BY APPLICABLE LAW, LICENSOR OFFERS THE WORK AS-IS AND MAKES NO REPRESENTATIONS OR WARRANTIES OF ANY KIND CONCERNING THE WORK, EXPRESS, IMPLIED, STATUTORY OR OTHERWISE, INCLUDING, WITHOUT LIMITATION, WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT, OR THE ABSENCE OF LATENT OR OTHER DEFECTS, ACCURACY, OR THE PRESENCE OF ABSENCE OF ERRORS, WHETHER OR NOT DISCOVERABLE. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OF IMPLIED WARRANTIES, SO THIS EXCLUSION MAY NOT APPLY TO YOU.\n\n   6. Limitation on Liability. EXCEPT TO THE EXTENT REQUIRED BY APPLICABLE LAW, IN NO EVENT WILL LICENSOR BE LIABLE TO YOU ON ANY LEGAL THEORY FOR ANY SPECIAL, INCIDENTAL, CONSEQUENTIAL, PUNITIVE OR EXEMPLARY DAMAGES ARISING OUT OF THIS LICENSE OR THE USE OF THE WORK, EVEN IF LICENSOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\n   7. Termination\n\n      a. This License and the rights granted hereunder will terminate automatically upon any breach by You of the terms of this License. Individuals or entities who have received Adaptations or Collections from You under this License, however, will not have their licenses terminated provided such individuals or entities remain in full compliance with those licenses. Sections 1, 2, 5, 6, 7, and 8 will survive any termination of this License.\n\n      b. Subject to the above terms and conditions, the license granted here is perpetual (for the duration of the applicable copyright in the Work). Notwithstanding the above, Licensor reserves the right to release the Work under different license terms or to stop distributing the Work at any time; provided, however that any such election will not serve to withdraw this License (or any other license that has been, or is required to be, granted under the terms of this License), and this License will continue in full force and effect unless terminated as stated above.\n\n   8. Miscellaneous\n\n      a. Each time You Distribute or Publicly Perform the Work or a Collection, the Licensor offers to the recipient a license to the Work on the same terms and conditions as the license granted to You under this License.\n\n      b. Each time You Distribute or Publicly Perform an Adaptation, Licensor offers to the recipient a license to the original Work on the same terms and conditions as the license granted to You under this License.\n\n      c. If any provision of this License is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this License, and without further action by the parties to this agreement, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.\n\n      d. No term or provision of this License shall be deemed waived and no breach consented to unless such waiver or consent shall be in writing and signed by the party to be charged with such waiver or consent.\n\n      e. This License constitutes the entire agreement between the parties with respect to the Work licensed here. There are no understandings, agreements or representations with respect to the Work not specified here. Licensor shall not be bound by any additional provisions that may appear in any communication from You. This License may not be modified without the mutual written agreement of the Licensor and You.\n\n      f. The rights granted under, and the subject matter referenced, in this License were drafted utilizing the terminology of the Berne Convention for the Protection of Literary and Artistic Works (as amended on September 28, 1979), the Rome Convention of 1961, the WIPO Copyright Treaty of 1996, the WIPO Performances and Phonograms Treaty of 1996 and the Universal Copyright Convention (as revised on July 24, 1971). These rights and subject matter take effect in the relevant jurisdiction in which the License terms are sought to be enforced according to the corresponding provisions of the implementation of those treaty provisions in the applicable national law. If the standard suite of rights granted under applicable copyright law includes additional rights not granted under this License, such additional rights are deemed to be included in the License; this License is not intended to restrict the license of any rights under applicable law.\n\nCreative Commons Notice\n\nCreative Commons is not a party to this License, and makes no warranty whatsoever in connection with the Work. Creative Commons will not be liable to You or any party on any legal theory for any damages whatsoever, including without limitation any general, special, incidental or consequential damages arising in connection to this license. Notwithstanding the foregoing two (2) sentences, if Creative Commons has expressly identified itself as the Licensor hereunder, it shall have all rights and obligations of Licensor.\n\nExcept for the limited purpose of indicating to the public that the Work is licensed under the CCPL, Creative Commons does not authorize the use by either party of the trademark \"Creative Commons\" or any related trademark or logo of Creative Commons without the prior written consent of Creative Commons. Any permitted use will be in compliance with Creative Commons' then-current trademark usage guidelines, as may be published on its website or otherwise made available upon request from time to time. For the avoidance of doubt, this trademark restriction does not form part of this License.\n\nCreative Commons may be contacted at http://creativecommons.org/."],"licenseIds":["CC-BY-NC-SA-3.0"],"keywords":["section 1 g","1 g below","g below which","ownership d license","d license elements","noncommercial sharealike e","sharealike e licensor","e licensor means","license f original","f original author","the broadcast g","broadcast g work","g work means","artistic work h","work h you","h you means","previous violation i","violation i publicly","i publicly perform","or images j","images j reproduce","j reproduce means","the rights described","only under i","i the terms","0 us applicable","us applicable license","uri for applicable","for applicable license","compensation in con","in con nection","con nection with","nection with the","4 d may","d may be","attribution parties e","parties e for","c and otherwise","4 c f","c f except","f except as","writing and to","applicable law licensor","law licensor offers","in section 1 g","section 1 g below","1 g below which","g below which by","of ownership d license","ownership d license elements","d license elements means","attribution noncommercial sharealike e","noncommercial sharealike e licensor","sharealike e licensor means","e licensor means the","this license f original","license f original author","f original author means","transmits the broadcast g","the broadcast g work","broadcast g work means","g work means the","or artistic work h","artistic work h you","work h you means","h you means an","a previous violation i","previous violation i publicly","violation i publicly perform","i publicly perform means","sounds or images j","or images j reproduce","images j reproduce means","j reproduce means to","to the rights described","the rights described in","section 4 e 4","adaptation only under i","only under i the","under i the terms","i the terms of","3 0 us applicable","0 us applicable license","us applicable license you","the uri for applicable","uri for applicable license","for applicable license with","license you must keep","applicable license c you","monetary compensation in con","compensation in con nection","in con nection with","con nection with the","nection with the exchange","this section 4 d","section 4 d may","4 d may be","d may be implemented","or attribution parties e","attribution parties e for","parties e for the","section 4 c and","4 c and otherwise","c and otherwise waives","section 4 c f","4 c f except","c f except as","f except as otherwise","parties in writing and","in writing and to","writing and to the","and to the fullest","by applicable law licensor","applicable law licensor offers","law licensor offers the","commons attribution noncommercial sharealike 3","noncommercial sharealike 3 0 unported","listed in section 1 g","in section 1 g below","section 1 g below which","1 g below which by","g below which by reason","transfer of ownership d license","of ownership d license elements","ownership d license elements means","d license elements means the","license attribution noncommercial sharealike e","attribution noncommercial sharealike e licensor","noncommercial sharealike e licensor means","sharealike e licensor means the","e licensor means the individual","of this license f original","this license f original author","license f original author means","f original author means in","that transmits the broadcast g","transmits the broadcast g work","the broadcast g work means","broadcast g work means the","g work means the literary","literary or artistic work h","or artistic work h you","artistic work h you means","work h you means an","h you means an individual","despite a previous violation i","a previous violation i publicly","previous violation i publicly perform","violation i publicly perform means","i publicly perform means to","signs sounds or images j","sounds or images j reproduce","or images j reproduce means","images j reproduce means to","j reproduce means to make","limited to the rights described","to the rights described in","the rights described in section","in section 4 e 4","section 4 e 4 restrictions","an adaptation only under i","adaptation only under i the","only under i the terms","under i the terms of","i the terms of this","terms of this license ii","of this license ii a","g attribution noncommercial sharealike 3","noncommercial sharealike 3 0 us","sharealike 3 0 us applicable","3 0 us applicable license","0 us applicable license you","us applicable license you must","applicable license you must include","or the uri for applicable","the uri for applicable license","uri for applicable license with","for applicable license with every","of the applicable license you","applicable license you must keep","license you must keep intact","the applicable license c you","applicable license c you may","any monetary compensation in con","monetary compensation in con nection","compensation in con nection with","in con nection with the","con nection with the exchange","nection with the exchange of","d if you distribute or","by this section 4 d","this section 4 d may","section 4 d may be","4 d may be implemented","d may be implemented in","and or attribution parties e","or attribution parties e for","attribution parties e for the","parties e for the avoidance","under section 4 c and"]},{"licenseTexts":["Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International Creative Commons Corporation (\"Creative Commons\") is not a law firm and does not provide legal services or legal advice. Distribution of Creative Commons public licenses does not create a lawyer-client or other relationship. Creative Commons makes its licenses and related information available on an \"as-is\" basis. Creative Commons gives no warranties regarding its licenses, any material licensed under their terms and conditions, or any related information. Creative Commons disclaims all liability for damages resulting from their use to the fullest extent possible.\n\nUsing Creative Commons Public Licenses\n\nCreative Commons public licenses provide a standard set of terms and conditions that creators and other rights holders may use to share original works of authorship and other material subject to copyright and certain other rights specified in the public license below. The following considerations are for informational purposes only, are not exhaustive, and do not form part of our licenses.\n\nConsiderations for licensors: Our public licenses are intended for use by those authorized to give the public permission to use material in ways otherwise restricted by copyright and certain other rights. Our licenses are irrevocable. Licensors should read and understand the terms and conditions of the license they choose before applying it. Licensors should also secure all rights necessary before applying our licenses so that the public can reuse the material as expected. Licensors should clearly mark any material not subject to the license. This includes other CC-licensed material, or material used under an exception or limitation to copyright. More considerations for licensors : wiki.creativecommons.org/Considerations_for_licensors\n\nConsiderations for the public: By using one of our public licenses, a licensor grants the public permission to use the licensed material under specified terms and conditions. If the licensor's permission is not necessary for any reason–for example, because of any applicable exception or limitation to copyright–then that use is not regulated by the license. Our licenses grant only permissions under copyright and certain other rights that a licensor has authority to grant. Use of the licensed material may still be restricted for other reasons, including because others have copyright or other rights in the material. A licensor may make special requests, such as asking that all changes be marked or described. Although not required by our licenses, you are encouraged to respect those requests where reasonable. More considerations for the public : wiki.creativecommons.org/Considerations_for_licensees\n\nCreative Commons Attribution-NonCommercial-ShareAlike 4.0 International Public License\n\nBy exercising the Licensed Rights (defined below), You accept and agree to be bound by the terms and conditions of this Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International Public License (\"Public License\"). To the extent this Public License may be interpreted as a contract, You are granted the Licensed Rights in consideration of Your acceptance of these terms and conditions, and the Licensor grants You such rights in consideration of benefits the Licensor receives from making the Licensed Material available under these terms and conditions.\n\nSection 1 – Definitions.\n\n   a. Adapted Material means material subject to Copyright and Similar Rights that is derived from or based upon the Licensed Material and in which the Licensed Material is translated, altered, arranged, transformed, or otherwise modified in a manner requiring permission under the Copyright and Similar Rights held by the Licensor. For purposes of this Public License, where the Licensed Material is a musical work, performance, or sound recording, Adapted Material is always produced where the Licensed Material is synched in timed relation with a moving image.\n\n   b. Adapter's License means the license You apply to Your Copyright and Similar Rights in Your contributions to Adapted Material in accordance with the terms and conditions of this Public License.\n\n   c. BY-NC-SA Compatible License means a license listed at creativecommons.org/compatiblelicenses, approved by Creative Commons as essentially the equivalent of this Public License.\n\n   d. Copyright and Similar Rights means copyright and/or similar rights closely related to copyright including, without limitation, performance, broadcast, sound recording, and Sui Generis Database Rights, without regard to how the rights are labeled or categorized. For purposes of this Public License, the rights specified in Section 2(b)(1)-(2) are not Copyright and Similar Rights.\n\n   e. Effective Technological Measures means those measures that, in the absence of proper authority, may not be circumvented under laws fulfilling obligations under Article 11 of the WIPO Copyright Treaty adopted on December 20, 1996, and/or similar international agreements.\n\n   f. Exceptions and Limitations means fair use, fair dealing, and/or any other exception or limitation to Copyright and Similar Rights that applies to Your use of the Licensed Material.\n\n   g. License Elements means the license attributes listed in the name of a Creative Commons Public License. The License Elements of this Public License are Attribution, NonCommercial, and ShareAlike.\n\n   h. Licensed Material means the artistic or literary work, database, or other material to which the Licensor applied this Public License.\n\n   i. Licensed Rights means the rights granted to You subject to the terms and conditions of this Public License, which are limited to all Copyright and Similar Rights that apply to Your use of the Licensed Material and that the Licensor has authority to license.\n\n   j. Licensor means the individual(s) or entity(ies) granting rights under this Public License.\n\n   k. NonCommercial means not primarily intended for or directed towards commercial advantage or monetary compensation. For purposes of this Public License, the exchange of the Licensed Material for other material subject to Copyright and Similar Rights by digital file-sharing or similar means is NonCommercial provided there is no payment of monetary compensation in connection with the exchange.\n\n   l. Share means to provide material to the public by any means or process that requires permission under the Licensed Rights, such as reproduction, public display, public performance, distribution, dissemination, communication, or importation, and to make material available to the public including in ways that members of the public may access the material from a place and at a time individually chosen by them.\n\n   m. Sui Generis Database Rights means rights other than copyright resulting from Directive 96/9/EC of the European Parliament and of the Council of 11 March 1996 on the legal protection of databases, as amended and/or succeeded, as well as other essentially equivalent rights anywhere in the world.\n\n   n. You means the individual or entity exercising the Licensed Rights under this Public License. Your has a corresponding meaning.\n\nSection 2 – Scope.\n\n   a. License grant.\n\n      1. Subject to the terms and conditions of this Public License, the Licensor hereby grants You a worldwide, royalty-free, non-sublicensable, non-exclusive, irrevocable license to exercise the Licensed Rights in the Licensed Material to:\n\n         A. reproduce and Share the Licensed Material, in whole or in part, for NonCommercial purposes only; and\n\n         B. produce, reproduce, and Share Adapted Material for NonCommercial purposes only.\n\n      2. Exceptions and Limitations. For the avoidance of doubt, where Exceptions and Limitations apply to Your use, this Public License does not apply, and You do not need to comply with its terms and conditions.\n\n      3. Term. The term of this Public License is specified in Section 6(a).\n\n      4. Media and formats; technical modifications allowed. The Licensor authorizes You to exercise the Licensed Rights in all media and formats whether now known or hereafter created, and to make technical modifications necessary to do so. The Licensor waives and/or agrees not to assert any right or authority to forbid You from making technical modifications necessary to exercise the Licensed Rights, including technical modifications necessary to circumvent Effective Technological Measures. For purposes of this Public License, simply making modifications authorized by this Section 2(a)(4) never produces Adapted Material.\n\n      5. Downstream recipients.\n\n         A. Offer from the Licensor – Licensed Material. Every recipient of the Licensed Material automatically receives an offer from the Licensor to exercise the Licensed Rights under the terms and conditions of this Public License.\n\n         B. Additional offer from the Licensor – Adapted Material. Every recipient of Adapted Material from You automatically receives an offer from the Licensor to exercise the Licensed Rights in the Adapted Material under the conditions of the Adapter's License You apply.\n\n         C. No downstream restrictions. You may not offer or impose any additional or different terms or conditions on, or apply any Effective Technological Measures to, the Licensed Material if doing so restricts exercise of the Licensed Rights by any recipient of the Licensed Material.\n\n      6. No endorsement. Nothing in this Public License constitutes or may be construed as permission to assert or imply that You are, or that Your use of the Licensed Material is, connected with, or sponsored, endorsed, or granted official status by, the Licensor or others designated to receive attribution as provided in Section 3(a)(1)(A)(i).\n\n   b. Other rights.\n\n      1. Moral rights, such as the right of integrity, are not licensed under this Public License, nor are publicity, privacy, and/or other similar personality rights; however, to the extent possible, the Licensor waives and/or agrees not to assert any such rights held by the Licensor to the limited extent necessary to allow You to exercise the Licensed Rights, but not otherwise.\n\n      2. Patent and trademark rights are not licensed under this Public License.\n\n      3. To the extent possible, the Licensor waives any right to collect royalties from You for the exercise of the Licensed Rights, whether directly or through a collecting society under any voluntary or waivable statutory or compulsory licensing scheme. In all other cases the Licensor expressly reserves any right to collect such royalties, including when the Licensed Material is used other than for NonCommercial purposes.\n\nSection 3 – License Conditions.\n\nYour exercise of the Licensed Rights is expressly made subject to the following conditions.\n\n   a. Attribution.\n\n      1. If You Share the Licensed Material (including in modified form), You must:\n\n         A. retain the following if it is supplied by the Licensor with the Licensed Material:\n\n            i. identification of the creator(s) of the Licensed Material and any others designated to receive attribution, in any reasonable manner requested by the Licensor (including by pseudonym if designated);\n\n            ii. a copyright notice;\n\n            iii. a notice that refers to this Public License;\n\n            iv. a notice that refers to the disclaimer of warranties;\n\n            \n\n            v. a URI or hyperlink to the Licensed Material to the extent reasonably practicable;\n\n         B. indicate if You modified the Licensed Material and retain an indication of any previous modifications; and\n\n         C. indicate the Licensed Material is licensed under this Public License, and include the text of, or the URI or hyperlink to, this Public License.\n\n      2. You may satisfy the conditions in Section 3(a)(1) in any reasonable manner based on the medium, means, and context in which You Share the Licensed Material. For example, it may be reasonable to satisfy the conditions by providing a URI or hyperlink to a resource that includes the required information.\n\n      3. If requested by the Licensor, You must remove any of the information required by Section 3(a)(1)(A) to the extent reasonably practicable.\n\n   b. ShareAlike.In addition to the conditions in Section 3(a), if You Share Adapted Material You produce, the following conditions also apply.\n\n      1. The Adapter's License You apply must be a Creative Commons license with the same License Elements, this version or later, or a BY-NC-SA Compatible License.\n\n      2. You must include the text of, or the URI or hyperlink to, the Adapter's License You apply. You may satisfy this condition in any reasonable manner based on the medium, means, and context in which You Share Adapted Material.\n\n      3. You may not offer or impose any additional or different terms or conditions on, or apply any Effective Technological Measures to, Adapted Material that restrict exercise of the rights granted under the Adapter's License You apply.\n\nSection 4 – Sui Generis Database Rights.\n\nWhere the Licensed Rights include Sui Generis Database Rights that apply to Your use of the Licensed Material:\n\n   a. for the avoidance of doubt, Section 2(a)(1) grants You the right to extract, reuse, reproduce, and Share all or a substantial portion of the contents of the database for NonCommercial purposes only;\n\n   b. if You include all or a substantial portion of the database contents in a database in which You have Sui Generis Database Rights, then the database in which You have Sui Generis Database Rights (but not its individual contents) is Adapted Material, including for purposes of Section 3(b); and\n\n   c. You must comply with the conditions in Section 3(a) if You Share all or a substantial portion of the contents of the database.\n\n   For the avoidance of doubt, this Section 4 supplements and does not replace Your obligations under this Public License where the Licensed Rights include other Copyright and Similar Rights.\n\nSection 5 – Disclaimer of Warranties and Limitation of Liability.\n\n   a. Unless otherwise separately undertaken by the Licensor, to the extent possible, the Licensor offers the Licensed Material as-is and as-available, and makes no representations or warranties of any kind concerning the Licensed Material, whether express, implied, statutory, or other. This includes, without limitation, warranties of title, merchantability, fitness for a particular purpose, non-infringement, absence of latent or other defects, accuracy, or the presence or absence of errors, whether or not known or discoverable. Where disclaimers of warranties are not allowed in full or in part, this disclaimer may not apply to You.\n\n   b. To the extent possible, in no event will the Licensor be liable to You on any legal theory (including, without limitation, negligence) or otherwise for any direct, special, indirect, incidental, consequential, punitive, exemplary, or other losses, costs, expenses, or damages arising out of this Public License or use of the Licensed Material, even if the Licensor has been advised of the possibility of such losses, costs, expenses, or damages. Where a limitation of liability is not allowed in full or in part, this limitation may not apply to You.\n\n   c. The disclaimer of warranties and limitation of liability provided above shall be interpreted in a manner that, to the extent possible, most closely approximates an absolute disclaimer and waiver of all liability.\n\nSection 6 – Term and Termination.\n\n   a. This Public License applies for the term of the Copyright and Similar Rights licensed here. However, if You fail to comply with this Public License, then Your rights under this Public License terminate automatically.\n\n   b. Where Your right to use the Licensed Material has terminated under Section 6(a), it reinstates:\n\n      1. automatically as of the date the violation is cured, provided it is cured within 30 days of Your discovery of the violation; or\n\n      2. upon express reinstatement by the Licensor.\n\n   For the avoidance of doubt, this Section 6(b) does not affect any right the Licensor may have to seek remedies for Your violations of this Public License.\n\n   c. For the avoidance of doubt, the Licensor may also offer the Licensed Material under separate terms or conditions or stop distributing the Licensed Material at any time; however, doing so will not terminate this Public License.\n\n   d. Sections 1, 5, 6, 7, and 8 survive termination of this Public License.\n\nSection 7 – Other Terms and Conditions.\n\n   a. The Licensor shall not be bound by any additional or different terms or conditions communicated by You unless expressly agreed.\n\n   b. Any arrangements, understandings, or agreements regarding the Licensed Material not stated herein are separate from and independent of the terms and conditions of this Public License.\n\nSection 8 – Interpretation.\n\n   a. For the avoidance of doubt, this Public License does not, and shall not be interpreted to, reduce, limit, restrict, or impose conditions on any use of the Licensed Material that could lawfully be made without permission under this Public License.\n\n   b. To the extent possible, if any provision of this Public License is deemed unenforceable, it shall be automatically reformed to the minimum extent necessary to make it enforceable. If the provision cannot be reformed, it shall be severed from this Public License without affecting the enforceability of the remaining terms and conditions.\n\n   c. No term or condition of this Public License will be waived and no failure to comply consented to unless expressly agreed to by the Licensor.\n\n   d. Nothing in this Public License constitutes or may be interpreted as a limitation upon, or waiver of, any privileges and immunities that apply to the Licensor or You, including from the legal processes of any jurisdiction or authority.\n\nCreative Commons is not a party to its public licenses. Notwithstanding, Creative Commons may elect to apply one of its public licenses to material it publishes and in those instances will be considered the \"Licensor.\" The text of the Creative Commons public licenses is dedicated to the public domain under the CC0 Public Domain Dedication. Except for the limited purpose of indicating that material is shared under a Creative Commons public license or as otherwise permitted by the Creative Commons policies published at creativecommons.org/policies, Creative Commons does not authorize the use of the trademark \"Creative Commons\" or any other trademark or logo of Creative Commons without its prior written consent including, without limitation, in connection with any unauthorized modifications to any of its public licenses or any other arrangements, understandings, or agreements concerning use of licensed material. For the avoidance of doubt, this paragraph does not form part of the public licenses.\n\nCreative Commons may be contacted at creativecommons.org."],"licenseIds":["CC-BY-NC-SA-4.0"],"keywords":["c by nc","are attribution noncommercial","attribution noncommercial and","noncommercial and sharealike","license k noncommercial","k noncommercial means","the exchange l","exchange l share","l share means","by them m","them m sui","m sui generis","the world n","world n you","n you means","a by nc","license c by nc","c by nc sa","license are attribution noncommercial","are attribution noncommercial and","attribution noncommercial and sharealike","noncommercial and sharealike h","public license k noncommercial","license k noncommercial means","k noncommercial means not","with the exchange l","the exchange l share","exchange l share means","l share means to","chosen by them m","by them m sui","them m sui generis","m sui generis database","in the world n","the world n you","world n you means","n you means the","or a by nc","a by nc sa","public license c by nc","license c by nc sa","c by nc sa compatible","nc sa compatible license means","public license are attribution noncommercial","license are attribution noncommercial and","are attribution noncommercial and sharealike","attribution noncommercial and sharealike h","noncommercial and sharealike h licensed","this public license k noncommercial","public license k noncommercial means","license k noncommercial means not","k noncommercial means not primarily","connection with the exchange l","with the exchange l share","the exchange l share means","exchange l share means to","l share means to provide","individually chosen by them m","chosen by them m sui","by them m sui generis","them m sui generis database","m sui generis database rights","anywhere in the world n","in the world n you","the world n you means","world n you means the","n you means the individual","later or a by nc","or a by nc sa","a by nc sa compatible","nc sa compatible license 2"]},{"licenseTexts":["Creative Commons Attribution-NoDerivs 1.0 CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE LEGAL SERVICES. DISTRIBUTION OF THIS DRAFT LICENSE DOES NOT CREATE AN ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS INFORMATION ON AN \"AS-IS\" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES REGARDING THE INFORMATION PROVIDED, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM ITS USE.\n\nLicense\n\nTHE WORK (AS DEFINED BELOW) IS PROVIDED UNDER THE TERMS OF THIS CREATIVE COMMONS PUBLIC LICENSE (\"CCPL\" OR \"LICENSE\"). THE WORK IS PROTECTED BY COPYRIGHT AND/OR OTHER APPLICABLE LAW. ANY USE OF THE WORK OTHER THAN AS AUTHORIZED UNDER THIS LICENSE IS PROHIBITED.\n\nBY EXERCISING ANY RIGHTS TO THE WORK PROVIDED HERE, YOU ACCEPT AND AGREE TO BE BOUND BY THE TERMS OF THIS LICENSE. THE LICENSOR GRANTS YOU THE RIGHTS CONTAINED HERE IN CONSIDERATION OF YOUR ACCEPTANCE OF SUCH TERMS AND CONDITIONS.\n\n   1. Definitions\n\n      a. \"Collective Work\" means a work, such as a periodical issue, anthology or encyclopedia, in which the Work in its entirety in unmodified form, along with a number of other contributions, constituting separate and independent works in themselves, are assembled into a collective whole. A work that constitutes a Collective Work will not be considered a Derivative Work (as defined below) for the purposes of this License.\n\n      b. \"Derivative Work\" means a work based upon the Work or upon the Work and other pre-existing works, such as a translation, musical arrangement, dramatization, fictionalization, motion picture version, sound recording, art reproduction, abridgment, condensation, or any other form in which the Work may be recast, transformed, or adapted, except that a work that constitutes a Collective Work will not be considered a Derivative Work for the purpose of this License.\n\n      c. \"Licensor\" means the individual or entity that offers the Work under the terms of this License.\n\n      d. \"Original Author\" means the individual or entity who created the Work.\n\n      e. \"Work\" means the copyrightable work of authorship offered under the terms of this License.\n\n      f. \"You\" means an individual or entity exercising rights under this License who has not previously violated the terms of this License with respect to the Work, or who has received express permission from the Licensor to exercise rights under this License despite a previous violation.\n\n   2. Fair Use Rights. Nothing in this license is intended to reduce, limit, or restrict any rights arising from fair use, first sale or other limitations on the exclusive rights of the copyright owner under copyright law or other applicable laws.\n\n   3. License Grant. Subject to the terms and conditions of this License, Licensor hereby grants You a worldwide, royalty-free, non-exclusive, perpetual (for the duration of the applicable copyright) license to exercise the rights in the Work as stated below:\n\n      a. to reproduce the Work, to incorporate the Work into one or more Collective Works, and to reproduce the Work as incorporated in the Collective Works;\n\n      b. to distribute copies or phonorecords of, display publicly, perform publicly, and perform publicly by means of a digital audio transmission the Work including as incorporated in Collective Works;\n\n   The above rights may be exercised in all media and formats whether now known or hereafter devised. The above rights include the right to make such modifications as are technically necessary to exercise the rights in other media and formats. All rights not expressly granted by Licensor are hereby reserved.\n\n   4. Restrictions. The license granted in Section 3 above is expressly made subject to and limited by the following restrictions:\n\n      a. You may distribute, publicly display, publicly perform, or publicly digitally perform the Work only under the terms of this License, and You must include a copy of, or the Uniform Resource Identifier for, this License with every copy or phonorecord of the Work You distribute, publicly display, publicly perform, or publicly digitally perform. You may not offer or impose any terms on the Work that alter or restrict the terms of this License or the recipients' exercise of the rights granted hereunder. You may not sublicense the Work. You must keep intact all notices that refer to this License and to the disclaimer of warranties. You may not distribute, publicly display, publicly perform, or publicly digitally perform the Work with any technological measures that control access or use of the Work in a manner inconsistent with the terms of this License Agreement. The above applies to the Work as incorporated in a Collective Work, but this does not require the Collective Work apart from the Work itself to be made subject to the terms of this License. If You create a Collective Work, upon notice from any Licensor You must, to the extent practicable, remove from the Collective Work any reference to such Licensor or the Original Author, as requested.\n\n      b. If you distribute, publicly display, publicly perform, or publicly digitally perform the Work or any Collective Works, You must keep intact all copyright notices for the Work and give the Original Author credit reasonable to the medium or means You are utilizing by conveying the name (or pseudonym if applicable) of the Original Author if supplied; the title of the Work if supplied. Such credit may be implemented in any reasonable manner; provided, however, that in the case of a Collective Work, at a minimum such credit will appear where any other comparable authorship credit appears and in a manner at least as prominent as such other comparable authorship credit.\n\n   5. Representations, Warranties and Disclaimer\n\n      a. By offering the Work for public release under this License, Licensor represents and warrants that, to the best of Licensor's knowledge after reasonable inquiry:\n\n         i. Licensor has secured all rights in the Work necessary to grant the license rights hereunder and to permit the lawful exercise of the rights granted hereunder without You having any obligation to pay any royalties, compulsory license fees, residuals or any other payments;\n\n         ii. The Work does not infringe the copyright, trademark, publicity rights, common law rights or any other right of any third party or constitute defamation, invasion of privacy or other tortious injury to any third party.\n\n      b. EXCEPT AS EXPRESSLY STATED IN THIS LICENSE OR OTHERWISE AGREED IN WRITING OR REQUIRED BY APPLICABLE LAW, THE WORK IS LICENSED ON AN \"AS IS\" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES REGARDING THE CONTENTS OR ACCURACY OF THE WORK.\n\n   6. Limitation on Liability. EXCEPT TO THE EXTENT REQUIRED BY APPLICABLE LAW, AND EXCEPT FOR DAMAGES ARISING FROM LIABILITY TO A THIRD PARTY RESULTING FROM BREACH OF THE WARRANTIES IN SECTION 5, IN NO EVENT WILL LICENSOR BE LIABLE TO YOU ON ANY LEGAL THEORY FOR ANY SPECIAL, INCIDENTAL, CONSEQUENTIAL, PUNITIVE OR EXEMPLARY DAMAGES ARISING OUT OF THIS LICENSE OR THE USE OF THE WORK, EVEN IF LICENSOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\n   7. Termination\n\n      a. This License and the rights granted hereunder will terminate automatically upon any breach by You of the terms of this License. Individuals or entities who have received Collective Works from You under this License, however, will not have their licenses terminated provided such individuals or entities remain in full compliance with those licenses. Sections 1, 2, 5, 6, 7, and 8 will survive any termination of this License.\n\n      b. Subject to the above terms and conditions, the license granted here is perpetual (for the duration of the applicable copyright in the Work). Notwithstanding the above, Licensor reserves the right to release the Work under different license terms or to stop distributing the Work at any time; provided, however that any such election will not serve to withdraw this License (or any other license that has been, or is required to be, granted under the terms of this License), and this License will continue in full force and effect unless terminated as stated above.\n\n   8. Miscellaneous\n\n      a. Each time You distribute or publicly digitally perform the Work or a Collective Work, the Licensor offers to the recipient a license to the Work on the same terms and conditions as the license granted to You under this License.\n\n      b. If any provision of this License is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this License, and without further action by the parties to this agreement, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.\n\n      c. No term or provision of this License shall be deemed waived and no breach consented to unless such waiver or consent shall be in writing and signed by the party to be charged with such waiver or consent.\n\n      d. This License constitutes the entire agreement between the parties with respect to the Work licensed here. There are no understandings, agreements or representations with respect to the Work not specified here. Licensor shall not be bound by any additional provisions that may appear in any communication from You. This License may not be modified without the mutual written agreement of the Licensor and You.\n\nCreative Commons is not a party to this License, and makes no warranty whatsoever in connection with the Work. Creative Commons will not be liable to You or any party on any legal theory for any damages whatsoever, including without limitation any general, special, incidental or consequential damages arising in connection to this license. Notwithstanding the foregoing two (2) sentences, if Creative Commons has expressly identified itself as the Licensor hereunder, it shall have all rights and obligations of Licensor.\n\nExcept for the limited purpose of indicating to the public that the Work is licensed under the CCPL, neither party will use the trademark \"Creative Commons\" or any related trademark or logo of Creative Commons without the prior written consent of Creative Commons. Any permitted use will be in compliance with Creative Commons' then-current trademark usage guidelines, as may be published on its website or otherwise made available upon request from time to time.\n\nCreative Commons may be contacted at http://creativecommons.org/."],"licenseIds":["CC-BY-ND-1.0"],"keywords":["attribution noderivs 1","noderivs 1 0","commons attribution noderivs 1","attribution noderivs 1 0","noderivs 1 0 creative","creative commons attribution noderivs 1","commons attribution noderivs 1 0","attribution noderivs 1 0 creative","noderivs 1 0 creative commons"]},{"licenseTexts":["Creative Commons Attribution-NoDerivs 2.0 CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE LEGAL SERVICES. DISTRIBUTION OF THIS LICENSE DOES NOT CREATE AN ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS INFORMATION ON AN \"AS-IS\" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES REGARDING THE INFORMATION PROVIDED, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM ITS USE.\n\nLicense\n\nTHE WORK (AS DEFINED BELOW) IS PROVIDED UNDER THE TERMS OF THIS CREATIVE COMMONS PUBLIC LICENSE (\"CCPL\" OR \"LICENSE\"). THE WORK IS PROTECTED BY COPYRIGHT AND/OR OTHER APPLICABLE LAW. ANY USE OF THE WORK OTHER THAN AS AUTHORIZED UNDER THIS LICENSE OR COPYRIGHT LAW IS PROHIBITED.\n\nBY EXERCISING ANY RIGHTS TO THE WORK PROVIDED HERE, YOU ACCEPT AND AGREE TO BE BOUND BY THE TERMS OF THIS LICENSE. THE LICENSOR GRANTS YOU THE RIGHTS CONTAINED HERE IN CONSIDERATION OF YOUR ACCEPTANCE OF SUCH TERMS AND CONDITIONS.\n\n   1. Definitions\n\n      a. \"Collective Work\" means a work, such as a periodical issue, anthology or encyclopedia, in which the Work in its entirety in unmodified form, along with a number of other contributions, constituting separate and independent works in themselves, are assembled into a collective whole. A work that constitutes a Collective Work will not be considered a Derivative Work (as defined below) for the purposes of this License.\n\n      b. \"Derivative Work\" means a work based upon the Work or upon the Work and other pre-existing works, such as a translation, musical arrangement, dramatization, fictionalization, motion picture version, sound recording, art reproduction, abridgment, condensation, or any other form in which the Work may be recast, transformed, or adapted, except that a work that constitutes a Collective Work will not be considered a Derivative Work for the purpose of this License. For the avoidance of doubt, where the Work is a musical composition or sound recording, the synchronization of the Work in timed-relation with a moving image (\"synching\") will be considered a Derivative Work for the purpose of this License.\n\n      c. \"Licensor\" means the individual or entity that offers the Work under the terms of this License.\n\n      d. \"Original Author\" means the individual or entity who created the Work.\n\n      e. \"Work\" means the copyrightable work of authorship offered under the terms of this License.\n\n      f. \"You\" means an individual or entity exercising rights under this License who has not previously violated the terms of this License with respect to the Work, or who has received express permission from the Licensor to exercise rights under this License despite a previous violation.\n\n   2. Fair Use Rights. Nothing in this license is intended to reduce, limit, or restrict any rights arising from fair use, first sale or other limitations on the exclusive rights of the copyright owner under copyright law or other applicable laws.\n\n   3. License Grant. Subject to the terms and conditions of this License, Licensor hereby grants You a worldwide, royalty-free, non-exclusive, perpetual (for the duration of the applicable copyright) license to exercise the rights in the Work as stated below:\n\n      a. to reproduce the Work, to incorporate the Work into one or more Collective Works, and to reproduce the Work as incorporated in the Collective Works;\n\n      b. to distribute copies or phonorecords of, display publicly, perform publicly, and perform publicly by means of a digital audio transmission the Work including as incorporated in Collective Works.\n\n      c. For the avoidance of doubt, where the work is a musical composition:\n\n         i. Performance Royalties Under Blanket Licenses. Licensor waives the exclusive right to collect, whether individually or via a performance rights society (e.g. ASCAP, BMI, SESAC), royalties for the public performance or public digital performance (e.g. webcast) of the Work.\n\n         ii. Mechanical Rights and Statutory Royalties. Licensor waives the exclusive right to collect, whether individually or via a music rights society or designated agent (e.g. Harry Fox Agency), royalties for any phonorecord You create from the Work (\"cover version\") and distribute, subject to the compulsory license created by 17 USC Section 115 of the US Copyright Act (or the equivalent in other jurisdictions).\n\n      d. Webcasting Rights and Statutory Royalties. For the avoidance of doubt, where the Work is a sound recording, Licensor waives the exclusive right to collect, whether individually or via a performance-rights society (e.g. SoundExchange), royalties for the public digital performance (e.g. webcast) of the Work, subject to the compulsory license created by 17 USC Section 114 of the US Copyright Act (or the equivalent in other jurisdictions).\n\n   \n\n   The above rights may be exercised in all media and formats whether now known or hereafter devised. The above rights include the right to make such modifications as are technically necessary to exercise the rights in other media and formats, but otherwise you have no rights to make Derivative Works. All rights not expressly granted by Licensor are hereby reserved.\n\n   4. Restrictions. The license granted in Section 3 above is expressly made subject to and limited by the following restrictions:\n\n      a. You may distribute, publicly display, publicly perform, or publicly digitally perform the Work only under the terms of this License, and You must include a copy of, or the Uniform Resource Identifier for, this License with every copy or phonorecord of the Work You distribute, publicly display, publicly perform, or publicly digitally perform. You may not offer or impose any terms on the Work that alter or restrict the terms of this License or the recipients' exercise of the rights granted hereunder. You may not sublicense the Work. You must keep intact all notices that refer to this License and to the disclaimer of warranties. You may not distribute, publicly display, publicly perform, or publicly digitally perform the Work with any technological measures that control access or use of the Work in a manner inconsistent with the terms of this License Agreement. The above applies to the Work as incorporated in a Collective Work, but this does not require the Collective Work apart from the Work itself to be made subject to the terms of this License. If You create a Collective Work, upon notice from any Licensor You must, to the extent practicable, remove from the Collective Work any reference to such Licensor or the Original Author, as requested.\n\n      b. If you distribute, publicly display, publicly perform, or publicly digitally perform the Work or Collective Works, You must keep intact all copyright notices for the Work and give the Original Author credit reasonable to the medium or means You are utilizing by conveying the name (or pseudonym if applicable) of the Original Author if supplied; the title of the Work if supplied; and to the extent reasonably practicable, the Uniform Resource Identifier, if any, that Licensor specifies to be associated with the Work, unless such URI does not refer to the copyright notice or licensing information for the Work. Such credit may be implemented in any reasonable manner; provided, however, that in the case of a Collective Work, at a minimum such credit will appear where any other comparable authorship credit appears and in a manner at least as prominent as such other comparable authorship credit.\n\n   5. Representations, Warranties and Disclaimer\n\n   UNLESS OTHERWISE MUTUALLY AGREED TO BY THE PARTIES IN WRITING, LICENSOR OFFERS THE WORK AS-IS AND MAKES NO REPRESENTATIONS OR WARRANTIES OF ANY KIND CONCERNING THE MATERIALS, EXPRESS, IMPLIED, STATUTORY OR OTHERWISE, INCLUDING, WITHOUT LIMITATION, WARRANTIES OF TITLE, MERCHANTIBILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT, OR THE ABSENCE OF LATENT OR OTHER DEFECTS, ACCURACY, OR THE PRESENCE OF ABSENCE OF ERRORS, WHETHER OR NOT DISCOVERABLE. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OF IMPLIED WARRANTIES, SO SUCH EXCLUSION MAY NOT APPLY TO YOU.\n\n   6. Limitation on Liability. EXCEPT TO THE EXTENT REQUIRED BY APPLICABLE LAW, IN NO EVENT WILL LICENSOR BE LIABLE TO YOU ON ANY LEGAL THEORY FOR ANY SPECIAL, INCIDENTAL, CONSEQUENTIAL, PUNITIVE OR EXEMPLARY DAMAGES ARISING OUT OF THIS LICENSE OR THE USE OF THE WORK, EVEN IF LICENSOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\n   7. Termination\n\n      a. This License and the rights granted hereunder will terminate automatically upon any breach by You of the terms of this License. Individuals or entities who have received Collective Works from You under this License, however, will not have their licenses terminated provided such individuals or entities remain in full compliance with those licenses. Sections 1, 2, 5, 6, 7, and 8 will survive any termination of this License.\n\n      b. Subject to the above terms and conditions, the license granted here is perpetual (for the duration of the applicable copyright in the Work). Notwithstanding the above, Licensor reserves the right to release the Work under different license terms or to stop distributing the Work at any time; provided, however that any such election will not serve to withdraw this License (or any other license that has been, or is required to be, granted under the terms of this License), and this License will continue in full force and effect unless terminated as stated above.\n\n   8. Miscellaneous\n\n      a. Each time You distribute or publicly digitally perform the Work, the Licensor offers to the recipient a license to the Work on the same terms and conditions as the license granted to You under this License.\n\n      b. If any provision of this License is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this License, and without further action by the parties to this agreement, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.\n\n      c. No term or provision of this License shall be deemed waived and no breach consented to unless such waiver or consent shall be in writing and signed by the party to be charged with such waiver or consent.\n\n      d. This License constitutes the entire agreement between the parties with respect to the Work licensed here. There are no understandings, agreements or representations with respect to the Work not specified here. Licensor shall not be bound by any additional provisions that may appear in any communication from You. This License may not be modified without the mutual written agreement of the Licensor and You.\n\nCreative Commons is not a party to this License, and makes no warranty whatsoever in connection with the Work. Creative Commons will not be liable to You or any party on any legal theory for any damages whatsoever, including without limitation any general, special, incidental or consequential damages arising in connection to this license. Notwithstanding the foregoing two (2) sentences, if Creative Commons has expressly identified itself as the Licensor hereunder, it shall have all rights and obligations of Licensor.\n\nExcept for the limited purpose of indicating to the public that the Work is licensed under the CCPL, neither party will use the trademark \"Creative Commons\" or any related trademark or logo of Creative Commons without the prior written consent of Creative Commons. Any permitted use will be in compliance with Creative Commons' then-current trademark usage guidelines, as may be published on its website or otherwise made available upon request from time to time.\n\nCreative Commons may be contacted at https://creativecommons.org/."],"licenseIds":["CC-BY-ND-2.0"],"keywords":["contacted at https","at https creativecommons","https creativecommons org","attribution noderivs 2 0","be contacted at https","contacted at https creativecommons","at https creativecommons org","commons attribution noderivs 2 0","attribution noderivs 2 0 creative","may be contacted at https","be contacted at https creativecommons","contacted at https creativecommons org"]},{"licenseTexts":["Creative Commons Attribution-NoDerivs 2.5 CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE LEGAL SERVICES. DISTRIBUTION OF THIS LICENSE DOES NOT CREATE AN ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS INFORMATION ON AN \"AS-IS\" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES REGARDING THE INFORMATION PROVIDED, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM ITS USE.\n\nLicense\n\nTHE WORK (AS DEFINED BELOW) IS PROVIDED UNDER THE TERMS OF THIS CREATIVE COMMONS PUBLIC LICENSE (\"CCPL\" OR \"LICENSE\"). THE WORK IS PROTECTED BY COPYRIGHT AND/OR OTHER APPLICABLE LAW. ANY USE OF THE WORK OTHER THAN AS AUTHORIZED UNDER THIS LICENSE OR COPYRIGHT LAW IS PROHIBITED.\n\nBY EXERCISING ANY RIGHTS TO THE WORK PROVIDED HERE, YOU ACCEPT AND AGREE TO BE BOUND BY THE TERMS OF THIS LICENSE. THE LICENSOR GRANTS YOU THE RIGHTS CONTAINED HERE IN CONSIDERATION OF YOUR ACCEPTANCE OF SUCH TERMS AND CONDITIONS.\n\n   1. Definitions\n\n      a. \"Collective Work\" means a work, such as a periodical issue, anthology or encyclopedia, in which the Work in its entirety in unmodified form, along with a number of other contributions, constituting separate and independent works in themselves, are assembled into a collective whole. A work that constitutes a Collective Work will not be considered a Derivative Work (as defined below) for the purposes of this License.\n\n      b. \"Derivative Work\" means a work based upon the Work or upon the Work and other pre-existing works, such as a translation, musical arrangement, dramatization, fictionalization, motion picture version, sound recording, art reproduction, abridgment, condensation, or any other form in which the Work may be recast, transformed, or adapted, except that a work that constitutes a Collective Work will not be considered a Derivative Work for the purpose of this License. For the avoidance of doubt, where the Work is a musical composition or sound recording, the synchronization of the Work in timed-relation with a moving image (\"synching\") will be considered a Derivative Work for the purpose of this License.\n\n      c. \"Licensor\" means the individual or entity that offers the Work under the terms of this License.\n\n      d. \"Original Author\" means the individual or entity who created the Work.\n\n      e. \"Work\" means the copyrightable work of authorship offered under the terms of this License.\n\n      f. \"You\" means an individual or entity exercising rights under this License who has not previously violated the terms of this License with respect to the Work, or who has received express permission from the Licensor to exercise rights under this License despite a previous violation.\n\n   2. Fair Use Rights. Nothing in this license is intended to reduce, limit, or restrict any rights arising from fair use, first sale or other limitations on the exclusive rights of the copyright owner under copyright law or other applicable laws.\n\n   3. License Grant. Subject to the terms and conditions of this License, Licensor hereby grants You a worldwide, royalty-free, non-exclusive, perpetual (for the duration of the applicable copyright) license to exercise the rights in the Work as stated below:\n\n      a. to reproduce the Work, to incorporate the Work into one or more Collective Works, and to reproduce the Work as incorporated in the Collective Works;\n\n      b. to distribute copies or phonorecords of, display publicly, perform publicly, and perform publicly by means of a digital audio transmission the Work including as incorporated in Collective Works.\n\n      c. For the avoidance of doubt, where the work is a musical composition:\n\n         i. Performance Royalties Under Blanket Licenses. Licensor waives the exclusive right to collect, whether individually or via a performance rights society (e.g. ASCAP, BMI, SESAC), royalties for the public performance or public digital performance (e.g. webcast) of the Work.\n\n         ii. Mechanical Rights and Statutory Royalties. Licensor waives the exclusive right to collect, whether individually or via a music rights society or designated agent (e.g. Harry Fox Agency), royalties for any phonorecord You create from the Work (\"cover version\") and distribute, subject to the compulsory license created by 17 USC Section 115 of the US Copyright Act (or the equivalent in other jurisdictions).\n\n      d. Webcasting Rights and Statutory Royalties. For the avoidance of doubt, where the Work is a sound recording, Licensor waives the exclusive right to collect, whether individually or via a performance-rights society (e.g. SoundExchange), royalties for the public digital performance (e.g. webcast) of the Work, subject to the compulsory license created by 17 USC Section 114 of the US Copyright Act (or the equivalent in other jurisdictions).\n\n   The above rights may be exercised in all media and formats whether now known or hereafter devised. The above rights include the right to make such modifications as are technically necessary to exercise the rights in other media and formats, but otherwise you have no rights to make Derivative Works. All rights not expressly granted by Licensor are hereby reserved.\n\n   4. Restrictions. The license granted in Section 3 above is expressly made subject to and limited by the following restrictions:\n\n      a. You may distribute, publicly display, publicly perform, or publicly digitally perform the Work only under the terms of this License, and You must include a copy of, or the Uniform Resource Identifier for, this License with every copy or phonorecord of the Work You distribute, publicly display, publicly perform, or publicly digitally perform. You may not offer or impose any terms on the Work that alter or restrict the terms of this License or the recipients' exercise of the rights granted hereunder. You may not sublicense the Work. You must keep intact all notices that refer to this License and to the disclaimer of warranties. You may not distribute, publicly display, publicly perform, or publicly digitally perform the Work with any technological measures that control access or use of the Work in a manner inconsistent with the terms of this License Agreement. The above applies to the Work as incorporated in a Collective Work, but this does not require the Collective Work apart from the Work itself to be made subject to the terms of this License. If You create a Collective Work, upon notice from any Licensor You must, to the extent practicable, remove from the Collective Work any credit as required by clause 4(b), as requested.\n\n      b. If you distribute, publicly display, publicly perform, or publicly digitally perform the Work or Collective Works, You must keep intact all copyright notices for the Work and provide, reasonable to the medium or means You are utilizing: (i) the name of the Original Author (or pseudonym, if applicable) if supplied, and/or (ii) if the Original Author and/or Licensor designate another party or parties (e.g. a sponsor institute, publishing entity, journal) for attribution in Licensor's copyright notice, terms of service or by other reasonable means, the name of such party or parties; the title of the Work if supplied; and to the extent reasonably practicable, the Uniform Resource Identifier, if any, that Licensor specifies to be associated with the Work, unless such URI does not refer to the copyright notice or licensing information for the Work. Such credit may be implemented in any reasonable manner; provided, however, that in the case of a Collective Work, at a minimum such credit will appear where any other comparable authorship credit appears and in a manner at least as prominent as such other comparable authorship credit.\n\n   5. Representations, Warranties and Disclaimer\n\n   UNLESS OTHERWISE MUTUALLY AGREED TO BY THE PARTIES IN WRITING, LICENSOR OFFERS THE WORK AS-IS AND MAKES NO REPRESENTATIONS OR WARRANTIES OF ANY KIND CONCERNING THE MATERIALS, EXPRESS, IMPLIED, STATUTORY OR OTHERWISE, INCLUDING, WITHOUT LIMITATION, WARRANTIES OF TITLE, MERCHANTIBILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT, OR THE ABSENCE OF LATENT OR OTHER DEFECTS, ACCURACY, OR THE PRESENCE OF ABSENCE OF ERRORS, WHETHER OR NOT DISCOVERABLE. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OF IMPLIED WARRANTIES, SO SUCH EXCLUSION MAY NOT APPLY TO YOU.\n\n   6. Limitation on Liability. EXCEPT TO THE EXTENT REQUIRED BY APPLICABLE LAW, IN NO EVENT WILL LICENSOR BE LIABLE TO YOU ON ANY LEGAL THEORY FOR ANY SPECIAL, INCIDENTAL, CONSEQUENTIAL, PUNITIVE OR EXEMPLARY DAMAGES ARISING OUT OF THIS LICENSE OR THE USE OF THE WORK, EVEN IF LICENSOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\n   7. Termination\n\n      a. This License and the rights granted hereunder will terminate automatically upon any breach by You of the terms of this License. Individuals or entities who have received Collective Works from You under this License, however, will not have their licenses terminated provided such individuals or entities remain in full compliance with those licenses. Sections 1, 2, 5, 6, 7, and 8 will survive any termination of this License.\n\n      b. Subject to the above terms and conditions, the license granted here is perpetual (for the duration of the applicable copyright in the Work). Notwithstanding the above, Licensor reserves the right to release the Work under different license terms or to stop distributing the Work at any time; provided, however that any such election will not serve to withdraw this License (or any other license that has been, or is required to be, granted under the terms of this License), and this License will continue in full force and effect unless terminated as stated above.\n\n   8. Miscellaneous\n\n      a. Each time You distribute or publicly digitally perform the Work, the Licensor offers to the recipient a license to the Work on the same terms and conditions as the license granted to You under this License.\n\n      b. If any provision of this License is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this License, and without further action by the parties to this agreement, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.\n\n      c. No term or provision of this License shall be deemed waived and no breach consented to unless such waiver or consent shall be in writing and signed by the party to be charged with such waiver or consent.\n\n      d. This License constitutes the entire agreement between the parties with respect to the Work licensed here. There are no understandings, agreements or representations with respect to the Work not specified here. Licensor shall not be bound by any additional provisions that may appear in any communication from You. This License may not be modified without the mutual written agreement of the Licensor and You.\n\nCreative Commons is not a party to this License, and makes no warranty whatsoever in connection with the Work. Creative Commons will not be liable to You or any party on any legal theory for any damages whatsoever, including without limitation any general, special, incidental or consequential damages arising in connection to this license. Notwithstanding the foregoing two (2) sentences, if Creative Commons has expressly identified itself as the Licensor hereunder, it shall have all rights and obligations of Licensor.\n\nExcept for the limited purpose of indicating to the public that the Work is licensed under the CCPL, neither party will use the trademark \"Creative Commons\" or any related trademark or logo of Creative Commons without the prior written consent of Creative Commons. Any permitted use will be in compliance with Creative Commons' then-current trademark usage guidelines, as may be published on its website or otherwise made available upon request from time to time.\n\nCreative Commons may be contacted at http://creativecommons.org/."],"licenseIds":["CC-BY-ND-2.5"],"keywords":["attribution noderivs 2 5","commons attribution noderivs 2 5","attribution noderivs 2 5 creative"]},{"licenseTexts":["Creative Commons Attribution-NoDerivs 3.0 Unported CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE LEGAL SERVICES. DISTRIBUTION OF THIS LICENSE DOES NOT CREATE AN ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS INFORMATION ON AN \"AS-IS\" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES REGARDING THE INFORMATION PROVIDED, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM ITS USE.\n\nLicense\n\nTHE WORK (AS DEFINED BELOW) IS PROVIDED UNDER THE TERMS OF THIS CREATIVE COMMONS PUBLIC LICENSE (\"CCPL\" OR \"LICENSE\"). THE WORK IS PROTECTED BY COPYRIGHT AND/OR OTHER APPLICABLE LAW. ANY USE OF THE WORK OTHER THAN AS AUTHORIZED UNDER THIS LICENSE OR COPYRIGHT LAW IS PROHIBITED.\n\nBY EXERCISING ANY RIGHTS TO THE WORK PROVIDED HERE, YOU ACCEPT AND AGREE TO BE BOUND BY THE TERMS OF THIS LICENSE. TO THE EXTENT THIS LICENSE MAY BE CONSIDERED TO BE A CONTRACT, THE LICENSOR GRANTS YOU THE RIGHTS CONTAINED HERE IN CONSIDERATION OF YOUR ACCEPTANCE OF SUCH TERMS AND CONDITIONS.\n\n   1. Definitions\n\n      a. \"Adaptation\" means a work based upon the Work, or upon the Work and other pre-existing works, such as a translation, adaptation, derivative work, arrangement of music or other alterations of a literary or artistic work, or phonogram or performance and includes cinematographic adaptations or any other form in which the Work may be recast, transformed, or adapted including in any form recognizably derived from the original, except that a work that constitutes a Collection will not be considered an Adaptation for the purpose of this License. For the avoidance of doubt, where the Work is a musical work, performance or phonogram, the synchronization of the Work in timed-relation with a moving image (\"synching\") will be considered an Adaptation for the purpose of this License.\n\n      b. \"Collection\" means a collection of literary or artistic works, such as encyclopedias and anthologies, or performances, phonograms or broadcasts, or other works or subject matter other than works listed in Section 1(f) below, which, by reason of the selection and arrangement of their contents, constitute intellectual creations, in which the Work is included in its entirety in unmodified form along with one or more other contributions, each constituting separate and independent works in themselves, which together are assembled into a collective whole. A work that constitutes a Collection will not be considered an Adaptation (as defined above) for the purposes of this License.\n\n      c. \"Distribute\" means to make available to the public the original and copies of the Work through sale or other transfer of ownership.\n\n      d. \"Licensor\" means the individual, individuals, entity or entities that offer(s) the Work under the terms of this License.\n\n      e. \"Original Author\" means, in the case of a literary or artistic work, the individual, individuals, entity or entities who created the Work or if no individual or entity can be identified, the publisher; and in addition (i) in the case of a performance the actors, singers, musicians, dancers, and other persons who act, sing, deliver, declaim, play in, interpret or otherwise perform literary or artistic works or expressions of folklore; (ii) in the case of a phonogram the producer being the person or legal entity who first fixes the sounds of a performance or other sounds; and, (iii) in the case of broadcasts, the organization that transmits the broadcast.\n\n      f. \"Work\" means the literary and/or artistic work offered under the terms of this License including without limitation any production in the literary, scientific and artistic domain, whatever may be the mode or form of its expression including digital form, such as a book, pamphlet and other writing; a lecture, address, sermon or other work of the same nature; a dramatic or dramatico-musical work; a choreographic work or entertainment in dumb show; a musical composition with or without words; a cinematographic work to which are assimilated works expressed by a process analogous to cinematography; a work of drawing, painting, architecture, sculpture, engraving or lithography; a photographic work to which are assimilated works expressed by a process analogous to photography; a work of applied art; an illustration, map, plan, sketch or three-dimensional work relative to geography, topography, architecture or science; a performance; a broadcast; a phonogram; a compilation of data to the extent it is protected as a copyrightable work; or a work performed by a variety or circus performer to the extent it is not otherwise considered a literary or artistic work.\n\n      g. \"You\" means an individual or entity exercising rights under this License who has not previously violated the terms of this License with respect to the Work, or who has received express permission from the Licensor to exercise rights under this License despite a previous violation.\n\n      h. \"Publicly Perform\" means to perform public recitations of the Work and to communicate to the public those public recitations, by any means or process, including by wire or wireless means or public digital performances; to make available to the public Works in such a way that members of the public may access these Works from a place and at a place individually chosen by them; to perform the Work to the public by any means or process and the communication to the public of the performances of the Work, including by public digital performance; to broadcast and rebroadcast the Work by any means including signs, sounds or images.\n\n      i. \"Reproduce\" means to make copies of the Work by any means including without limitation by sound or visual recordings and the right of fixation and reproducing fixations of the Work, including storage of a protected performance or phonogram in digital form or other electronic medium.\n\n   2. Fair Dealing Rights. Nothing in this License is intended to reduce, limit, or restrict any uses free from copyright or rights arising from limitations or exceptions that are provided for in connection with the copyright protection under copyright law or other applicable laws.\n\n   3. License Grant. Subject to the terms and conditions of this License, Licensor hereby grants You a worldwide, royalty-free, non-exclusive, perpetual (for the duration of the applicable copyright) license to exercise the rights in the Work as stated below:\n\n      a. to Reproduce the Work, to incorporate the Work into one or more Collections, and to Reproduce the Work as incorporated in the Collections; and,\n\n      b. to Distribute and Publicly Perform the Work including as incorporated in Collections.\n\n      c. For the avoidance of doubt:\n\n         i. Non-waivable Compulsory License Schemes. In those jurisdictions in which the right to collect royalties through any statutory or compulsory licensing scheme cannot be waived, the Licensor reserves the exclusive right to collect such royalties for any exercise by You of the rights granted under this License;\n\n         ii. Waivable Compulsory License Schemes. In those jurisdictions in which the right to collect royalties through any statutory or compulsory licensing scheme can be waived, the Licensor waives the exclusive right to collect such royalties for any exercise by You of the rights granted under this License; and,\n\n         iii. Voluntary License Schemes. The Licensor waives the right to collect royalties, whether individually or, in the event that the Licensor is a member of a collecting society that administers voluntary licensing schemes, via that society, from any exercise by You of the rights granted under this License.\n\n   The above rights may be exercised in all media and formats whether now known or hereafter devised. The above rights include the right to make such modifications as are technically necessary to exercise the rights in other media and formats, but otherwise you have no rights to make Adaptations. Subject to Section 8(f), all rights not expressly granted by Licensor are hereby reserved.\n\n   4. Restrictions. The license granted in Section 3 above is expressly made subject to and limited by the following restrictions:\n\n      a. You may Distribute or Publicly Perform the Work only under the terms of this License. You must include a copy of, or the Uniform Resource Identifier (URI) for, this License with every copy of the Work You Distribute or Publicly Perform. You may not offer or impose any terms on the Work that restrict the terms of this License or the ability of the recipient of the Work to exercise the rights granted to that recipient under the terms of the License. You may not sublicense the Work. You must keep intact all notices that refer to this License and to the disclaimer of warranties with every copy of the Work You Distribute or Publicly Perform. When You Distribute or Publicly Perform the Work, You may not impose any effective technological measures on the Work that restrict the ability of a recipient of the Work from You to exercise the rights granted to that recipient under the terms of the License. This Section 4(a) applies to the Work as incorporated in a Collection, but this does not require the Collection apart from the Work itself to be made subject to the terms of this License. If You create a Collection, upon notice from any Licensor You must, to the extent practicable, remove from the Collection any credit as required by Section 4(b), as requested.\n\n      b. If You Distribute, or Publicly Perform the Work or Collections, You must, unless a request has been made pursuant to Section 4(a), keep intact all copyright notices for the Work and provide, reasonable to the medium or means You are utilizing: (i) the name of the Original Author (or pseudonym, if applicable) if supplied, and/or if the Original Author and/or Licensor designate another party or parties (e.g., a sponsor institute, publishing entity, journal) for attribution (\"Attribution Parties\") in Licensor's copyright notice, terms of service or by other reasonable means, the name of such party or parties; (ii) the title of the Work if supplied; (iii) to the extent reasonably practicable, the URI, if any, that Licensor specifies to be associated with the Work, unless such URI does not refer to the copyright notice or licensing information for the Work. The credit required by this Section 4(b) may be implemented in any reasonable manner; provided, however, that in the case of a Collection, at a minimum such credit will appear, if a credit for all contributing authors of the Collection appears, then as part of these credits and in a manner at least as prominent as the credits for the other contributing authors. For the avoidance of doubt, You may only use the credit required by this Section for the purpose of attribution in the manner set out above and, by exercising Your rights under this License, You may not implicitly or explicitly assert or imply any connection with, sponsorship or endorsement by the Original Author, Licensor and/or Attribution Parties, as appropriate, of You or Your use of the Work, without the separate, express prior written permission of the Original Author, Licensor and/or Attribution Parties.\n\n      c. Except as otherwise agreed in writing by the Licensor or as may be otherwise permitted by applicable law, if You Reproduce, Distribute or Publicly Perform the Work either by itself or as part of any Collections, You must not distort, mutilate, modify or take other derogatory action in relation to the Work which would be prejudicial to the Original Author's honor or reputation.\n\n   5. Representations, Warranties and Disclaimer\n\n   UNLESS OTHERWISE MUTUALLY AGREED TO BY THE PARTIES IN WRITING, LICENSOR OFFERS THE WORK AS-IS AND MAKES NO REPRESENTATIONS OR WARRANTIES OF ANY KIND CONCERNING THE WORK, EXPRESS, IMPLIED, STATUTORY OR OTHERWISE, INCLUDING, WITHOUT LIMITATION, WARRANTIES OF TITLE, MERCHANTIBILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT, OR THE ABSENCE OF LATENT OR OTHER DEFECTS, ACCURACY, OR THE PRESENCE OF ABSENCE OF ERRORS, WHETHER OR NOT DISCOVERABLE. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OF IMPLIED WARRANTIES, SO SUCH EXCLUSION MAY NOT APPLY TO YOU.\n\n   6. Limitation on Liability. EXCEPT TO THE EXTENT REQUIRED BY APPLICABLE LAW, IN NO EVENT WILL LICENSOR BE LIABLE TO YOU ON ANY LEGAL THEORY FOR ANY SPECIAL, INCIDENTAL, CONSEQUENTIAL, PUNITIVE OR EXEMPLARY DAMAGES ARISING OUT OF THIS LICENSE OR THE USE OF THE WORK, EVEN IF LICENSOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\n   7. Termination\n\n      a. This License and the rights granted hereunder will terminate automatically upon any breach by You of the terms of this License. Individuals or entities who have received Collections from You under this License, however, will not have their licenses terminated provided such individuals or entities remain in full compliance with those licenses. Sections 1, 2, 5, 6, 7, and 8 will survive any termination of this License.\n\n      b. Subject to the above terms and conditions, the license granted here is perpetual (for the duration of the applicable copyright in the Work). Notwithstanding the above, Licensor reserves the right to release the Work under different license terms or to stop distributing the Work at any time; provided, however that any such election will not serve to withdraw this License (or any other license that has been, or is required to be, granted under the terms of this License), and this License will continue in full force and effect unless terminated as stated above.\n\n   8. Miscellaneous\n\n      a. Each time You Distribute or Publicly Perform the Work or a Collection, the Licensor offers to the recipient a license to the Work on the same terms and conditions as the license granted to You under this License.\n\n      b. If any provision of this License is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this License, and without further action by the parties to this agreement, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.\n\n      c. No term or provision of this License shall be deemed waived and no breach consented to unless such waiver or consent shall be in writing and signed by the party to be charged with such waiver or consent.\n\n      d. This License constitutes the entire agreement between the parties with respect to the Work licensed here. There are no understandings, agreements or representations with respect to the Work not specified here. Licensor shall not be bound by any additional provisions that may appear in any communication from You. This License may not be modified without the mutual written agreement of the Licensor and You.\n\n      e. The rights granted under, and the subject matter referenced, in this License were drafted utilizing the terminology of the Berne Convention for the Protection of Literary and Artistic Works (as amended on September 28, 1979), the Rome Convention of 1961, the WIPO Copyright Treaty of 1996, the WIPO Performances and Phonograms Treaty of 1996 and the Universal Copyright Convention (as revised on July 24, 1971). These rights and subject matter take effect in the relevant jurisdiction in which the License terms are sought to be enforced according to the corresponding provisions of the implementation of those treaty provisions in the applicable national law. If the standard suite of rights granted under applicable copyright law includes additional rights not granted under this License, such additional rights are deemed to be included in the License; this License is not intended to restrict the license of any rights under applicable law.\n\nCreative Commons Notice\n\nCreative Commons is not a party to this License, and makes no warranty whatsoever in connection with the Work. Creative Commons will not be liable to You or any party on any legal theory for any damages whatsoever, including without limitation any general, special, incidental or consequential damages arising in connection to this license. Notwithstanding the foregoing two (2) sentences, if Creative Commons has expressly identified itself as the Licensor hereunder, it shall have all rights and obligations of Licensor.\n\nExcept for the limited purpose of indicating to the public that the Work is licensed under the CCPL, Creative Commons does not authorize the use by either party of the trademark \"Creative Commons\" or any related trademark or logo of Creative Commons without the prior written consent of Creative Commons. Any permitted use will be in compliance with Creative Commons' then-current trademark usage guidelines, as may be published on its website or otherwise made available upon request from time to time. For the avoidance of doubt, this trademark restriction does not form part of this License.\n\nCreative Commons may be contacted at http://creativecommons.org/."],"licenseIds":["CC-BY-ND-3.0"],"keywords":["attribution noderivs 3","in collections c","collections c for","of the collection","the collection appears","commons attribution noderivs 3","attribution noderivs 3 0","incorporated in collections c","in collections c for","collections c for the","adaptations subject to section","authors of the collection","of the collection appears","the collection appears then","creative commons attribution noderivs 3","commons attribution noderivs 3 0","attribution noderivs 3 0 unported","as incorporated in collections c","incorporated in collections c for","in collections c for the","collections c for the avoidance","make adaptations subject to section","adaptations subject to section 8","contributing authors of the collection","authors of the collection appears","of the collection appears then","the collection appears then as"]},{"licenseTexts":["Creative Commons Attribution-NoDerivatives 4.0 International Creative Commons Corporation (\"Creative Commons\") is not a law firm and does not provide legal services or legal advice. Distribution of Creative Commons public licenses does not create a lawyer-client or other relationship. Creative Commons makes its licenses and related information available on an \"as-is\" basis. Creative Commons gives no warranties regarding its licenses, any material licensed under their terms and conditions, or any related information. Creative Commons disclaims all liability for damages resulting from their use to the fullest extent possible.\n\nUsing Creative Commons Public Licenses\n\nCreative Commons public licenses provide a standard set of terms and conditions that creators and other rights holders may use to share original works of authorship and other material subject to copyright and certain other rights specified in the public license below. The following considerations are for informational purposes only, are not exhaustive, and do not form part of our licenses.\n\nConsiderations for licensors: Our public licenses are intended for use by those authorized to give the public permission to use material in ways otherwise restricted by copyright and certain other rights. Our licenses are irrevocable. Licensors should read and understand the terms and conditions of the license they choose before applying it. Licensors should also secure all rights necessary before applying our licenses so that the public can reuse the material as expected. Licensors should clearly mark any material not subject to the license. This includes other CC-licensed material, or material used under an exception or limitation to copyright. More considerations for licensors : wiki.creativecommons.org/Considerations_for_licensors\n\nConsiderations for the public: By using one of our public licenses, a licensor grants the public permission to use the licensed material under specified terms and conditions. If the licensor's permission is not necessary for any reason–for example, because of any applicable exception or limitation to copyright–then that use is not regulated by the license. Our licenses grant only permissions under copyright and certain other rights that a licensor has authority to grant. Use of the licensed material may still be restricted for other reasons, including because others have copyright or other rights in the material. A licensor may make special requests, such as asking that all changes be marked or described. Although not required by our licenses, you are encouraged to respect those requests where reasonable. More considerations for the public : wiki.creativecommons.org/Considerations_for_licensees\n\nCreative Commons Attribution-NoDerivatives 4.0 International Public License\n\nBy exercising the Licensed Rights (defined below), You accept and agree to be bound by the terms and conditions of this Creative Commons Attribution-NoDerivatives 4.0 International Public License (\"Public License\"). To the extent this Public License may be interpreted as a contract, You are granted the Licensed Rights in consideration of Your acceptance of these terms and conditions, and the Licensor grants You such rights in consideration of benefits the Licensor receives from making the Licensed Material available under these terms and conditions.\n\nSection 1 – Definitions.\n\n   a. Adapted Material means material subject to Copyright and Similar Rights that is derived from or based upon the Licensed Material and in which the Licensed Material is translated, altered, arranged, transformed, or otherwise modified in a manner requiring permission under the Copyright and Similar Rights held by the Licensor. For purposes of this Public License, where the Licensed Material is a musical work, performance, or sound recording, Adapted Material is always produced where the Licensed Material is synched in timed relation with a moving image.\n\n   b. Copyright and Similar Rights means copyright and/or similar rights closely related to copyright including, without limitation, performance, broadcast, sound recording, and Sui Generis Database Rights, without regard to how the rights are labeled or categorized. For purposes of this Public License, the rights specified in Section 2(b)(1)-(2) are not Copyright and Similar Rights.\n\n   c. Effective Technological Measures means those measures that, in the absence of proper authority, may not be circumvented under laws fulfilling obligations under Article 11 of the WIPO Copyright Treaty adopted on December 20, 1996, and/or similar international agreements.\n\n   d. Exceptions and Limitations means fair use, fair dealing, and/or any other exception or limitation to Copyright and Similar Rights that applies to Your use of the Licensed Material.\n\n   e. Licensed Material means the artistic or literary work, database, or other material to which the Licensor applied this Public License.\n\n   f. Licensed Rights means the rights granted to You subject to the terms and conditions of this Public License, which are limited to all Copyright and Similar Rights that apply to Your use of the Licensed Material and that the Licensor has authority to license.\n\n   g. Licensor means the individual(s) or entity(ies) granting rights under this Public License.\n\n   h. Share means to provide material to the public by any means or process that requires permission under the Licensed Rights, such as reproduction, public display, public performance, distribution, dissemination, communication, or importation, and to make material available to the public including in ways that members of the public may access the material from a place and at a time individually chosen by them.\n\n   i. Sui Generis Database Rights means rights other than copyright resulting from Directive 96/9/EC of the European Parliament and of the Council of 11 March 1996 on the legal protection of databases, as amended and/or succeeded, as well as other essentially equivalent rights anywhere in the world.\n\n   j. You means the individual or entity exercising the Licensed Rights under this Public License. Your has a corresponding meaning.\n\nSection 2 – Scope.\n\n   a. License grant.\n\n      1. Subject to the terms and conditions of this Public License, the Licensor hereby grants You a worldwide, royalty-free, non-sublicensable, non-exclusive, irrevocable license to exercise the Licensed Rights in the Licensed Material to:\n\n         A. reproduce and Share the Licensed Material, in whole or in part; and\n\n         B. produce and reproduce, but not Share, Adapted Material.\n\n      2. Exceptions and Limitations. For the avoidance of doubt, where Exceptions and Limitations apply to Your use, this Public License does not apply, and You do not need to comply with its terms and conditions.\n\n      3. Term. The term of this Public License is specified in Section 6(a).\n\n      4. Media and formats; technical modifications allowed. The Licensor authorizes You to exercise the Licensed Rights in all media and formats whether now known or hereafter created, and to make technical modifications necessary to do so. The Licensor waives and/or agrees not to assert any right or authority to forbid You from making technical modifications necessary to exercise the Licensed Rights, including technical modifications necessary to circumvent Effective Technological Measures. For purposes of this Public License, simply making modifications authorized by this Section 2(a)(4) never produces Adapted Material.\n\n      5. Downstream recipients.\n\n         A. Offer from the Licensor – Licensed Material. Every recipient of the Licensed Material automatically receives an offer from the Licensor to exercise the Licensed Rights under the terms and conditions of this Public License.\n\n         B. No downstream restrictions. You may not offer or impose any additional or different terms or conditions on, or apply any Effective Technological Measures to, the Licensed Material if doing so restricts exercise of the Licensed Rights by any recipient of the Licensed Material.\n\n      6. No endorsement. Nothing in this Public License constitutes or may be construed as permission to assert or imply that You are, or that Your use of the Licensed Material is, connected with, or sponsored, endorsed, or granted official status by, the Licensor or others designated to receive attribution as provided in Section 3(a)(1)(A)(i).\n\n   b. Other rights.\n\n      1. Moral rights, such as the right of integrity, are not licensed under this Public License, nor are publicity, privacy, and/or other similar personality rights; however, to the extent possible, the Licensor waives and/or agrees not to assert any such rights held by the Licensor to the limited extent necessary to allow You to exercise the Licensed Rights, but not otherwise.\n\n      2. Patent and trademark rights are not licensed under this Public License.\n\n      3. To the extent possible, the Licensor waives any right to collect royalties from You for the exercise of the Licensed Rights, whether directly or through a collecting society under any voluntary or waivable statutory or compulsory licensing scheme. In all other cases the Licensor expressly reserves any right to collect such royalties.\n\nSection 3 – License Conditions.\n\nYour exercise of the Licensed Rights is expressly made subject to the following conditions.\n\n   a. Attribution.\n\n      1. If You Share the Licensed Material, You must:\n\n         A. retain the following if it is supplied by the Licensor with the Licensed Material:\n\n            i. identification of the creator(s) of the Licensed Material and any others designated to receive attribution, in any reasonable manner requested by the Licensor (including by pseudonym if designated);\n\n            ii. a copyright notice;\n\n            iii. a notice that refers to this Public License;\n\n            iv. a notice that refers to the disclaimer of warranties;\n\n            v. a URI or hyperlink to the Licensed Material to the extent reasonably practicable;\n\n         B. indicate if You modified the Licensed Material and retain an indication of any previous modifications; and\n\n         C. indicate the Licensed Material is licensed under this Public License, and include the text of, or the URI or hyperlink to, this Public License.\n\n      2. For the avoidance of doubt, You do not have permission under this Public License to Share Adapted Material.\n\n      3. You may satisfy the conditions in Section 3(a)(1) in any reasonable manner based on the medium, means, and context in which You Share the Licensed Material. For example, it may be reasonable to satisfy the conditions by providing a URI or hyperlink to a resource that includes the required information.\n\n      4. If requested by the Licensor, You must remove any of the information required by Section 3(a)(1)(A) to the extent reasonably practicable.\n\nSection 4 – Sui Generis Database Rights.\n\nWhere the Licensed Rights include Sui Generis Database Rights that apply to Your use of the Licensed Material:\n\n   a. for the avoidance of doubt, Section 2(a)(1) grants You the right to extract, reuse, reproduce, and Share all or a substantial portion of the contents of the database, provided You do not Share Adapted Material;\n\n   b. if You include all or a substantial portion of the database contents in a database in which You have Sui Generis Database Rights, then the database in which You have Sui Generis Database Rights (but not its individual contents) is Adapted Material; and\n\n   c. You must comply with the conditions in Section 3(a) if You Share all or a substantial portion of the contents of the database.\n\n   For the avoidance of doubt, this Section 4 supplements and does not replace Your obligations under this Public License where the Licensed Rights include other Copyright and Similar Rights.\n\nSection 5 – Disclaimer of Warranties and Limitation of Liability.\n\n   a. Unless otherwise separately undertaken by the Licensor, to the extent possible, the Licensor offers the Licensed Material as-is and as-available, and makes no representations or warranties of any kind concerning the Licensed Material, whether express, implied, statutory, or other. This includes, without limitation, warranties of title, merchantability, fitness for a particular purpose, non-infringement, absence of latent or other defects, accuracy, or the presence or absence of errors, whether or not known or discoverable. Where disclaimers of warranties are not allowed in full or in part, this disclaimer may not apply to You.\n\n   b. To the extent possible, in no event will the Licensor be liable to You on any legal theory (including, without limitation, negligence) or otherwise for any direct, special, indirect, incidental, consequential, punitive, exemplary, or other losses, costs, expenses, or damages arising out of this Public License or use of the Licensed Material, even if the Licensor has been advised of the possibility of such losses, costs, expenses, or damages. Where a limitation of liability is not allowed in full or in part, this limitation may not apply to You.\n\n   c. The disclaimer of warranties and limitation of liability provided above shall be interpreted in a manner that, to the extent possible, most closely approximates an absolute disclaimer and waiver of all liability.\n\nSection 6 – Term and Termination.\n\n   a. This Public License applies for the term of the Copyright and Similar Rights licensed here. However, if You fail to comply with this Public License, then Your rights under this Public License terminate automatically.\n\n   b. Where Your right to use the Licensed Material has terminated under Section 6(a), it reinstates:\n\n      1. automatically as of the date the violation is cured, provided it is cured within 30 days of Your discovery of the violation; or\n\n      2. upon express reinstatement by the Licensor.\n\n   c. For the avoidance of doubt, this Section 6(b) does not affect any right the Licensor may have to seek remedies for Your violations of this Public License.\n\n   d. For the avoidance of doubt, the Licensor may also offer the Licensed Material under separate terms or conditions or stop distributing the Licensed Material at any time; however, doing so will not terminate this Public License.\n\n   e. Sections 1, 5, 6, 7, and 8 survive termination of this Public License.\n\nSection 7 – Other Terms and Conditions.\n\n   a. The Licensor shall not be bound by any additional or different terms or conditions communicated by You unless expressly agreed.\n\n   b. Any arrangements, understandings, or agreements regarding the Licensed Material not stated herein are separate from and independent of the terms and conditions of this Public License.\n\nSection 8 – Interpretation.\n\n   a. For the avoidance of doubt, this Public License does not, and shall not be interpreted to, reduce, limit, restrict, or impose conditions on any use of the Licensed Material that could lawfully be made without permission under this Public License.\n\n   b. To the extent possible, if any provision of this Public License is deemed unenforceable, it shall be automatically reformed to the minimum extent necessary to make it enforceable. If the provision cannot be reformed, it shall be severed from this Public License without affecting the enforceability of the remaining terms and conditions.\n\n   c. No term or condition of this Public License will be waived and no failure to comply consented to unless expressly agreed to by the Licensor.\n\n   d. Nothing in this Public License constitutes or may be interpreted as a limitation upon, or waiver of, any privileges and immunities that apply to the Licensor or You, including from the legal processes of any jurisdiction or authority.\n\nCreative Commons is not a party to its public licenses. Notwithstanding, Creative Commons may elect to apply one of its public licenses to material it publishes and in those instances will be considered the \"Licensor.\" The text of the Creative Commons public licenses is dedicated to the public domain under the CC0 Public Domain Dedication. Except for the limited purpose of indicating that material is shared under a Creative Commons public license or as otherwise permitted by the Creative Commons policies published at creativecommons.org/policies, Creative Commons does not authorize the use of the trademark \"Creative Commons\" or any other trademark or logo of Creative Commons without its prior written consent including, without limitation, in connection with any unauthorized modifications to any of its public licenses or any other arrangements, understandings, or agreements concerning use of licensed material. For the avoidance of doubt, this paragraph does not form part of the public licenses.\n\nCreative Commons may be contacted at creativecommons.org."],"licenseIds":["CC-BY-ND-4.0"],"keywords":["license h share","h share means","by them i","them i sui","i sui generis","the world j","world j you","j you means","license 2 for","2 for the","required information 4","information 4 if","4 if requested","the database provided","database provided you","public license h share","license h share means","h share means to","chosen by them i","by them i sui","them i sui generis","i sui generis database","in the world j","the world j you","world j you means","j you means the","public license 2 for","license 2 for the","2 for the avoidance","3 you may satisfy","the required information 4","required information 4 if","information 4 if requested","4 if requested by","of the database provided","the database provided you","database provided you do","licensees creative commons attribution noderivatives","this creative commons attribution noderivatives","this public license h share","public license h share means","license h share means to","h share means to provide","individually chosen by them i","chosen by them i sui","by them i sui generis","them i sui generis database","i sui generis database rights","anywhere in the world j","in the world j you","the world j you means","world j you means the","j you means the individual","part and b produce and","not share adapted material 2","this public license 2 for","public license 2 for the","license 2 for the avoidance","2 for the avoidance of","to share adapted material 3","material 3 you may satisfy","3 you may satisfy the","includes the required information 4","the required information 4 if","required information 4 if requested","information 4 if requested by","4 if requested by the","contents of the database provided","of the database provided you","the database provided you do","database provided you do not"]},{"licenseTexts":["Creative Commons Attribution-ShareAlike 1.0 CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE LEGAL SERVICES. DISTRIBUTION OF THIS DRAFT LICENSE DOES NOT CREATE AN ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS INFORMATION ON AN \"AS-IS\" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES REGARDING THE INFORMATION PROVIDED, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM ITS USE.\n\nLicense\n\nTHE WORK (AS DEFINED BELOW) IS PROVIDED UNDER THE TERMS OF THIS CREATIVE COMMONS PUBLIC LICENSE (\"CCPL\" OR \"LICENSE\"). THE WORK IS PROTECTED BY COPYRIGHT AND/OR OTHER APPLICABLE LAW. ANY USE OF THE WORK OTHER THAN AS AUTHORIZED UNDER THIS LICENSE IS PROHIBITED.\n\nBY EXERCISING ANY RIGHTS TO THE WORK PROVIDED HERE, YOU ACCEPT AND AGREE TO BE BOUND BY THE TERMS OF THIS LICENSE. THE LICENSOR GRANTS YOU THE RIGHTS CONTAINED HERE IN CONSIDERATION OF YOUR ACCEPTANCE OF SUCH TERMS AND CONDITIONS.\n\n   1. Definitions\n\n      a. \"Collective Work\" means a work, such as a periodical issue, anthology or encyclopedia, in which the Work in its entirety in unmodified form, along with a number of other contributions, constituting separate and independent works in themselves, are assembled into a collective whole. A work that constitutes a Collective Work will not be considered a Derivative Work (as defined below) for the purposes of this License.\n\n      b. \"Derivative Work\" means a work based upon the Work or upon the Work and other pre-existing works, such as a translation, musical arrangement, dramatization, fictionalization, motion picture version, sound recording, art reproduction, abridgment, condensation, or any other form in which the Work may be recast, transformed, or adapted, except that a work that constitutes a Collective Work will not be considered a Derivative Work for the purpose of this License.\n\n      c. \"Licensor\" means the individual or entity that offers the Work under the terms of this License.\n\n      d. \"Original Author\" means the individual or entity who created the Work.\n\n      e. \"Work\" means the copyrightable work of authorship offered under the terms of this License.\n\n      f. \"You\" means an individual or entity exercising rights under this License who has not previously violated the terms of this License with respect to the Work, or who has received express permission from the Licensor to exercise rights under this License despite a previous violation.\n\n   2. Fair Use Rights. Nothing in this license is intended to reduce, limit, or restrict any rights arising from fair use, first sale or other limitations on the exclusive rights of the copyright owner under copyright law or other applicable laws.\n\n   3. License Grant. Subject to the terms and conditions of this License, Licensor hereby grants You a worldwide, royalty-free, non-exclusive, perpetual (for the duration of the applicable copyright) license to exercise the rights in the Work as stated below:\n\n      a. to reproduce the Work, to incorporate the Work into one or more Collective Works, and to reproduce the Work as incorporated in the Collective Works;\n\n      b. to create and reproduce Derivative Works;\n\n      c. to distribute copies or phonorecords of, display publicly, perform publicly, and perform publicly by means of a digital audio transmission the Work including as incorporated in Collective Works;\n\n      d. to distribute copies or phonorecords of, display publicly, perform publicly, and perform publicly by means of a digital audio transmission Derivative Works;\n\n   The above rights may be exercised in all media and formats whether now known or hereafter devised. The above rights include the right to make such modifications as are technically necessary to exercise the rights in other media and formats. All rights not expressly granted by Licensor are hereby reserved.\n\n   4. Restrictions. The license granted in Section 3 above is expressly made subject to and limited by the following restrictions:\n\n      a. You may distribute, publicly display, publicly perform, or publicly digitally perform the Work only under the terms of this License, and You must include a copy of, or the Uniform Resource Identifier for, this License with every copy or phonorecord of the Work You distribute, publicly display, publicly perform, or publicly digitally perform. You may not offer or impose any terms on the Work that alter or restrict the terms of this License or the recipients' exercise of the rights granted hereunder. You may not sublicense the Work. You must keep intact all notices that refer to this License and to the disclaimer of warranties. You may not distribute, publicly display, publicly perform, or publicly digitally perform the Work with any technological measures that control access or use of the Work in a manner inconsistent with the terms of this License Agreement. The above applies to the Work as incorporated in a Collective Work, but this does not require the Collective Work apart from the Work itself to be made subject to the terms of this License. If You create a Collective Work, upon notice from any Licensor You must, to the extent practicable, remove from the Collective Work any reference to such Licensor or the Original Author, as requested. If You create a Derivative Work, upon notice from any Licensor You must, to the extent practicable, remove from the Derivative Work any reference to such Licensor or the Original Author, as requested.\n\n      b. You may distribute, publicly display, publicly perform, or publicly digitally perform a Derivative Work only under the terms of this License, and You must include a copy of, or the Uniform Resource Identifier for, this License with every copy or phonorecord of each Derivative Work You distribute, publicly display, publicly perform, or publicly digitally perform. You may not offer or impose any terms on the Derivative Works that alter or restrict the terms of this License or the recipients' exercise of the rights granted hereunder, and You must keep intact all notices that refer to this License and to the disclaimer of warranties. You may not distribute, publicly display, publicly perform, or publicly digitally perform the Derivative Work with any technological measures that control access or use of the Work in a manner inconsistent with the terms of this License Agreement. The above applies to the Derivative Work as incorporated in a Collective Work, but this does not require the Collective Work apart from the Derivative Work itself to be made subject to the terms of this License.\n\n      c. If you distribute, publicly display, publicly perform, or publicly digitally perform the Work or any Derivative Works or Collective Works, You must keep intact all copyright notices for the Work and give the Original Author credit reasonable to the medium or means You are utilizing by conveying the name (or pseudonym if applicable) of the Original Author if supplied; the title of the Work if supplied; in the case of a Derivative Work, a credit identifying the use of the Work in the Derivative Work (e.g., \"French translation of the Work by Original Author,\" or \"Screenplay based on original Work by Original Author\"). Such credit may be implemented in any reasonable manner; provided, however, that in the case of a Derivative Work or Collective Work, at a minimum such credit will appear where any other comparable authorship credit appears and in a manner at least as prominent as such other comparable authorship credit.\n\n   5. Representations, Warranties and Disclaimer\n\n      a. By offering the Work for public release under this License, Licensor represents and warrants that, to the best of Licensor's knowledge after reasonable inquiry:\n\n         i. Licensor has secured all rights in the Work necessary to grant the license rights hereunder and to permit the lawful exercise of the rights granted hereunder without You having any obligation to pay any royalties, compulsory license fees, residuals or any other payments;\n\n         ii. The Work does not infringe the copyright, trademark, publicity rights, common law rights or any other right of any third party or constitute defamation, invasion of privacy or other tortious injury to any third party.\n\n      b. EXCEPT AS EXPRESSLY STATED IN THIS LICENSE OR OTHERWISE AGREED IN WRITING OR REQUIRED BY APPLICABLE LAW, THE WORK IS LICENSED ON AN \"AS IS\" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES REGARDING THE CONTENTS OR ACCURACY OF THE WORK.\n\n   6. Limitation on Liability. EXCEPT TO THE EXTENT REQUIRED BY APPLICABLE LAW, AND EXCEPT FOR DAMAGES ARISING FROM LIABILITY TO A THIRD PARTY RESULTING FROM BREACH OF THE WARRANTIES IN SECTION 5, IN NO EVENT WILL LICENSOR BE LIABLE TO YOU ON ANY LEGAL THEORY FOR ANY SPECIAL, INCIDENTAL, CONSEQUENTIAL, PUNITIVE OR EXEMPLARY DAMAGES ARISING OUT OF THIS LICENSE OR THE USE OF THE WORK, EVEN IF LICENSOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\n   7. Termination\n\n      a. This License and the rights granted hereunder will terminate automatically upon any breach by You of the terms of this License. Individuals or entities who have received Derivative Works or Collective Works from You under this License, however, will not have their licenses terminated provided such individuals or entities remain in full compliance with those licenses. Sections 1, 2, 5, 6, 7, and 8 will survive any termination of this License.\n\n      b. Subject to the above terms and conditions, the license granted here is perpetual (for the duration of the applicable copyright in the Work). Notwithstanding the above, Licensor reserves the right to release the Work under different license terms or to stop distributing the Work at any time; provided, however that any such election will not serve to withdraw this License (or any other license that has been, or is required to be, granted under the terms of this License), and this License will continue in full force and effect unless terminated as stated above.\n\n   8. Miscellaneous\n\n      a. Each time You distribute or publicly digitally perform the Work or a Collective Work, the Licensor offers to the recipient a license to the Work on the same terms and conditions as the license granted to You under this License.\n\n      b. Each time You distribute or publicly digitally perform a Derivative Work, Licensor offers to the recipient a license to the original Work on the same terms and conditions as the license granted to You under this License.\n\n      c. If any provision of this License is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this License, and without further action by the parties to this agreement, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.\n\n      d. No term or provision of this License shall be deemed waived and no breach consented to unless such waiver or consent shall be in writing and signed by the party to be charged with such waiver or consent.\n\n      e. This License constitutes the entire agreement between the parties with respect to the Work licensed here. There are no understandings, agreements or representations with respect to the Work not specified here. Licensor shall not be bound by any additional provisions that may appear in any communication from You. This License may not be modified without the mutual written agreement of the Licensor and You.\n\nCreative Commons is not a party to this License, and makes no warranty whatsoever in connection with the Work. Creative Commons will not be liable to You or any party on any legal theory for any damages whatsoever, including without limitation any general, special, incidental or consequential damages arising in connection to this license. Notwithstanding the foregoing two (2) sentences, if Creative Commons has expressly identified itself as the Licensor hereunder, it shall have all rights and obligations of Licensor.\n\nExcept for the limited purpose of indicating to the public that the Work is licensed under the CCPL, neither party will use the trademark \"Creative Commons\" or any related trademark or logo of Creative Commons without the prior written consent of Creative Commons. Any permitted use will be in compliance with Creative Commons' then-current trademark usage guidelines, as may be published on its website or otherwise made available upon request from time to time.\n\nCreative Commons may be contacted at http://creativecommons.org/."],"licenseIds":["CC-BY-SA-1.0"],"keywords":["attribution sharealike 1","commons attribution sharealike 1","attribution sharealike 1 0","creative commons attribution sharealike 1","commons attribution sharealike 1 0","attribution sharealike 1 0 creative"]},{"licenseTexts":["Creative Commons Attribution-ShareAlike 2.0 CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE LEGAL SERVICES. DISTRIBUTION OF THIS LICENSE DOES NOT CREATE AN ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS INFORMATION ON AN \"AS-IS\" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES REGARDING THE INFORMATION PROVIDED, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM ITS USE.\n\nLicense\n\nTHE WORK (AS DEFINED BELOW) IS PROVIDED UNDER THE TERMS OF THIS CREATIVE COMMONS PUBLIC LICENSE (\"CCPL\" OR \"LICENSE\"). THE WORK IS PROTECTED BY COPYRIGHT AND/OR OTHER APPLICABLE LAW. ANY USE OF THE WORK OTHER THAN AS AUTHORIZED UNDER THIS LICENSE OR COPYRIGHT LAW IS PROHIBITED.\n\nBY EXERCISING ANY RIGHTS TO THE WORK PROVIDED HERE, YOU ACCEPT AND AGREE TO BE BOUND BY THE TERMS OF THIS LICENSE. THE LICENSOR GRANTS YOU THE RIGHTS CONTAINED HERE IN CONSIDERATION OF YOUR ACCEPTANCE OF SUCH TERMS AND CONDITIONS.\n\n   1. Definitions\n\n      a. \"Collective Work\" means a work, such as a periodical issue, anthology or encyclopedia, in which the Work in its entirety in unmodified form, along with a number of other contributions, constituting separate and independent works in themselves, are assembled into a collective whole. A work that constitutes a Collective Work will not be considered a Derivative Work (as defined below) for the purposes of this License.\n\n      b. \"Derivative Work\" means a work based upon the Work or upon the Work and other pre-existing works, such as a translation, musical arrangement, dramatization, fictionalization, motion picture version, sound recording, art reproduction, abridgment, condensation, or any other form in which the Work may be recast, transformed, or adapted, except that a work that constitutes a Collective Work will not be considered a Derivative Work for the purpose of this License. For the avoidance of doubt, where the Work is a musical composition or sound recording, the synchronization of the Work in timed-relation with a moving image (\"synching\") will be considered a Derivative Work for the purpose of this License.\n\n      c. \"Licensor\" means the individual or entity that offers the Work under the terms of this License.\n\n      d. \"Original Author\" means the individual or entity who created the Work.\n\n      e. \"Work\" means the copyrightable work of authorship offered under the terms of this License.\n\n      f. \"You\" means an individual or entity exercising rights under this License who has not previously violated the terms of this License with respect to the Work, or who has received express permission from the Licensor to exercise rights under this License despite a previous violation.\n\n      g. \"License Elements\" means the following high-level license attributes as selected by Licensor and indicated in the title of this License: Attribution, ShareAlike.\n\n   2. Fair Use Rights. Nothing in this license is intended to reduce, limit, or restrict any rights arising from fair use, first sale or other limitations on the exclusive rights of the copyright owner under copyright law or other applicable laws.\n\n   3. License Grant. Subject to the terms and conditions of this License, Licensor hereby grants You a worldwide, royalty-free, non-exclusive, perpetual (for the duration of the applicable copyright) license to exercise the rights in the Work as stated below:\n\n      a. to reproduce the Work, to incorporate the Work into one or more Collective Works, and to reproduce the Work as incorporated in the Collective Works;\n\n      b. to create and reproduce Derivative Works;\n\n      c. to distribute copies or phonorecords of, display publicly, perform publicly, and perform publicly by means of a digital audio transmission the Work including as incorporated in Collective Works;\n\n      d. to distribute copies or phonorecords of, display publicly, perform publicly, and perform publicly by means of a digital audio transmission Derivative Works.\n\n      e. For the avoidance of doubt, where the work is a musical composition:\n\n         i. Performance Royalties Under Blanket Licenses. Licensor waives the exclusive right to collect, whether individually or via a performance rights society (e.g. ASCAP, BMI, SESAC), royalties for the public performance or public digital performance (e.g. webcast) of the Work.\n\n         ii. Mechanical Rights and Statutory Royalties. Licensor waives the exclusive right to collect, whether individually or via a music rights society or designated agent (e.g. Harry Fox Agency), royalties for any phonorecord You create from the Work (\"cover version\") and distribute, subject to the compulsory license created by 17 USC Section 115 of the US Copyright Act (or the equivalent in other jurisdictions).\n\n      f. Webcasting Rights and Statutory Royalties. For the avoidance of doubt, where the Work is a sound recording, Licensor waives the exclusive right to collect, whether individually or via a performance-rights society (e.g. SoundExchange), royalties for the public digital performance (e.g. webcast) of the Work, subject to the compulsory license created by 17 USC Section 114 of the US Copyright Act (or the equivalent in other jurisdictions).\n\n   The above rights may be exercised in all media and formats whether now known or hereafter devised. The above rights include the right to make such modifications as are technically necessary to exercise the rights in other media and formats. All rights not expressly granted by Licensor are hereby reserved.\n\n   4. Restrictions. The license granted in Section 3 above is expressly made subject to and limited by the following restrictions:\n\n      a. You may distribute, publicly display, publicly perform, or publicly digitally perform the Work only under the terms of this License, and You must include a copy of, or the Uniform Resource Identifier for, this License with every copy or phonorecord of the Work You distribute, publicly display, publicly perform, or publicly digitally perform. You may not offer or impose any terms on the Work that alter or restrict the terms of this License or the recipients' exercise of the rights granted hereunder. You may not sublicense the Work. You must keep intact all notices that refer to this License and to the disclaimer of warranties. You may not distribute, publicly display, publicly perform, or publicly digitally perform the Work with any technological measures that control access or use of the Work in a manner inconsistent with the terms of this License Agreement. The above applies to the Work as incorporated in a Collective Work, but this does not require the Collective Work apart from the Work itself to be made subject to the terms of this License. If You create a Collective Work, upon notice from any Licensor You must, to the extent practicable, remove from the Collective Work any reference to such Licensor or the Original Author, as requested. If You create a Derivative Work, upon notice from any Licensor You must, to the extent practicable, remove from the Derivative Work any reference to such Licensor or the Original Author, as requested.\n\n      b. You may distribute, publicly display, publicly perform, or publicly digitally perform a Derivative Work only under the terms of this License, a later version of this License with the same License Elements as this License, or a Creative Commons iCommons license that contains the same License Elements as this License (e.g. Attribution-ShareAlike 2.0 Japan). You must include a copy of, or the Uniform Resource Identifier for, this License or other license specified in the previous sentence with every copy or phonorecord of each Derivative Work You distribute, publicly display, publicly perform, or publicly digitally perform. You may not offer or impose any terms on the Derivative Works that alter or restrict the terms of this License or the recipients' exercise of the rights granted hereunder, and You must keep intact all notices that refer to this License and to the disclaimer of warranties. You may not distribute, publicly display, publicly perform, or publicly digitally perform the Derivative Work with any technological measures that control access or use of the Work in a manner inconsistent with the terms of this License Agreement. The above applies to the Derivative Work as incorporated in a Collective Work, but this does not require the Collective Work apart from the Derivative Work itself to be made subject to the terms of this License.\n\n      c. If you distribute, publicly display, publicly perform, or publicly digitally perform the Work or any Derivative Works or Collective Works, You must keep intact all copyright notices for the Work and give the Original Author credit reasonable to the medium or means You are utilizing by conveying the name (or pseudonym if applicable) of the Original Author if supplied; the title of the Work if supplied; to the extent reasonably practicable, the Uniform Resource Identifier, if any, that Licensor specifies to be associated with the Work, unless such URI does not refer to the copyright notice or licensing information for the Work; and in the case of a Derivative Work, a credit identifying the use of the Work in the Derivative Work (e.g., \"French translation of the Work by Original Author,\" or \"Screenplay based on original Work by Original Author\"). Such credit may be implemented in any reasonable manner; provided, however, that in the case of a Derivative Work or Collective Work, at a minimum such credit will appear where any other comparable authorship credit appears and in a manner at least as prominent as such other comparable authorship credit.\n\n   5. Representations, Warranties and Disclaimer\n\n   UNLESS OTHERWISE AGREED TO BY THE PARTIES IN WRITING, LICENSOR OFFERS THE WORK AS-IS AND MAKES NO REPRESENTATIONS OR WARRANTIES OF ANY KIND CONCERNING THE MATERIALS, EXPRESS, IMPLIED, STATUTORY OR OTHERWISE, INCLUDING, WITHOUT LIMITATION, WARRANTIES OF TITLE, MERCHANTIBILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT, OR THE ABSENCE OF LATENT OR OTHER DEFECTS, ACCURACY, OR THE PRESENCE OF ABSENCE OF ERRORS, WHETHER OR NOT DISCOVERABLE. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OF IMPLIED WARRANTIES, SO SUCH EXCLUSION MAY NOT APPLY TO YOU.\n\n   6. Limitation on Liability. EXCEPT TO THE EXTENT REQUIRED BY APPLICABLE LAW, IN NO EVENT WILL LICENSOR BE LIABLE TO YOU ON ANY LEGAL THEORY FOR ANY SPECIAL, INCIDENTAL, CONSEQUENTIAL, PUNITIVE OR EXEMPLARY DAMAGES ARISING OUT OF THIS LICENSE OR THE USE OF THE WORK, EVEN IF LICENSOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\n   7. Termination\n\n      a. This License and the rights granted hereunder will terminate automatically upon any breach by You of the terms of this License. Individuals or entities who have received Derivative Works or Collective Works from You under this License, however, will not have their licenses terminated provided such individuals or entities remain in full compliance with those licenses. Sections 1, 2, 5, 6, 7, and 8 will survive any termination of this License.\n\n      b. Subject to the above terms and conditions, the license granted here is perpetual (for the duration of the applicable copyright in the Work). Notwithstanding the above, Licensor reserves the right to release the Work under different license terms or to stop distributing the Work at any time; provided, however that any such election will not serve to withdraw this License (or any other license that has been, or is required to be, granted under the terms of this License), and this License will continue in full force and effect unless terminated as stated above.\n\n   8. Miscellaneous\n\n      a. Each time You distribute or publicly digitally perform the Work or a Collective Work, the Licensor offers to the recipient a license to the Work on the same terms and conditions as the license granted to You under this License.\n\n      b. Each time You distribute or publicly digitally perform a Derivative Work, Licensor offers to the recipient a license to the original Work on the same terms and conditions as the license granted to You under this License.\n\n      c. If any provision of this License is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this License, and without further action by the parties to this agreement, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.\n\n      d. No term or provision of this License shall be deemed waived and no breach consented to unless such waiver or consent shall be in writing and signed by the party to be charged with such waiver or consent.\n\n      e. This License constitutes the entire agreement between the parties with respect to the Work licensed here. There are no understandings, agreements or representations with respect to the Work not specified here. Licensor shall not be bound by any additional provisions that may appear in any communication from You. This License may not be modified without the mutual written agreement of the Licensor and You.\n\nCreative Commons is not a party to this License, and makes no warranty whatsoever in connection with the Work. Creative Commons will not be liable to You or any party on any legal theory for any damages whatsoever, including without limitation any general, special, incidental or consequential damages arising in connection to this license. Notwithstanding the foregoing two (2) sentences, if Creative Commons has expressly identified itself as the Licensor hereunder, it shall have all rights and obligations of Licensor.\n\nExcept for the limited purpose of indicating to the public that the Work is licensed under the CCPL, neither party will use the trademark \"Creative Commons\" or any related trademark or logo of Creative Commons without the prior written consent of Creative Commons. Any permitted use will be in compliance with Creative Commons' then-current trademark usage guidelines, as may be published on its website or otherwise made available upon request from time to time.\n\nCreative Commons may be contacted at http://creativecommons.org/."],"licenseIds":["CC-BY-SA-2.0"],"keywords":["commons attribution sharealike 2 0","attribution sharealike 2 0 creative","g attribution sharealike 2 0","attribution sharealike 2 0 japan"]},{"licenseTexts":["Creative Commons Attribution-ShareAlike 2.5 CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE LEGAL SERVICES. DISTRIBUTION OF THIS LICENSE DOES NOT CREATE AN ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS INFORMATION ON AN \"AS-IS\" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES REGARDING THE INFORMATION PROVIDED, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM ITS USE.\n\nLicense\n\nTHE WORK (AS DEFINED BELOW) IS PROVIDED UNDER THE TERMS OF THIS CREATIVE COMMONS PUBLIC LICENSE (\"CCPL\" OR \"LICENSE\"). THE WORK IS PROTECTED BY COPYRIGHT AND/OR OTHER APPLICABLE LAW. ANY USE OF THE WORK OTHER THAN AS AUTHORIZED UNDER THIS LICENSE OR COPYRIGHT LAW IS PROHIBITED.\n\nBY EXERCISING ANY RIGHTS TO THE WORK PROVIDED HERE, YOU ACCEPT AND AGREE TO BE BOUND BY THE TERMS OF THIS LICENSE. THE LICENSOR GRANTS YOU THE RIGHTS CONTAINED HERE IN CONSIDERATION OF YOUR ACCEPTANCE OF SUCH TERMS AND CONDITIONS.\n\n   1. Definitions\n\n      a. \"Collective Work\" means a work, such as a periodical issue, anthology or encyclopedia, in which the Work in its entirety in unmodified form, along with a number of other contributions, constituting separate and independent works in themselves, are assembled into a collective whole. A work that constitutes a Collective Work will not be considered a Derivative Work (as defined below) for the purposes of this License.\n\n      b. \"Derivative Work\" means a work based upon the Work or upon the Work and other pre-existing works, such as a translation, musical arrangement, dramatization, fictionalization, motion picture version, sound recording, art reproduction, abridgment, condensation, or any other form in which the Work may be recast, transformed, or adapted, except that a work that constitutes a Collective Work will not be considered a Derivative Work for the purpose of this License. For the avoidance of doubt, where the Work is a musical composition or sound recording, the synchronization of the Work in timed-relation with a moving image (\"synching\") will be considered a Derivative Work for the purpose of this License.\n\n      c. \"Licensor\" means the individual or entity that offers the Work under the terms of this License.\n\n      d. \"Original Author\" means the individual or entity who created the Work.\n\n      e. \"Work\" means the copyrightable work of authorship offered under the terms of this License.\n\n      f. \"You\" means an individual or entity exercising rights under this License who has not previously violated the terms of this License with respect to the Work, or who has received express permission from the Licensor to exercise rights under this License despite a previous violation.\n\n      g. \"License Elements\" means the following high-level license attributes as selected by Licensor and indicated in the title of this License: Attribution, ShareAlike.\n\n   2. Fair Use Rights. Nothing in this license is intended to reduce, limit, or restrict any rights arising from fair use, first sale or other limitations on the exclusive rights of the copyright owner under copyright law or other applicable laws.\n\n   3. License Grant. Subject to the terms and conditions of this License, Licensor hereby grants You a worldwide, royalty-free, non-exclusive, perpetual (for the duration of the applicable copyright) license to exercise the rights in the Work as stated below:\n\n      a. to reproduce the Work, to incorporate the Work into one or more Collective Works, and to reproduce the Work as incorporated in the Collective Works;\n\n      b. to create and reproduce Derivative Works;\n\n      c. to distribute copies or phonorecords of, display publicly, perform publicly, and perform publicly by means of a digital audio transmission the Work including as incorporated in Collective Works;\n\n      d. to distribute copies or phonorecords of, display publicly, perform publicly, and perform publicly by means of a digital audio transmission Derivative Works.\n\n      e. For the avoidance of doubt, where the work is a musical composition:\n\n         i. Performance Royalties Under Blanket Licenses. Licensor waives the exclusive right to collect, whether individually or via a performance rights society (e.g. ASCAP, BMI, SESAC), royalties for the public performance or public digital performance (e.g. webcast) of the Work.\n\n         ii. Mechanical Rights and Statutory Royalties. Licensor waives the exclusive right to collect, whether individually or via a music rights society or designated agent (e.g. Harry Fox Agency), royalties for any phonorecord You create from the Work (\"cover version\") and distribute, subject to the compulsory license created by 17 USC Section 115 of the US Copyright Act (or the equivalent in other jurisdictions).\n\n      f. Webcasting Rights and Statutory Royalties. For the avoidance of doubt, where the Work is a sound recording, Licensor waives the exclusive right to collect, whether individually or via a performance-rights society (e.g. SoundExchange), royalties for the public digital performance (e.g. webcast) of the Work, subject to the compulsory license created by 17 USC Section 114 of the US Copyright Act (or the equivalent in other jurisdictions).\n\n   The above rights may be exercised in all media and formats whether now known or hereafter devised. The above rights include the right to make such modifications as are technically necessary to exercise the rights in other media and formats. All rights not expressly granted by Licensor are hereby reserved.\n\n   4. Restrictions. The license granted in Section 3 above is expressly made subject to and limited by the following restrictions:\n\n      a. You may distribute, publicly display, publicly perform, or publicly digitally perform the Work only under the terms of this License, and You must include a copy of, or the Uniform Resource Identifier for, this License with every copy or phonorecord of the Work You distribute, publicly display, publicly perform, or publicly digitally perform. You may not offer or impose any terms on the Work that alter or restrict the terms of this License or the recipients' exercise of the rights granted hereunder. You may not sublicense the Work. You must keep intact all notices that refer to this License and to the disclaimer of warranties. You may not distribute, publicly display, publicly perform, or publicly digitally perform the Work with any technological measures that control access or use of the Work in a manner inconsistent with the terms of this License Agreement. The above applies to the Work as incorporated in a Collective Work, but this does not require the Collective Work apart from the Work itself to be made subject to the terms of this License. If You create a Collective Work, upon notice from any Licensor You must, to the extent practicable, remove from the Collective Work any credit as required by clause 4(c), as requested. If You create a Derivative Work, upon notice from any Licensor You must, to the extent practicable, remove from the Derivative Work any credit as required by clause 4(c), as requested.\n\n      b. You may distribute, publicly display, publicly perform, or publicly digitally perform a Derivative Work only under the terms of this License, a later version of this License with the same License Elements as this License, or a Creative Commons iCommons license that contains the same License Elements as this License (e.g. Attribution-ShareAlike 2.5 Japan). You must include a copy of, or the Uniform Resource Identifier for, this License or other license specified in the previous sentence with every copy or phonorecord of each Derivative Work You distribute, publicly display, publicly perform, or publicly digitally perform. You may not offer or impose any terms on the Derivative Works that alter or restrict the terms of this License or the recipients' exercise of the rights granted hereunder, and You must keep intact all notices that refer to this License and to the disclaimer of warranties. You may not distribute, publicly display, publicly perform, or publicly digitally perform the Derivative Work with any technological measures that control access or use of the Work in a manner inconsistent with the terms of this License Agreement. The above applies to the Derivative Work as incorporated in a Collective Work, but this does not require the Collective Work apart from the Derivative Work itself to be made subject to the terms of this License.\n\n      c. If you distribute, publicly display, publicly perform, or publicly digitally perform the Work or any Derivative Works or Collective Works, You must keep intact all copyright notices for the Work and provide, reasonable to the medium or means You are utilizing: (i) the name of the Original Author (or pseudonym, if applicable) if supplied, and/or (ii) if the Original Author and/or Licensor designate another party or parties (e.g. a sponsor institute, publishing entity, journal) for attribution in Licensor's copyright notice, terms of service or by other reasonable means, the name of such party or parties; the title of the Work if supplied; to the extent reasonably practicable, the Uniform Resource Identifier, if any, that Licensor specifies to be associated with the Work, unless such URI does not refer to the copyright notice or licensing information for the Work; and in the case of a Derivative Work, a credit identifying the use of the Work in the Derivative Work (e.g., \"French translation of the Work by Original Author,\" or \"Screenplay based on original Work by Original Author\"). Such credit may be implemented in any reasonable manner; provided, however, that in the case of a Derivative Work or Collective Work, at a minimum such credit will appear where any other comparable authorship credit appears and in a manner at least as prominent as such other comparable authorship credit.\n\n   5. Representations, Warranties and Disclaimer\n\n   UNLESS OTHERWISE AGREED TO BY THE PARTIES IN WRITING, LICENSOR OFFERS THE WORK AS-IS AND MAKES NO REPRESENTATIONS OR WARRANTIES OF ANY KIND CONCERNING THE MATERIALS, EXPRESS, IMPLIED, STATUTORY OR OTHERWISE, INCLUDING, WITHOUT LIMITATION, WARRANTIES OF TITLE, MERCHANTIBILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT, OR THE ABSENCE OF LATENT OR OTHER DEFECTS, ACCURACY, OR THE PRESENCE OF ABSENCE OF ERRORS, WHETHER OR NOT DISCOVERABLE. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OF IMPLIED WARRANTIES, SO SUCH EXCLUSION MAY NOT APPLY TO YOU.\n\n   6. Limitation on Liability. EXCEPT TO THE EXTENT REQUIRED BY APPLICABLE LAW, IN NO EVENT WILL LICENSOR BE LIABLE TO YOU ON ANY LEGAL THEORY FOR ANY SPECIAL, INCIDENTAL, CONSEQUENTIAL, PUNITIVE OR EXEMPLARY DAMAGES ARISING OUT OF THIS LICENSE OR THE USE OF THE WORK, EVEN IF LICENSOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\n   7. Termination\n\n      a. This License and the rights granted hereunder will terminate automatically upon any breach by You of the terms of this License. Individuals or entities who have received Derivative Works or Collective Works from You under this License, however, will not have their licenses terminated provided such individuals or entities remain in full compliance with those licenses. Sections 1, 2, 5, 6, 7, and 8 will survive any termination of this License.\n\n      b. Subject to the above terms and conditions, the license granted here is perpetual (for the duration of the applicable copyright in the Work). Notwithstanding the above, Licensor reserves the right to release the Work under different license terms or to stop distributing the Work at any time; provided, however that any such election will not serve to withdraw this License (or any other license that has been, or is required to be, granted under the terms of this License), and this License will continue in full force and effect unless terminated as stated above.\n\n   8. Miscellaneous\n\n      a. Each time You distribute or publicly digitally perform the Work or a Collective Work, the Licensor offers to the recipient a license to the Work on the same terms and conditions as the license granted to You under this License.\n\n      b. Each time You distribute or publicly digitally perform a Derivative Work, Licensor offers to the recipient a license to the original Work on the same terms and conditions as the license granted to You under this License.\n\n      c. If any provision of this License is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this License, and without further action by the parties to this agreement, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.\n\n      d. No term or provision of this License shall be deemed waived and no breach consented to unless such waiver or consent shall be in writing and signed by the party to be charged with such waiver or consent.\n\n      e. This License constitutes the entire agreement between the parties with respect to the Work licensed here. There are no understandings, agreements or representations with respect to the Work not specified here. Licensor shall not be bound by any additional provisions that may appear in any communication from You. This License may not be modified without the mutual written agreement of the Licensor and You.\n\nCreative Commons is not a party to this License, and makes no warranty whatsoever in connection with the Work. Creative Commons will not be liable to You or any party on any legal theory for any damages whatsoever, including without limitation any general, special, incidental or consequential damages arising in connection to this license. Notwithstanding the foregoing two (2) sentences, if Creative Commons has expressly identified itself as the Licensor hereunder, it shall have all rights and obligations of Licensor.\n\nExcept for the limited purpose of indicating to the public that the Work is licensed under the CCPL, neither party will use the trademark \"Creative Commons\" or any related trademark or logo of Creative Commons without the prior written consent of Creative Commons. Any permitted use will be in compliance with Creative Commons' then-current trademark usage guidelines, as may be published on its website or otherwise made available upon request from time to time.\n\nCreative Commons may be contacted at http://creativecommons.org/."],"licenseIds":["CC-BY-SA-2.5"],"keywords":["commons attribution sharealike 2 5","attribution sharealike 2 5 creative","g attribution sharealike 2 5","attribution sharealike 2 5 japan"]},{"licenseTexts":["Creative Commons Attribution-ShareAlike 3.0 Unported CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE LEGAL SERVICES. DISTRIBUTION OF THIS LICENSE DOES NOT CREATE AN ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS INFORMATION ON AN \"AS-IS\" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES REGARDING THE INFORMATION PROVIDED, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM ITS USE.\n\nLicense\n\nTHE WORK (AS DEFINED BELOW) IS PROVIDED UNDER THE TERMS OF THIS CREATIVE COMMONS PUBLIC LICENSE (\"CCPL\" OR \"LICENSE\"). THE WORK IS PROTECTED BY COPYRIGHT AND/OR OTHER APPLICABLE LAW. ANY USE OF THE WORK OTHER THAN AS AUTHORIZED UNDER THIS LICENSE OR COPYRIGHT LAW IS PROHIBITED.\n\nBY EXERCISING ANY RIGHTS TO THE WORK PROVIDED HERE, YOU ACCEPT AND AGREE TO BE BOUND BY THE TERMS OF THIS LICENSE. TO THE EXTENT THIS LICENSE MAY BE CONSIDERED TO BE A CONTRACT, THE LICENSOR GRANTS YOU THE RIGHTS CONTAINED HERE IN CONSIDERATION OF YOUR ACCEPTANCE OF SUCH TERMS AND CONDITIONS.\n\n   1. Definitions\n\n      a. \"Adaptation\" means a work based upon the Work, or upon the Work and other pre-existing works, such as a translation, adaptation, derivative work, arrangement of music or other alterations of a literary or artistic work, or phonogram or performance and includes cinematographic adaptations or any other form in which the Work may be recast, transformed, or adapted including in any form recognizably derived from the original, except that a work that constitutes a Collection will not be considered an Adaptation for the purpose of this License. For the avoidance of doubt, where the Work is a musical work, performance or phonogram, the synchronization of the Work in timed-relation with a moving image (\"synching\") will be considered an Adaptation for the purpose of this License.\n\n      b. \"Collection\" means a collection of literary or artistic works, such as encyclopedias and anthologies, or performances, phonograms or broadcasts, or other works or subject matter other than works listed in Section 1(f) below, which, by reason of the selection and arrangement of their contents, constitute intellectual creations, in which the Work is included in its entirety in unmodified form along with one or more other contributions, each constituting separate and independent works in themselves, which together are assembled into a collective whole. A work that constitutes a Collection will not be considered an Adaptation (as defined below) for the purposes of this License.\n\n      c. \"Creative Commons Compatible License\" means a license that is listed at http://creativecommons.org/compatiblelicenses that has been approved by Creative Commons as being essentially equivalent to this License, including, at a minimum, because that license: (i) contains terms that have the same purpose, meaning and effect as the License Elements of this License; and, (ii) explicitly permits the relicensing of adaptations of works made available under that license under this License or a Creative Commons jurisdiction license with the same License Elements as this License.\n\n      d. \"Distribute\" means to make available to the public the original and copies of the Work or Adaptation, as appropriate, through sale or other transfer of ownership.\n\n      e. \"License Elements\" means the following high-level license attributes as selected by Licensor and indicated in the title of this License: Attribution, ShareAlike.\n\n      f. \"Licensor\" means the individual, individuals, entity or entities that offer(s) the Work under the terms of this License.\n\n      g. \"Original Author\" means, in the case of a literary or artistic work, the individual, individuals, entity or entities who created the Work or if no individual or entity can be identified, the publisher; and in addition (i) in the case of a performance the actors, singers, musicians, dancers, and other persons who act, sing, deliver, declaim, play in, interpret or otherwise perform literary or artistic works or expressions of folklore; (ii) in the case of a phonogram the producer being the person or legal entity who first fixes the sounds of a performance or other sounds; and, (iii) in the case of broadcasts, the organization that transmits the broadcast.\n\n      h. \"Work\" means the literary and/or artistic work offered under the terms of this License including without limitation any production in the literary, scientific and artistic domain, whatever may be the mode or form of its expression including digital form, such as a book, pamphlet and other writing; a lecture, address, sermon or other work of the same nature; a dramatic or dramatico-musical work; a choreographic work or entertainment in dumb show; a musical composition with or without words; a cinematographic work to which are assimilated works expressed by a process analogous to cinematography; a work of drawing, painting, architecture, sculpture, engraving or lithography; a photographic work to which are assimilated works expressed by a process analogous to photography; a work of applied art; an illustration, map, plan, sketch or three-dimensional work relative to geography, topography, architecture or science; a performance; a broadcast; a phonogram; a compilation of data to the extent it is protected as a copyrightable work; or a work performed by a variety or circus performer to the extent it is not otherwise considered a literary or artistic work.\n\n      i. \"You\" means an individual or entity exercising rights under this License who has not previously violated the terms of this License with respect to the Work, or who has received express permission from the Licensor to exercise rights under this License despite a previous violation.\n\n      j. \"Publicly Perform\" means to perform public recitations of the Work and to communicate to the public those public recitations, by any means or process, including by wire or wireless means or public digital performances; to make available to the public Works in such a way that members of the public may access these Works from a place and at a place individually chosen by them; to perform the Work to the public by any means or process and the communication to the public of the performances of the Work, including by public digital performance; to broadcast and rebroadcast the Work by any means including signs, sounds or images.\n\n      k. \"Reproduce\" means to make copies of the Work by any means including without limitation by sound or visual recordings and the right of fixation and reproducing fixations of the Work, including storage of a protected performance or phonogram in digital form or other electronic medium.\n\n   2. Fair Dealing Rights. Nothing in this License is intended to reduce, limit, or restrict any uses free from copyright or rights arising from limitations or exceptions that are provided for in connection with the copyright protection under copyright law or other applicable laws.\n\n   3. License Grant. Subject to the terms and conditions of this License, Licensor hereby grants You a worldwide, royalty-free, non-exclusive, perpetual (for the duration of the applicable copyright) license to exercise the rights in the Work as stated below:\n\n      a. to Reproduce the Work, to incorporate the Work into one or more Collections, and to Reproduce the Work as incorporated in the Collections;\n\n      b. to create and Reproduce Adaptations provided that any such Adaptation, including any translation in any medium, takes reasonable steps to clearly label, demarcate or otherwise identify that changes were made to the original Work. For example, a translation could be marked \"The original work was translated from English to Spanish,\" or a modification could indicate \"The original work has been modified.\";\n\n      c. to Distribute and Publicly Perform the Work including as incorporated in Collections; and,\n\n      d. to Distribute and Publicly Perform Adaptations.\n\n      e. For the avoidance of doubt:\n\n         i. Non-waivable Compulsory License Schemes. In those jurisdictions in which the right to collect royalties through any statutory or compulsory licensing scheme cannot be waived, the Licensor reserves the exclusive right to collect such royalties for any exercise by You of the rights granted under this License;\n\n         ii. Waivable Compulsory License Schemes. In those jurisdictions in which the right to collect royalties through any statutory or compulsory licensing scheme can be waived, the Licensor waives the exclusive right to collect such royalties for any exercise by You of the rights granted under this License; and,\n\n         iii. Voluntary License Schemes. The Licensor waives the right to collect royalties, whether individually or, in the event that the Licensor is a member of a collecting society that administers voluntary licensing schemes, via that society, from any exercise by You of the rights granted under this License.\n\n   The above rights may be exercised in all media and formats whether now known or hereafter devised. The above rights include the right to make such modifications as are technically necessary to exercise the rights in other media and formats. Subject to Section 8(f), all rights not expressly granted by Licensor are hereby reserved.\n\n   4. Restrictions. The license granted in Section 3 above is expressly made subject to and limited by the following restrictions:\n\n      a. You may Distribute or Publicly Perform the Work only under the terms of this License. You must include a copy of, or the Uniform Resource Identifier (URI) for, this License with every copy of the Work You Distribute or Publicly Perform. You may not offer or impose any terms on the Work that restrict the terms of this License or the ability of the recipient of the Work to exercise the rights granted to that recipient under the terms of the License. You may not sublicense the Work. You must keep intact all notices that refer to this License and to the disclaimer of warranties with every copy of the Work You Distribute or Publicly Perform. When You Distribute or Publicly Perform the Work, You may not impose any effective technological measures on the Work that restrict the ability of a recipient of the Work from You to exercise the rights granted to that recipient under the terms of the License. This Section 4(a) applies to the Work as incorporated in a Collection, but this does not require the Collection apart from the Work itself to be made subject to the terms of this License. If You create a Collection, upon notice from any Licensor You must, to the extent practicable, remove from the Collection any credit as required by Section 4(c), as requested. If You create an Adaptation, upon notice from any Licensor You must, to the extent practicable, remove from the Adaptation any credit as required by Section 4(c), as requested.\n\n      b. You may Distribute or Publicly Perform an Adaptation only under the terms of: (i) this License; (ii) a later version of this License with the same License Elements as this License; (iii) a Creative Commons jurisdiction license (either this or a later license version) that contains the same License Elements as this License (e.g., Attribution-ShareAlike 3.0 US)); (iv) a Creative Commons Compatible License. If you license the Adaptation under one of the licenses mentioned in (iv), you must comply with the terms of that license. If you license the Adaptation under the terms of any of the licenses mentioned in (i), (ii) or (iii) (the \"Applicable License\"), you must comply with the terms of the Applicable License generally and the following provisions: (I) You must include a copy of, or the URI for, the Applicable License with every copy of each Adaptation You Distribute or Publicly Perform; (II) You may not offer or impose any terms on the Adaptation that restrict the terms of the Applicable License or the ability of the recipient of the Adaptation to exercise the rights granted to that recipient under the terms of the Applicable License; (III) You must keep intact all notices that refer to the Applicable License and to the disclaimer of warranties with every copy of the Work as included in the Adaptation You Distribute or Publicly Perform; (IV) when You Distribute or Publicly Perform the Adaptation, You may not impose any effective technological measures on the Adaptation that restrict the ability of a recipient of the Adaptation from You to exercise the rights granted to that recipient under the terms of the Applicable License. This Section 4(b) applies to the Adaptation as incorporated in a Collection, but this does not require the Collection apart from the Adaptation itself to be made subject to the terms of the Applicable License.\n\n      c. If You Distribute, or Publicly Perform the Work or any Adaptations or Collections, You must, unless a request has been made pursuant to Section 4(a), keep intact all copyright notices for the Work and provide, reasonable to the medium or means You are utilizing: (i) the name of the Original Author (or pseudonym, if applicable) if supplied, and/or if the Original Author and/or Licensor designate another party or parties (e.g., a sponsor institute, publishing entity, journal) for attribution (\"Attribution Parties\") in Licensor's copyright notice, terms of service or by other reasonable means, the name of such party or parties; (ii) the title of the Work if supplied; (iii) to the extent reasonably practicable, the URI, if any, that Licensor specifies to be associated with the Work, unless such URI does not refer to the copyright notice or licensing information for the Work; and (iv), consistent with Section 3(b), in the case of an Adaptation, a credit identifying the use of the Work in the Adaptation (e.g., \"French translation of the Work by Original Author,\" or \"Screenplay based on original Work by Original Author\"). The credit required by this Section 4(c) may be implemented in any reasonable manner; provided, however, that in the case of a Adaptation or Collection, at a minimum such credit will appear, if a credit for all contributing authors of the Adaptation or Collection appears, then as part of these credits and in a manner at least as prominent as the credits for the other contributing authors. For the avoidance of doubt, You may only use the credit required by this Section for the purpose of attribution in the manner set out above and, by exercising Your rights under this License, You may not implicitly or explicitly assert or imply any connection with, sponsorship or endorsement by the Original Author, Licensor and/or Attribution Parties, as appropriate, of You or Your use of the Work, without the separate, express prior written permission of the Original Author, Licensor and/or Attribution Parties.\n\n      d. Except as otherwise agreed in writing by the Licensor or as may be otherwise permitted by applicable law, if You Reproduce, Distribute or Publicly Perform the Work either by itself or as part of any Adaptations or Collections, You must not distort, mutilate, modify or take other derogatory action in relation to the Work which would be prejudicial to the Original Author's honor or reputation. Licensor agrees that in those jurisdictions (e.g. Japan), in which any exercise of the right granted in Section 3(b) of this License (the right to make Adaptations) would be deemed to be a distortion, mutilation, modification or other derogatory action prejudicial to the Original Author's honor and reputation, the Licensor will waive or not assert, as appropriate, this Section, to the fullest extent permitted by the applicable national law, to enable You to reasonably exercise Your right under Section 3(b) of this License (right to make Adaptations) but not otherwise.\n\n   5. Representations, Warranties and Disclaimer\n\n   UNLESS OTHERWISE MUTUALLY AGREED TO BY THE PARTIES IN WRITING, LICENSOR OFFERS THE WORK AS-IS AND MAKES NO REPRESENTATIONS OR WARRANTIES OF ANY KIND CONCERNING THE WORK, EXPRESS, IMPLIED, STATUTORY OR OTHERWISE, INCLUDING, WITHOUT LIMITATION, WARRANTIES OF TITLE, MERCHANTIBILITY, FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT, OR THE ABSENCE OF LATENT OR OTHER DEFECTS, ACCURACY, OR THE PRESENCE OF ABSENCE OF ERRORS, WHETHER OR NOT DISCOVERABLE. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OF IMPLIED WARRANTIES, SO SUCH EXCLUSION MAY NOT APPLY TO YOU.\n\n   6. Limitation on Liability. EXCEPT TO THE EXTENT REQUIRED BY APPLICABLE LAW, IN NO EVENT WILL LICENSOR BE LIABLE TO YOU ON ANY LEGAL THEORY FOR ANY SPECIAL, INCIDENTAL, CONSEQUENTIAL, PUNITIVE OR EXEMPLARY DAMAGES ARISING OUT OF THIS LICENSE OR THE USE OF THE WORK, EVEN IF LICENSOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\n   7. Termination\n\n      a. This License and the rights granted hereunder will terminate automatically upon any breach by You of the terms of this License. Individuals or entities who have received Adaptations or Collections from You under this License, however, will not have their licenses terminated provided such individuals or entities remain in full compliance with those licenses. Sections 1, 2, 5, 6, 7, and 8 will survive any termination of this License.\n\n      b. Subject to the above terms and conditions, the license granted here is perpetual (for the duration of the applicable copyright in the Work). Notwithstanding the above, Licensor reserves the right to release the Work under different license terms or to stop distributing the Work at any time; provided, however that any such election will not serve to withdraw this License (or any other license that has been, or is required to be, granted under the terms of this License), and this License will continue in full force and effect unless terminated as stated above.\n\n   8. Miscellaneous\n\n      a. Each time You Distribute or Publicly Perform the Work or a Collection, the Licensor offers to the recipient a license to the Work on the same terms and conditions as the license granted to You under this License.\n\n      b. Each time You Distribute or Publicly Perform an Adaptation, Licensor offers to the recipient a license to the original Work on the same terms and conditions as the license granted to You under this License.\n\n      c. If any provision of this License is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this License, and without further action by the parties to this agreement, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.\n\n      d. No term or provision of this License shall be deemed waived and no breach consented to unless such waiver or consent shall be in writing and signed by the party to be charged with such waiver or consent.\n\n      e. This License constitutes the entire agreement between the parties with respect to the Work licensed here. There are no understandings, agreements or representations with respect to the Work not specified here. Licensor shall not be bound by any additional provisions that may appear in any communication from You. This License may not be modified without the mutual written agreement of the Licensor and You.\n\n      f. The rights granted under, and the subject matter referenced, in this License were drafted utilizing the terminology of the Berne Convention for the Protection of Literary and Artistic Works (as amended on September 28, 1979), the Rome Convention of 1961, the WIPO Copyright Treaty of 1996, the WIPO Performances and Phonograms Treaty of 1996 and the Universal Copyright Convention (as revised on July 24, 1971). These rights and subject matter take effect in the relevant jurisdiction in which the License terms are sought to be enforced according to the corresponding provisions of the implementation of those treaty provisions in the applicable national law. If the standard suite of rights granted under applicable copyright law includes additional rights not granted under this License, such additional rights are deemed to be included in the License; this License is not intended to restrict the license of any rights under applicable law.\n\nCreative Commons Notice\n\nCreative Commons is not a party to this License, and makes no warranty whatsoever in connection with the Work. Creative Commons will not be liable to You or any party on any legal theory for any damages whatsoever, including without limitation any general, special, incidental or consequential damages arising in connection to this license. Notwithstanding the foregoing two (2) sentences, if Creative Commons has expressly identified itself as the Licensor hereunder, it shall have all rights and obligations of Licensor.\n\nExcept for the limited purpose of indicating to the public that the Work is licensed under the CCPL, Creative Commons does not authorize the use by either party of the trademark \"Creative Commons\" or any related trademark or logo of Creative Commons without the prior written consent of Creative Commons. Any permitted use will be in compliance with Creative Commons' then-current trademark usage guidelines, as may be published on its website or otherwise made available upon request from time to time. For the avoidance of doubt, this trademark restriction does not form part of the License.\n\nCreative Commons may be contacted at http://creativecommons.org/."],"licenseIds":["CC-BY-SA-3.0"],"keywords":["license c creative","c creative commons","that is listed","is listed at","listed at http","org compatiblelicenses that","compatiblelicenses that has","commons as being","as being essentially","being essentially equivalent","essentially equivalent to","equivalent to this","license including at","including at a","a minimum because","minimum because that","because that license","that license i","license i contains","i contains terms","terms that have","that have the","same purpose meaning","purpose meaning and","meaning and effect","and effect as","and ii explicitly","ii explicitly permits","explicitly permits the","permits the relicensing","the relicensing of","relicensing of adaptations","of adaptations of","adaptations of works","of works made","that license under","license under this","jurisdiction license with","license d distribute","d distribute means","of ownership e","ownership e license","e license elements","attribution sharealike f","sharealike f licensor","f licensor means","this license g","license g original","g original author","the broadcast h","broadcast h work","h work means","artistic work i","work i you","i you means","previous violation j","violation j publicly","j publicly perform","or images k","images k reproduce","k reproduce means","0 us iv","us iv a","iv a creative","adaptation under one","mentioned in iv","in iv you","that license if","adaptation under the","mentioned in i","in i ii","i ii or","ii or iii","or iii the","iii the applicable","applicable license generally","license generally and","generally and the","the following provisions","following provisions i","provisions i you","i you must","uri for the","for the applicable","publicly perform ii","perform ii you","ii you may","applicable license iii","license iii you","publicly perform iv","perform iv when","iv when you","parties d except","d except as","commons attribution sharealike 3","adaptation as defined below","this license c creative","license c creative commons","c creative commons compatible","commons compatible license means","means a license that","license that is listed","that is listed at","is listed at http","listed at http creativecommons","http creativecommons org compatiblelicenses","creativecommons org compatiblelicenses that","org compatiblelicenses that has","compatiblelicenses that has been","that has been approved","been approved by creative","creative commons as being","commons as being essentially","as being essentially equivalent","being essentially equivalent to","essentially equivalent to this","equivalent to this license","this license including at","license including at a","including at a minimum","at a minimum because","a minimum because that","minimum because that license","because that license i","that license i contains","license i contains terms","i contains terms that","contains terms that have","terms that have the","that have the same","have the same purpose","the same purpose meaning","same purpose meaning and","purpose meaning and effect","meaning and effect as","and effect as the","effect as the license","as the license elements","elements of this license","this license and ii","license and ii explicitly","and ii explicitly permits","ii explicitly permits the","explicitly permits the relicensing","permits the relicensing of","the relicensing of adaptations","relicensing of adaptations of","of adaptations of works","adaptations of works made","of works made available","works made available under","made available under that","under that license under","that license under this","license under this license","commons jurisdiction license with","jurisdiction license with the","as this license d","this license d distribute","license d distribute means","d distribute means to","transfer of ownership e","of ownership e license","ownership e license elements","e license elements means","license attribution sharealike f","attribution sharealike f licensor","sharealike f licensor means","f licensor means the","of this license g","this license g original","license g original author","g original author means","transmits the broadcast h","the broadcast h work","broadcast h work means","h work means the","or artistic work i","artistic work i you","work i you means","i you means an","a previous violation j","previous violation j publicly","violation j publicly perform","j publicly perform means","sounds or images k","or images k reproduce","images k reproduce means","k reproduce means to","adaptation only under the","g attribution sharealike 3","3 0 us iv","0 us iv a","us iv a creative","iv a creative commons","a creative commons compatible","commons compatible license if","the adaptation under one","adaptation under one of","licenses mentioned in iv"]},{"licenseTexts":["Creative Commons Attribution-ShareAlike 4.0 International Creative Commons Corporation (\"Creative Commons\") is not a law firm and does not provide legal services or legal advice. Distribution of Creative Commons public licenses does not create a lawyer-client or other relationship. Creative Commons makes its licenses and related information available on an \"as-is\" basis. Creative Commons gives no warranties regarding its licenses, any material licensed under their terms and conditions, or any related information. Creative Commons disclaims all liability for damages resulting from their use to the fullest extent possible.\n\nUsing Creative Commons Public Licenses\n\nCreative Commons public licenses provide a standard set of terms and conditions that creators and other rights holders may use to share original works of authorship and other material subject to copyright and certain other rights specified in the public license below. The following considerations are for informational purposes only, are not exhaustive, and do not form part of our licenses.\n\nConsiderations for licensors: Our public licenses are intended for use by those authorized to give the public permission to use material in ways otherwise restricted by copyright and certain other rights. Our licenses are irrevocable. Licensors should read and understand the terms and conditions of the license they choose before applying it. Licensors should also secure all rights necessary before applying our licenses so that the public can reuse the material as expected. Licensors should clearly mark any material not subject to the license. This includes other CC-licensed material, or material used under an exception or limitation to copyright. More considerations for licensors : wiki.creativecommons.org/Considerations_for_licensors\n\nConsiderations for the public: By using one of our public licenses, a licensor grants the public permission to use the licensed material under specified terms and conditions. If the licensor's permission is not necessary for any reason–for example, because of any applicable exception or limitation to copyright–then that use is not regulated by the license. Our licenses grant only permissions under copyright and certain other rights that a licensor has authority to grant. Use of the licensed material may still be restricted for other reasons, including because others have copyright or other rights in the material. A licensor may make special requests, such as asking that all changes be marked or described.\n\nAlthough not required by our licenses, you are encouraged to respect those requests where reasonable. More considerations for the public : wiki.creativecommons.org/Considerations_for_licensees\n\nCreative Commons Attribution-ShareAlike 4.0 International Public License\n\nBy exercising the Licensed Rights (defined below), You accept and agree to be bound by the terms and conditions of this Creative Commons Attribution-ShareAlike 4.0 International Public License (\"Public License\"). To the extent this Public License may be interpreted as a contract, You are granted the Licensed Rights in consideration of Your acceptance of these terms and conditions, and the Licensor grants You such rights in consideration of benefits the Licensor receives from making the Licensed Material available under these terms and conditions.\n\nSection 1 – Definitions.\n\n   a. Adapted Material means material subject to Copyright and Similar Rights that is derived from or based upon the Licensed Material and in which the Licensed Material is translated, altered, arranged, transformed, or otherwise modified in a manner requiring permission under the Copyright and Similar Rights held by the Licensor. For purposes of this Public License, where the Licensed Material is a musical work, performance, or sound recording, Adapted Material is always produced where the Licensed Material is synched in timed relation with a moving image.\n\n   b. Adapter's License means the license You apply to Your Copyright and Similar Rights in Your contributions to Adapted Material in accordance with the terms and conditions of this Public License.\n\n   c. BY-SA Compatible License means a license listed at creativecommons.org/compatiblelicenses, approved by Creative Commons as essentially the equivalent of this Public License.\n\n   d. Copyright and Similar Rights means copyright and/or similar rights closely related to copyright including, without limitation, performance, broadcast, sound recording, and Sui Generis Database Rights, without regard to how the rights are labeled or categorized. For purposes of this Public License, the rights specified in Section 2(b)(1)-(2) are not Copyright and Similar Rights.\n\n   e. Effective Technological Measures means those measures that, in the absence of proper authority, may not be circumvented under laws fulfilling obligations under Article 11 of the WIPO Copyright Treaty adopted on December 20, 1996, and/or similar international agreements.\n\n   f. Exceptions and Limitations means fair use, fair dealing, and/or any other exception or limitation to Copyright and Similar Rights that applies to Your use of the Licensed Material.\n\n   g. License Elements means the license attributes listed in the name of a Creative Commons Public License. The License Elements of this Public License are Attribution and ShareAlike.\n\n   h. Licensed Material means the artistic or literary work, database, or other material to which the Licensor applied this Public License.\n\n   i. Licensed Rights means the rights granted to You subject to the terms and conditions of this Public License, which are limited to all Copyright and Similar Rights that apply to Your use of the Licensed Material and that the Licensor has authority to license.\n\n   j. Licensor means the individual(s) or entity(ies) granting rights under this Public License.\n\n   k. Share means to provide material to the public by any means or process that requires permission under the Licensed Rights, such as reproduction, public display, public performance, distribution, dissemination, communication, or importation, and to make material available to the public including in ways that members of the public may access the material from a place and at a time individually chosen by them.\n\n   l. Sui Generis Database Rights means rights other than copyright resulting from Directive 96/9/EC of the European Parliament and of the Council of 11 March 1996 on the legal protection of databases, as amended and/or succeeded, as well as other essentially equivalent rights anywhere in the world.\n\n   m. You means the individual or entity exercising the Licensed Rights under this Public License. Your has a corresponding meaning.\n\nSection 2 – Scope.\n\n   a. License grant.\n\n      1. Subject to the terms and conditions of this Public License, the Licensor hereby grants You a worldwide, royalty-free, non-sublicensable, non-exclusive, irrevocable license to exercise the Licensed Rights in the Licensed Material to:\n\n         A. reproduce and Share the Licensed Material, in whole or in part; and\n\n         B. produce, reproduce, and Share Adapted Material.\n\n      2. Exceptions and Limitations. For the avoidance of doubt, where Exceptions and Limitations apply to Your use, this Public License does not apply, and You do not need to comply with its terms and conditions.\n\n      3. Term. The term of this Public License is specified in Section 6(a).\n\n      4. Media and formats; technical modifications allowed. The Licensor authorizes You to exercise the Licensed Rights in all media and formats whether now known or hereafter created, and to make technical modifications necessary to do so. The Licensor waives and/or agrees not to assert any right or authority to forbid You from making technical modifications necessary to exercise the Licensed Rights, including technical modifications necessary to circumvent Effective Technological Measures. For purposes of this Public License, simply making modifications authorized by this Section 2(a)(4) never produces Adapted Material.\n\n      5. Downstream recipients.\n\n         A. Offer from the Licensor – Licensed Material. Every recipient of the Licensed Material automatically receives an offer from the Licensor to exercise the Licensed Rights under the terms and conditions of this Public License.\n\n         B. Additional offer from the Licensor – Adapted Material. Every recipient of Adapted Material from You automatically receives an offer from the Licensor to exercise the Licensed Rights in the Adapted Material under the conditions of the Adapter's License You apply.\n\n         C. No downstream restrictions. You may not offer or impose any additional or different terms or conditions on, or apply any Effective Technological Measures to, the Licensed Material if doing so restricts exercise of the Licensed Rights by any recipient of the Licensed Material.\n\n      6. No endorsement. Nothing in this Public License constitutes or may be construed as permission to assert or imply that You are, or that Your use of the Licensed Material is, connected with, or sponsored, endorsed, or granted official status by, the Licensor or others designated to receive attribution as provided in Section 3(a)(1)(A)(i).\n\n   b. Other rights.\n\n      1. Moral rights, such as the right of integrity, are not licensed under this Public License, nor are publicity, privacy, and/or other similar personality rights; however, to the extent possible, the Licensor waives and/or agrees not to assert any such rights held by the Licensor to the limited extent necessary to allow You to exercise the Licensed Rights, but not otherwise.\n\n      2. Patent and trademark rights are not licensed under this Public License.\n\n      3. To the extent possible, the Licensor waives any right to collect royalties from You for the exercise of the Licensed Rights, whether directly or through a collecting society under any voluntary or waivable statutory or compulsory licensing scheme. In all other cases the Licensor expressly reserves any right to collect such royalties.\n\nSection 3 – License Conditions.\n\nYour exercise of the Licensed Rights is expressly made subject to the following conditions.\n\n   a. Attribution.\n\n      1. If You Share the Licensed Material (including in modified form), You must:\n\n         A. retain the following if it is supplied by the Licensor with the Licensed Material:\n\n            i. identification of the creator(s) of the Licensed Material and any others designated to receive attribution, in any reasonable manner requested by the Licensor (including by pseudonym if designated);\n\n            ii. a copyright notice;\n\n            iii. a notice that refers to this Public License;\n\n            iv. a notice that refers to the disclaimer of warranties;\n\n            v. a URI or hyperlink to the Licensed Material to the extent reasonably practicable;\n\n         B. indicate if You modified the Licensed Material and retain an indication of any previous modifications; and\n\n         C. indicate the Licensed Material is licensed under this Public License, and include the text of, or the URI or hyperlink to, this Public License.\n\n      2. You may satisfy the conditions in Section 3(a)(1) in any reasonable manner based on the medium, means, and context in which You Share the Licensed Material. For example, it may be reasonable to satisfy the conditions by providing a URI or hyperlink to a resource that includes the required information.\n\n      3. If requested by the Licensor, You must remove any of the information required by Section 3(a)(1)(A) to the extent reasonably practicable.\n\n   b. ShareAlike.In addition to the conditions in Section 3(a), if You Share Adapted Material You produce, the following conditions also apply.\n\n      1. The Adapter's License You apply must be a Creative Commons license with the same License Elements, this version or later, or a BY-SA Compatible License.\n\n      2. You must include the text of, or the URI or hyperlink to, the Adapter's License You apply. You may satisfy this condition in any reasonable manner based on the medium, means, and context in which You Share Adapted Material.\n\n      3. You may not offer or impose any additional or different terms or conditions on, or apply any Effective Technological Measures to, Adapted Material that restrict exercise of the rights granted under the Adapter's License You apply.\n\nSection 4 – Sui Generis Database Rights.\n\nWhere the Licensed Rights include Sui Generis Database Rights that apply to Your use of the Licensed Material:\n\n   a. for the avoidance of doubt, Section 2(a)(1) grants You the right to extract, reuse, reproduce, and Share all or a substantial portion of the contents of the database;\n\n   b. if You include all or a substantial portion of the database contents in a database in which You have Sui Generis Database Rights, then the database in which You have Sui Generis Database Rights (but not its individual contents) is Adapted Material, including for purposes of Section 3(b); and\n\n   c. You must comply with the conditions in Section 3(a) if You Share all or a substantial portion of the contents of the database.\n\n   For the avoidance of doubt, this Section 4 supplements and does not replace Your obligations under this Public License where the Licensed Rights include other Copyright and Similar Rights.\n\nSection 5 – Disclaimer of Warranties and Limitation of Liability.\n\n   a. Unless otherwise separately undertaken by the Licensor, to the extent possible, the Licensor offers the Licensed Material as-is and as-available, and makes no representations or warranties of any kind concerning the Licensed Material, whether express, implied, statutory, or other. This includes, without limitation, warranties of title, merchantability, fitness for a particular purpose, non-infringement, absence of latent or other defects, accuracy, or the presence or absence of errors, whether or not known or discoverable. Where disclaimers of warranties are not allowed in full or in part, this disclaimer may not apply to You.\n\n   b. To the extent possible, in no event will the Licensor be liable to You on any legal theory (including, without limitation, negligence) or otherwise for any direct, special, indirect, incidental, consequential, punitive, exemplary, or other losses, costs, expenses, or damages arising out of this Public License or use of the Licensed Material, even if the Licensor has been advised of the possibility of such losses, costs, expenses, or damages. Where a limitation of liability is not allowed in full or in part, this limitation may not apply to You.\n\n   c. The disclaimer of warranties and limitation of liability provided above shall be interpreted in a manner that, to the extent possible, most closely approximates an absolute disclaimer and waiver of all liability.\n\nSection 6 – Term and Termination.\n\n   a. This Public License applies for the term of the Copyright and Similar Rights licensed here. However, if You fail to comply with this Public License, then Your rights under this Public License terminate automatically.\n\n   b. Where Your right to use the Licensed Material has terminated under Section 6(a), it reinstates:\n\n      1. automatically as of the date the violation is cured, provided it is cured within 30 days of Your discovery of the violation; or\n\n      2. upon express reinstatement by the Licensor.\n\n   c. For the avoidance of doubt, this Section 6(b) does not affect any right the Licensor may have to seek remedies for Your violations of this Public License.\n\n   d. For the avoidance of doubt, the Licensor may also offer the Licensed Material under separate terms or conditions or stop distributing the Licensed Material at any time; however, doing so will not terminate this Public License.\n\n   e. Sections 1, 5, 6, 7, and 8 survive termination of this Public License.\n\nSection 7 – Other Terms and Conditions.\n\n   a. The Licensor shall not be bound by any additional or different terms or conditions communicated by You unless expressly agreed.\n\n   b. Any arrangements, understandings, or agreements regarding the Licensed Material not stated herein are separate from and independent of the terms and conditions of this Public License.\n\nSection 8 – Interpretation.\n\n   a. For the avoidance of doubt, this Public License does not, and shall not be interpreted to, reduce, limit, restrict, or impose conditions on any use of the Licensed Material that could lawfully be made without permission under this Public License.\n\n   b. To the extent possible, if any provision of this Public License is deemed unenforceable, it shall be automatically reformed to the minimum extent necessary to make it enforceable. If the provision cannot be reformed, it shall be severed from this Public License without affecting the enforceability of the remaining terms and conditions.\n\n   c. No term or condition of this Public License will be waived and no failure to comply consented to unless expressly agreed to by the Licensor.\n\n   d. Nothing in this Public License constitutes or may be interpreted as a limitation upon, or waiver of, any privileges and immunities that apply to the Licensor or You, including from the legal processes of any jurisdiction or authority.\n\nCreative Commons is not a party to its public licenses. Notwithstanding, Creative Commons may elect to apply one of its public licenses to material it publishes and in those instances will be considered the \"Licensor.\" The text of the Creative Commons public licenses is dedicated to the public domain under the CC0 Public Domain Dedication. Except for the limited purpose of indicating that material is shared under a Creative Commons public license or as otherwise permitted by the Creative Commons policies published at creativecommons.org/policies, Creative Commons does not authorize the use of the trademark \"Creative Commons\" or any other trademark or logo of Creative Commons without its prior written consent including, without limitation, in connection with any unauthorized modifications to any of its public licenses or any other arrangements, understandings, or agreements concerning use of licensed material. For the avoidance of doubt, this paragraph does not form part of the public licenses.\n\nCreative Commons may be contacted at creativecommons.org."],"licenseIds":["CC-BY-SA-4.0"],"keywords":["c by sa","are attribution and","attribution and sharealike","license k share","k share means","by them l","them l sui","l sui generis","the world m","world m you","m you means","a by sa","license c by sa","c by sa compatible","license are attribution and","are attribution and sharealike","attribution and sharealike h","public license k share","license k share means","k share means to","chosen by them l","by them l sui","them l sui generis","l sui generis database","in the world m","the world m you","world m you means","m you means the","or a by sa","a by sa compatible","licensees creative commons attribution sharealike","this creative commons attribution sharealike","public license c by sa","license c by sa compatible","c by sa compatible license","by sa compatible license means","public license are attribution and","license are attribution and sharealike","are attribution and sharealike h","attribution and sharealike h licensed","this public license k share","public license k share means","license k share means to","k share means to provide","individually chosen by them l","chosen by them l sui","by them l sui generis","them l sui generis database","l sui generis database rights","anywhere in the world m","in the world m you","the world m you means","world m you means the","m you means the individual","later or a by sa","or a by sa compatible","a by sa compatible license","by sa compatible license 2"]},{"licenseTexts":["The person or persons who have associated work with this document (the \"Dedicator\" or \"Certifier\") hereby either (a) certifies that, to the best of his knowledge, the work of authorship identified is in the public domain of the country from which the work is published, or (b) hereby dedicates whatever copyright the dedicators holds in the work of authorship identified below (the \"Work\") to the public domain. A certifier, moreover, dedicates any copyright interest he may have in the associated work, and for these purposes, is described as a \"dedicator\" below.\n\nA certifier has taken reasonable steps to verify the copyright status of this work. Certifier recognizes that his good faith efforts may not shield him from liability if in fact the work certified is not in the public domain.\n\nDedicator makes this dedication for the benefit of the public at large and to the detriment of the Dedicator's heirs and successors. Dedicator intends this dedication to be an overt act of relinquishment in perpetuity of all present and future rights under copyright law, whether vested or contingent, in the Work. Dedicator understands that such relinquishment of all rights includes the relinquishment of all rights to enforce (by lawsuit or otherwise) those copyrights in the Work.\n\nDedicator recognizes that, once placed in the public domain, the Work may be freely reproduced, distributed, transmitted, used, modified, built upon, or otherwise exploited by anyone for any purpose, commercial or non-commercial, and in any way, including by methods that have not yet been invented or conceived."],"licenseIds":["CC-PDDC"],"keywords":["who have associated","have associated work","associated work with","with this document","document the dedicator","the dedicator or","dedicator or certifier","or certifier hereby","certifier hereby either","hereby either a","either a certifies","a certifies that","certifies that to","best of his","of his knowledge","his knowledge the","knowledge the work","authorship identified is","identified is in","public domain of","domain of the","the country from","country from which","work is published","is published or","published or b","or b hereby","b hereby dedicates","hereby dedicates whatever","dedicates whatever copyright","whatever copyright the","copyright the dedicators","the dedicators holds","dedicators holds in","holds in the","authorship identified below","identified below the","below the work","public domain a","domain a certifier","a certifier moreover","certifier moreover dedicates","moreover dedicates any","dedicates any copyright","any copyright interest","copyright interest he","interest he may","he may have","in the associated","the associated work","associated work and","and for these","these purposes is","purposes is described","is described as","described as a","as a dedicator","a dedicator below","dedicator below a","below a certifier","a certifier has","certifier has taken","has taken reasonable","taken reasonable steps","steps to verify","to verify the","verify the copyright","the copyright status","copyright status of","this work certifier","work certifier recognizes","certifier recognizes that","recognizes that his","that his good","his good faith","good faith efforts","faith efforts may","efforts may not","may not shield","not shield him","shield him from","him from liability","from liability if","liability if in","if in fact","in fact the","fact the work","the work certified","work certified is","certified is not","is not in","not in the","public domain dedicator","domain dedicator makes","dedicator makes this","makes this dedication","detriment of the","the dedicator s","dedicator s heirs","and successors dedicator","successors dedicator intends","dedicator intends this","intends this dedication","future rights under","copyright law whether","law whether vested","whether vested or","or contingent in","contingent in the","work dedicator understands","dedicator understands that","understands that such","that such relinquishment","such relinquishment of","all rights includes","rights includes the","includes the relinquishment","the relinquishment of","rights to enforce","to enforce by","enforce by lawsuit","by lawsuit or","lawsuit or otherwise","or otherwise those","otherwise those copyrights","those copyrights in","work dedicator recognizes","dedicator recognizes that","recognizes that once","that once placed","once placed in","domain the work","freely reproduced distributed","reproduced distributed transmitted","distributed transmitted used","transmitted used modified","used modified built","modified built upon","built upon or","upon or otherwise","or otherwise exploited","otherwise exploited by","exploited by anyone","by anyone for","commercial and in","any way including","way including by","including by methods","by methods that","methods that have","that have not","have not yet","not yet been","yet been invented","been invented or","invented or conceived","the person or persons","or persons who have","persons who have associated","who have associated work","have associated work with","associated work with this","work with this document","with this document the","this document the dedicator","document the dedicator or","the dedicator or certifier","dedicator or certifier hereby","or certifier hereby either","certifier hereby either a","hereby either a certifies","either a certifies that","a certifies that to","certifies that to the","the best of his","best of his knowledge","of his knowledge the","his knowledge the work","knowledge the work of","of authorship identified is","authorship identified is in","identified is in the","is in the public","the public domain of","public domain of the","domain of the country","of the country from","the country from which","country from which the","from which the work","the work is published","work is published or","is published or b","published or b hereby","or b hereby dedicates","b hereby dedicates whatever","hereby dedicates whatever copyright","dedicates whatever copyright the","whatever copyright the dedicators","copyright the dedicators holds"]},{"licenseTexts":["Creative Commons Legal Code\n\nCC0 1.0 Universal CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS INFORMATION ON AN \"AS-IS\" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED HEREUNDER.\n\nStatement of Purpose\n\nThe laws of most jurisdictions throughout the world automatically confer exclusive Copyright and Related Rights (defined below) upon the creator and subsequent owner(s) (each and all, an \"owner\") of an original work of authorship and/or a database (each, a \"Work\").\n\nCertain owners wish to permanently relinquish those rights to a Work for the purpose of contributing to a commons of creative, cultural and scientific works (\"Commons\") that the public can reliably and without fear of later claims of infringement build upon, modify, incorporate in other works, reuse and redistribute as freely as possible in any form whatsoever and for any purposes, including without limitation commercial purposes. These owners may contribute to the Commons to promote the ideal of a free culture and the further production of creative, cultural and scientific works, or to gain reputation or greater distribution for their Work in part through the use and efforts of others.\n\nFor these and/or other purposes and motivations, and without any expectation of additional consideration or compensation, the person associating CC0 with a Work (the \"Affirmer\"), to the extent that he or she is an owner of Copyright and Related Rights in the Work, voluntarily elects to apply CC0 to the Work and publicly distribute the Work under its terms, with knowledge of his or her Copyright and Related Rights in the Work and the meaning and intended legal effect of CC0 on those rights.\n\n   1. Copyright and Related Rights. A Work made available under CC0 may be protected by copyright and related or neighboring rights (\"Copyright and Related Rights\"). Copyright and Related Rights include, but are not limited to, the following:\n\n      i. the right to reproduce, adapt, distribute, perform, display, communicate, and translate a Work;\n\n      ii. moral rights retained by the original author(s) and/or performer(s);\n\n      iii. publicity and privacy rights pertaining to a person's image or likeness depicted in a Work;\n\n      iv. rights protecting against unfair competition in regards to a Work, subject to the limitations in paragraph 4(a), below;\n\n      v. rights protecting the extraction, dissemination, use and reuse of data in a Work;\n\n      vi. database rights (such as those arising under Directive 96/9/EC of the European Parliament and of the Council of 11 March 1996 on the legal protection of databases, and under any national implementation thereof, including any amended or successor version of such directive); and\n\n      vii. other similar, equivalent or corresponding rights throughout the world based on applicable law or treaty, and any national implementations thereof.\n\n   2. Waiver. To the greatest extent permitted by, but not in contravention of, applicable law, Affirmer hereby overtly, fully, permanently, irrevocably and unconditionally waives, abandons, and surrenders all of Affirmer's Copyright and Related Rights and associated claims and causes of action, whether now known or unknown (including existing as well as future claims and causes of action), in the Work (i) in all territories worldwide, (ii) for the maximum duration provided by applicable law or treaty (including future time extensions), (iii) in any current or future medium and for any number of copies, and (iv) for any purpose whatsoever, including without limitation commercial, advertising or promotional purposes (the \"Waiver\"). Affirmer makes the Waiver for the benefit of each member of the public at large and to the detriment of Affirmer's heirs and successors, fully intending that such Waiver shall not be subject to revocation, rescission, cancellation, termination, or any other legal or equitable action to disrupt the quiet enjoyment of the Work by the public as contemplated by Affirmer's express Statement of Purpose.\n\n   3. Public License Fallback. Should any part of the Waiver for any reason be judged legally invalid or ineffective under applicable law, then the Waiver shall be preserved to the maximum extent permitted taking into account Affirmer's express Statement of Purpose. In addition, to the extent the Waiver is so judged Affirmer hereby grants to each affected person a royalty-free, non transferable, non sublicensable, non exclusive, irrevocable and unconditional license to exercise Affirmer's Copyright and Related Rights in the Work (i) in all territories worldwide, (ii) for the maximum duration provided by applicable law or treaty (including future time extensions), (iii) in any current or future medium and for any number of copies, and (iv) for any purpose whatsoever, including without limitation commercial, advertising or promotional purposes (the \"License\"). The License shall be deemed effective as of the date CC0 was applied by Affirmer to the Work. Should any part of the License for any reason be judged legally invalid or ineffective under applicable law, such partial invalidity or ineffectiveness shall not invalidate the remainder of the License, and in such case Affirmer hereby affirms that he or she will not (i) exercise any of his or her remaining Copyright and Related Rights in the Work or (ii) assert any associated claims and causes of action with respect to the Work, in either case contrary to Affirmer's express Statement of Purpose.\n\n   4. Limitations and Disclaimers.\n\n      a. No trademark or patent rights held by Affirmer are waived, abandoned, surrendered, licensed or otherwise affected by this document.\n\n      b. Affirmer offers the Work as-is and makes no representations or warranties of any kind concerning the Work, express, implied, statutory or otherwise, including without limitation warranties of title, merchantability, fitness for a particular purpose, non infringement, or the absence of latent or other defects, accuracy, or the present or absence of errors, whether or not discoverable, all to the greatest extent permissible under applicable law.\n\n      c. Affirmer disclaims responsibility for clearing rights of other persons that may apply to the Work or any use thereof, including without limitation any person's Copyright and Related Rights in the Work. Further, Affirmer disclaims responsibility for obtaining any necessary consents, permissions or other rights required for any use of the Work.\n\n      d. Affirmer understands and acknowledges that Creative Commons is not a party to this document and has no duty or obligation with respect to this CC0 or use of the Work. "],"licenseIds":["CC0-1.0"],"keywords":["creative commons legal","commons legal code","legal code cc0","code cc0 1","cc0 1 0","1 0 universal","0 universal creative","universal creative commons","regarding the use","provided hereunder and","hereunder and disclaims","provided hereunder statement","hereunder statement of","of purpose the","purpose the laws","laws of most","of most jurisdictions","most jurisdictions throughout","jurisdictions throughout the","the world automatically","world automatically confer","automatically confer exclusive","confer exclusive copyright","exclusive copyright and","related rights defined","defined below upon","below upon the","upon the creator","the creator and","creator and subsequent","and subsequent owner","subsequent owner s","owner s each","s each and","each and all","and all an","all an owner","owner of an","of an original","authorship and or","or a database","a database each","database each a","each a work","a work certain","work certain owners","certain owners wish","owners wish to","wish to permanently","to permanently relinquish","permanently relinquish those","relinquish those rights","those rights to","purpose of contributing","of contributing to","contributing to a","to a commons","a commons of","commons of creative","scientific works commons","works commons that","commons that the","public can reliably","can reliably and","reliably and without","and without fear","without fear of","fear of later","of later claims","later claims of","of infringement build","infringement build upon","build upon modify","upon modify incorporate","modify incorporate in","incorporate in other","in other works","other works reuse","works reuse and","reuse and redistribute","and redistribute as","redistribute as freely","as freely as","freely as possible","as possible in","possible in any","form whatsoever and","whatsoever and for","any purposes including","purposes including without","limitation commercial purposes","commercial purposes these","purposes these owners","these owners may","owners may contribute","may contribute to","contribute to the","to the commons","the commons to","commons to promote","promote the ideal","the ideal of","ideal of a","a free culture","free culture and","culture and the","and the further","the further production","further production of","production of creative","scientific works or","works or to","or to gain","to gain reputation","gain reputation or","reputation or greater","or greater distribution","greater distribution for","distribution for their","their work in","work in part","in part through","part through the","use and efforts","and efforts of","efforts of others","others for these","for these and","these and or","or other purposes","other purposes and","purposes and motivations","and motivations and","motivations and without","without any expectation","any expectation of","expectation of additional","of additional consideration","additional consideration or","consideration or compensation","or compensation the","compensation the person","the person associating","person associating cc0","associating cc0 with","cc0 with a","a work the","work the affirmer","the affirmer to","extent that he","she is an","is an owner","owner of copyright","the work voluntarily","work voluntarily elects","voluntarily elects to","elects to apply","to apply cc0","apply cc0 to","cc0 to the","work and publicly","and publicly distribute","publicly distribute the","work under its","terms with knowledge","with knowledge of","knowledge of his","or her copyright","her copyright and","and the meaning","the meaning and","meaning and intended","and intended legal","intended legal effect","effect of cc0","of cc0 on","cc0 on those","on those rights","those rights 1","rights 1 copyright","1 copyright and","related rights a","rights a work","a work made","work made available","available under cc0","under cc0 may","cc0 may be","may be protected","be protected by","and related or","related or neighboring","or neighboring rights","neighboring rights copyright","related rights copyright","related rights include","rights include but","following i the","i the right","to reproduce adapt"]},{"licenseTexts":["COMMON DEVELOPMENT AND DISTRIBUTION LICENSE (CDDL)\n\nVersion 1.0\n\n   1. Definitions.\n\n      1.1. \"Contributor\" means each individual or entity that creates or contributes to the creation of Modifications.\n\n      1.2. \"Contributor Version\" means the combination of the Original Software, prior Modifications used by a Contributor (if any), and the Modifications made by that particular Contributor.\n\n      1.3. \"Covered Software\" means (a) the Original Software, or (b) Modifications, or (c) the combination of files containing Original Software with files containing Modifications, in each case including portions thereof.\n\n      1.4. \"Executable\" means the Covered Software in any form other than Source Code.\n\n      1.5. \"Initial Developer\" means the individual or entity that first makes Original Software available under this License.\n\n      1.6. \"Larger Work\" means a work which combines Covered Software or portions thereof with code not governed by the terms of this License.\n\n      1.7. \"License\" means this document.\n\n      1.8. \"Licensable\" means having the right to grant, to the maximum extent possible, whether at the time of the initial grant or subsequently acquired, any and all of the rights conveyed herein.\n\n      1.9. \"Modifications\" means the Source Code and Executable form of any of the following:\n\n         A. Any file that results from an addition to, deletion from or modification of the contents of a file containing Original Software or previous Modifications;\n\n         B. Any new file that contains any part of the Original Software or previous Modification; or\n\n         C. Any new file that is contributed or otherwise made available under the terms of this License.\n\n      1.10. \"Original Software\" means the Source Code and Executable form of computer software code that is originally released under this License.\n\n      1.11. \"Patent Claims\" means any patent claim(s), now owned or hereafter acquired, including without limitation, method, process, and apparatus claims, in any patent Licensable by grantor.\n\n      1.12. \"Source Code\" means (a) the common form of computer software code in which modifications are made and (b) associated documentation included in or with such code.\n\n      1.13. \"You\" (or \"Your\") means an individual or a legal entity exercising rights under, and complying with all of the terms of, this License. For legal entities, \"You\" includes any entity which controls, is controlled by, or is under common control with You. For purposes of this definition, \"control\" means (a) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (b) ownership of more than fifty percent (50%) of the outstanding shares or beneficial ownership of such entity.\n\n   2. License Grants.\n\n      2.1. The Initial Developer Grant.\n\n      Conditioned upon Your compliance with Section 3.1 below and subject to third party intellectual property claims, the Initial Developer hereby grants You a world-wide, royalty-free, non-exclusive license:\n\n         (a) under intellectual property rights (other than patent or trademark) Licensable by Initial Developer, to use, reproduce, modify, display, perform, sublicense and distribute the Original Software (or portions thereof), with or without Modifications, and/or as part of a Larger Work; and\n\n         (b) under Patent Claims infringed by the making, using or selling of Original Software, to make, have made, use, practice, sell, and offer for sale, and/or otherwise dispose of the Original Software (or portions thereof).\n\n         (c) The licenses granted in Sections 2.1(a) and (b) are effective on the date Initial Developer first distributes or otherwise makes the Original Software available to a third party under the terms of this License.\n\n         (d) Notwithstanding Section 2.1(b) above, no patent license is granted: (1) for code that You delete from the Original Software, or (2) for infringements caused by: (i) the modification of the Original Software, or (ii) the combination of the Original Software with other software or devices.\n\n      2.2. Contributor Grant.\n\n      Conditioned upon Your compliance with Section 3.1 below and subject to third party intellectual property claims, each Contributor hereby grants You a world-wide, royalty-free, non-exclusive license:\n\n         (a) under intellectual property rights (other than patent or trademark) Licensable by Contributor to use, reproduce, modify, display, perform, sublicense and distribute the Modifications created by such Contributor (or portions thereof), either on an unmodified basis, with other Modifications, as Covered Software and/or as part of a Larger Work; and\n\n         (b) under Patent Claims infringed by the making, using, or selling of Modifications made by that Contributor either alone and/or in combination with its Contributor Version (or portions of such combination), to make, use, sell, offer for sale, have made, and/or otherwise dispose of: (1) Modifications made by that Contributor (or portions thereof); and (2) the combination of Modifications made by that Contributor with its Contributor Version (or portions of such combination).\n\n         (c) The licenses granted in Sections 2.2(a) and 2.2(b) are effective on the date Contributor first distributes or otherwise makes the Modifications available to a third party.\n\n         (d) Notwithstanding Section 2.2(b) above, no patent license is granted: (1) for any code that Contributor has deleted from the Contributor Version; (2) for infringements caused by: (i) third party modifications of Contributor Version, or (ii) the combination of Modifications made by that Contributor with other software (except as part of the Contributor Version) or other devices; or (3) under Patent Claims infringed by Covered Software in the absence of Modifications made by that Contributor.\n\n   3. Distribution Obligations.\n\n      3.1. Availability of Source Code.\n\n      Any Covered Software that You distribute or otherwise make available in Executable form must also be made available in Source Code form and that Source Code form must be distributed only under the terms of this License. You must include a copy of this License with every copy of the Source Code form of the Covered Software You distribute or otherwise make available. You must inform recipients of any such Covered Software in Executable form as to how they can obtain such Covered Software in Source Code form in a reasonable manner on or through a medium customarily used for software exchange.\n\n      3.2. Modifications.\n\n      The Modifications that You create or to which You contribute are governed by the terms of this License. You represent that You believe Your Modifications are Your original creation(s) and/or You have sufficient rights to grant the rights conveyed by this License.\n\n      3.3. Required Notices.\n\n      You must include a notice in each of Your Modifications that identifies You as the Contributor of the Modification. You may not remove or alter any copyright, patent or trademark notices contained within the Covered Software, or any notices of licensing or any descriptive text giving attribution to any Contributor or the Initial Developer.\n\n      3.4. Application of Additional Terms.\n\n      You may not offer or impose any terms on any Covered Software in Source Code form that alters or restricts the applicable version of this License or the recipients' rights hereunder. You may choose to offer, and to charge a fee for, warranty, support, indemnity or liability obligations to one or more recipients of Covered Software. However, you may do so only on Your own behalf, and not on behalf of the Initial Developer or any Contributor. You must make it absolutely clear that any such warranty, support, indemnity or liability obligation is offered by You alone, and You hereby agree to indemnify the Initial Developer and every Contributor for any liability incurred by the Initial Developer or such Contributor as a result of warranty, support, indemnity or liability terms You offer.\n\n      3.5. Distribution of Executable Versions.\n\n      You may distribute the Executable form of the Covered Software under the terms of this License or under the terms of a license of Your choice, which may contain terms different from this License, provided that You are in compliance with the terms of this License and that the license for the Executable form does not attempt to limit or alter the recipient's rights in the Source Code form from the rights set forth in this License. If You distribute the Covered Software in Executable form under a different license, You must make it absolutely clear that any terms which differ from this License are offered by You alone, not by the Initial Developer or Contributor. You hereby agree to indemnify the Initial Developer and every Contributor for any liability incurred by the Initial Developer or such Contributor as a result of any such terms You offer.\n\n      3.6. Larger Works.\n\n      You may create a Larger Work by combining Covered Software with other code not governed by the terms of this License and distribute the Larger Work as a single product. In such a case, You must make sure the requirements of this License are fulfilled for the Covered Software.\n\n   4. Versions of the License.\n\n      4.1. New Versions.\n\n      Sun Microsystems, Inc. is the initial license steward and may publish revised and/or new versions of this License from time to time. Each version will be given a distinguishing version number. Except as provided in Section 4.3, no one other than the license steward has the right to modify this License.\n\n      4.2. Effect of New Versions.\n\n      You may always continue to use, distribute or otherwise make the Covered Software available under the terms of the version of the License under which You originally received the Covered Software. If the Initial Developer includes a notice in the Original Software prohibiting it from being distributed or otherwise made available under any subsequent version of the License, You must distribute and make the Covered Software available under the terms of the version of the License under which You originally received the Covered Software. Otherwise, You may also choose to use, distribute or otherwise make the Covered Software available under the terms of any subsequent version of the License published by the license steward.\n\n      4.3. Modified Versions.\n\n      When You are an Initial Developer and You want to create a new license for Your Original Software, You may create and use a modified version of this License if You: (a) rename the license and remove any references to the name of the license steward (except to note that the license differs from this License); and (b) otherwise make it clear that the license contains terms which differ from this License.\n\n   5. DISCLAIMER OF WARRANTY.\n\n   COVERED SOFTWARE IS PROVIDED UNDER THIS LICENSE ON AN \"AS IS\" BASIS, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES THAT THE COVERED SOFTWARE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED SOFTWARE IS WITH YOU. SHOULD ANY COVERED SOFTWARE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. NO USE OF ANY COVERED SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER.\n\n   6. TERMINATION.\n\n      6.1. This License and the rights granted hereunder will terminate automatically if You fail to comply with terms herein and fail to cure such breach within 30 days of becoming aware of the breach. Provisions which, by their nature, must remain in effect beyond the termination of this License shall survive.\n\n      6.2. If You assert a patent infringement claim (excluding declaratory judgment actions) against Initial Developer or a Contributor (the Initial Developer or Contributor against whom You assert such claim is referred to as \"Participant\") alleging that the Participant Software (meaning the Contributor Version where the Participant is a Contributor or the Original Software where the Participant is the Initial Developer) directly or indirectly infringes any patent, then any and all rights granted directly or indirectly to You by such Participant, the Initial Developer (if the Initial Developer is not the Participant) and all Contributors under Sections 2.1 and/or 2.2 of this License shall, upon 60 days notice from Participant terminate prospectively and automatically at the expiration of such 60 day notice period, unless if within such 60 day period You withdraw Your claim with respect to the Participant Software against such Participant either unilaterally or pursuant to a written agreement with Participant.\n\n      6.3. In the event of termination under Sections 6.1 or 6.2 above, all end user licenses that have been validly granted by You or any distributor hereunder prior to termination (excluding licenses granted to You by any distributor) shall survive termination.\n\n   7. LIMITATION OF LIABILITY.\n\n   UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER TORT (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL YOU, THE INITIAL DEVELOPER, ANY OTHER CONTRIBUTOR, OR ANY DISTRIBUTOR OF COVERED SOFTWARE, OR ANY SUPPLIER OF ANY OF SUCH PARTIES, BE LIABLE TO ANY PERSON FOR ANY INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOST PROFITS, LOSS OF GOODWILL, WORK STOPPAGE, COMPUTER FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER COMMERCIAL DAMAGES OR LOSSES, EVEN IF SUCH PARTY SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF LIABILITY SHALL NOT APPLY TO LIABILITY FOR DEATH OR PERSONAL INJURY RESULTING FROM SUCH PARTY'S NEGLIGENCE TO THE EXTENT APPLICABLE LAW PROHIBITS SUCH LIMITATION. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OR LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THIS EXCLUSION AND LIMITATION MAY NOT APPLY TO YOU.\n\n   8. U.S. GOVERNMENT END USERS.\n\n   The Covered Software is a \"commercial item,\" as that term is defined in 48 C.F.R. 2.101 (Oct. 1995), consisting of \"commercial computer software\" (as that term is defined at 48 C.F.R. § 252.227-7014(a)(1)) and \"commercial computer software documentation\" as such terms are used in 48 C.F.R. 12.212 (Sept. 1995). Consistent with 48 C.F.R. 12.212 and 48 C.F.R. 227.7202-1 through 227.7202-4 (June 1995), all U.S. Government End Users acquire Covered Software with only those rights set forth herein. This U.S. Government Rights clause is in lieu of, and supersedes, any other FAR, DFAR, or other clause or provision that addresses Government rights in computer software under this License.\n\n   9. MISCELLANEOUS.\n\n   This License represents the complete agreement concerning subject matter hereof. If any provision of this License is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable. This License shall be governed by the law of the jurisdiction specified in a notice contained within the Original Software (except to the extent applicable law, if any, provides otherwise), excluding such jurisdiction's conflict-of-law provisions. Any litigation relating to this License shall be subject to the jurisdiction of the courts located in the jurisdiction and venue specified in a notice contained within the Original Software, with the losing party responsible for costs, including, without limitation, court costs and reasonable attorneys' fees and expenses. The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded. Any law or regulation which provides that the language of a contract shall be construed against the drafter shall not apply to this License. You agree that You alone are responsible for compliance with the United States export administration regulations (and the export control laws and regulation of any other countries) when You use, distribute or otherwise make available any Covered Software.\n\n   10. RESPONSIBILITY FOR CLAIMS.\n\n   As between Initial Developer and the Contributors, each party is responsible for claims and damages arising, directly or indirectly, out of its utilization of rights under this License and You agree to work with Initial Developer and Contributors to distribute such responsibility on an equitable basis. Nothing herein is intended or shall be deemed to constitute any admission of liability."],"licenseIds":["CDDL-1.0"],"keywords":["microsystems inc is","inc is the","6 3 in","cddl version 1 0","sun microsystems inc is","microsystems inc is the","inc is the initial","participant 6 3 in","6 3 in the","license cddl version 1 0","cddl version 1 0 1","4 1 new versions sun","versions sun microsystems inc is","sun microsystems inc is the","microsystems inc is the initial","inc is the initial license","with participant 6 3 in","participant 6 3 in the","6 3 in the event"]},{"licenseTexts":["COMMON DEVELOPMENT AND DISTRIBUTION LICENSE (CDDL)\n\nVersion 1.1\n\n   1. Definitions.\n\n      1.1. \"Contributor\" means each individual or entity that creates or contributes to the creation of Modifications.\n\n      1.2. \"Contributor Version\" means the combination of the Original Software, prior Modifications used by a Contributor (if any), and the Modifications made by that particular Contributor.\n\n      1.3. \"Covered Software\" means (a) the Original Software, or (b) Modifications, or (c) the combination of files containing Original Software with files containing Modifications, in each case including portions thereof.\n\n      1.4. \"Executable\" means the Covered Software in any form other than Source Code.\n\n      1.5. \"Initial Developer\" means the individual or entity that first makes Original Software available under this License.\n\n      1.6. \"Larger Work\" means a work which combines Covered Software or portions thereof with code not governed by the terms of this License.\n\n      1.7. \"License\" means this document.\n\n      1.8. \"Licensable\" means having the right to grant, to the maximum extent possible, whether at the time of the initial grant or subsequently acquired, any and all of the rights conveyed herein.\n\n      1.9. \"Modifications\" means the Source Code and Executable form of any of the following:\n\n         A. Any file that results from an addition to, deletion from or modification of the contents of a file containing Original Software or previous Modifications;\n\n         B. Any new file that contains any part of the Original Software or previous Modification; or\n\n         C. Any new file that is contributed or otherwise made available under the terms of this License.\n\n      1.10. \"Original Software\" means the Source Code and Executable form of computer software code that is originally released under this License.\n\n      1.11. \"Patent Claims\" means any patent claim(s), now owned or hereafter acquired, including without limitation, method, process, and apparatus claims, in any patent Licensable by grantor.\n\n      1.12. \"Source Code\" means (a) the common form of computer software code in which modifications are made and (b) associated documentation included in or with such code.\n\n      1.13. \"You\" (or \"Your\") means an individual or a legal entity exercising rights under, and complying with all of the terms of, this License. For legal entities, \"You\" includes any entity which controls, is controlled by, or is under common control with You. For purposes of this definition, \"control\" means (a) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (b) ownership of more than fifty percent (50%) of the outstanding shares or beneficial ownership of such entity.\n\n   2. License Grants.\n\n      2.1. The Initial Developer Grant.\n\n      Conditioned upon Your compliance with Section 3.1 below and subject to third party intellectual property claims, the Initial Developer hereby grants You a world-wide, royalty-free, non-exclusive license:\n\n         (a) under intellectual property rights (other than patent or trademark) Licensable by Initial Developer, to use, reproduce, modify, display, perform, sublicense and distribute the Original Software (or portions thereof), with or without Modifications, and/or as part of a Larger Work; and\n\n         (b) under Patent Claims infringed by the making, using or selling of Original Software, to make, have made, use, practice, sell, and offer for sale, and/or otherwise dispose of the Original Software (or portions thereof).\n\n         (c) The licenses granted in Sections 2.1(a) and (b) are effective on the date Initial Developer first distributes or otherwise makes the Original Software available to a third party under the terms of this License.\n\n         (d) Notwithstanding Section 2.1(b) above, no patent license is granted: (1) for code that You delete from the Original Software, or (2) for infringements caused by: (i) the modification of the Original Software, or (ii) the combination of the Original Software with other software or devices.\n\n      2.2. Contributor Grant.\n\n      Conditioned upon Your compliance with Section 3.1 below and subject to third party intellectual property claims, each Contributor hereby grants You a world-wide, royalty-free, non-exclusive license:\n\n         (a) under intellectual property rights (other than patent or trademark) Licensable by Contributor to use, reproduce, modify, display, perform, sublicense and distribute the Modifications created by such Contributor (or portions thereof), either on an unmodified basis, with other Modifications, as Covered Software and/or as part of a Larger Work; and\n\n         (b) under Patent Claims infringed by the making, using, or selling of Modifications made by that Contributor either alone and/or in combination with its Contributor Version (or portions of such combination), to make, use, sell, offer for sale, have made, and/or otherwise dispose of: (1) Modifications made by that Contributor (or portions thereof); and (2) the combination of Modifications made by that Contributor with its Contributor Version (or portions of such combination).\n\n         (c) The licenses granted in Sections 2.2(a) and 2.2(b) are effective on the date Contributor first distributes or otherwise makes the Modifications available to a third party.\n\n         (d) Notwithstanding Section 2.2(b) above, no patent license is granted: (1) for any code that Contributor has deleted from the Contributor Version; (2) for infringements caused by: (i) third party modifications of Contributor Version, or (ii) the combination of Modifications made by that Contributor with other software (except as part of the Contributor Version) or other devices; or (3) under Patent Claims infringed by Covered Software in the absence of Modifications made by that Contributor.\n\n   3. Distribution Obligations.\n\n      3.1. Availability of Source Code.\n\n      Any Covered Software that You distribute or otherwise make available in Executable form must also be made available in Source Code form and that Source Code form must be distributed only under the terms of this License. You must include a copy of this License with every copy of the Source Code form of the Covered Software You distribute or otherwise make available. You must inform recipients of any such Covered Software in Executable form as to how they can obtain such Covered Software in Source Code form in a reasonable manner on or through a medium customarily used for software exchange.\n\n      3.2. Modifications.\n\n      The Modifications that You create or to which You contribute are governed by the terms of this License. You represent that You believe Your Modifications are Your original creation(s) and/or You have sufficient rights to grant the rights conveyed by this License.\n\n      3.3. Required Notices.\n\n      You must include a notice in each of Your Modifications that identifies You as the Contributor of the Modification. You may not remove or alter any copyright, patent or trademark notices contained within the Covered Software, or any notices of licensing or any descriptive text giving attribution to any Contributor or the Initial Developer.\n\n      3.4. Application of Additional Terms.\n\n      You may not offer or impose any terms on any Covered Software in Source Code form that alters or restricts the applicable version of this License or the recipients' rights hereunder. You may choose to offer, and to charge a fee for, warranty, support, indemnity or liability obligations to one or more recipients of Covered Software. However, you may do so only on Your own behalf, and not on behalf of the Initial Developer or any Contributor. You must make it absolutely clear that any such warranty, support, indemnity or liability obligation is offered by You alone, and You hereby agree to indemnify the Initial Developer and every Contributor for any liability incurred by the Initial Developer or such Contributor as a result of warranty, support, indemnity or liability terms You offer.\n\n      3.5. Distribution of Executable Versions.\n\n      You may distribute the Executable form of the Covered Software under the terms of this License or under the terms of a license of Your choice, which may contain terms different from this License, provided that You are in compliance with the terms of this License and that the license for the Executable form does not attempt to limit or alter the recipient's rights in the Source Code form from the rights set forth in this License. If You distribute the Covered Software in Executable form under a different license, You must make it absolutely clear that any terms which differ from this License are offered by You alone, not by the Initial Developer or Contributor. You hereby agree to indemnify the Initial Developer and every Contributor for any liability incurred by the Initial Developer or such Contributor as a result of any such terms You offer.\n\n      3.6. Larger Works.\n\n      You may create a Larger Work by combining Covered Software with other code not governed by the terms of this License and distribute the Larger Work as a single product. In such a case, You must make sure the requirements of this License are fulfilled for the Covered Software.\n\n   4. Versions of the License.\n\n      4.1. New Versions.\n\n      Oracle is the initial license steward and may publish revised and/or new versions of this License from time to time. Each version will be given a distinguishing version number. Except as provided in Section 4.3, no one other than the license steward has the right to modify this License.\n\n      4.2. Effect of New Versions.\n\n      You may always continue to use, distribute or otherwise make the Covered Software available under the terms of the version of the License under which You originally received the Covered Software. If the Initial Developer includes a notice in the Original Software prohibiting it from being distributed or otherwise made available under any subsequent version of the License, You must distribute and make the Covered Software available under the terms of the version of the License under which You originally received the Covered Software. Otherwise, You may also choose to use, distribute or otherwise make the Covered Software available under the terms of any subsequent version of the License published by the license steward.\n\n      4.3. Modified Versions.\n\n      When You are an Initial Developer and You want to create a new license for Your Original Software, You may create and use a modified version of this License if You: (a) rename the license and remove any references to the name of the license steward (except to note that the license differs from this License); and (b) otherwise make it clear that the license contains terms which differ from this License.\n\n   5. DISCLAIMER OF WARRANTY.\n\n   COVERED SOFTWARE IS PROVIDED UNDER THIS LICENSE ON AN \"AS IS\" BASIS, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES THAT THE COVERED SOFTWARE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED SOFTWARE IS WITH YOU. SHOULD ANY COVERED SOFTWARE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. NO USE OF ANY COVERED SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER.\n\n   6. TERMINATION.\n\n      6.1. This License and the rights granted hereunder will terminate automatically if You fail to comply with terms herein and fail to cure such breach within 30 days of becoming aware of the breach. Provisions which, by their nature, must remain in effect beyond the termination of this License shall survive.\n\n      6.2. If You assert a patent infringement claim (excluding declaratory judgment actions) against Initial Developer or a Contributor (the Initial Developer or Contributor against whom You assert such claim is referred to as \"Participant\") alleging that the Participant Software (meaning the Contributor Version where the Participant is a Contributor or the Original Software where the Participant is the Initial Developer) directly or indirectly infringes any patent, then any and all rights granted directly or indirectly to You by such Participant, the Initial Developer (if the Initial Developer is not the Participant) and all Contributors under Sections 2.1 and/or 2.2 of this License shall, upon 60 days notice from Participant terminate prospectively and automatically at the expiration of such 60 day notice period, unless if within such 60 day period You withdraw Your claim with respect to the Participant Software against such Participant either unilaterally or pursuant to a written agreement with Participant.\n\n      6.3. If You assert a patent infringement claim against Participant alleging that the Participant Software directly or indirectly infringes any patent where such claim is resolved (such as by license or settlement) prior to the initiation of patent infringement litigation, then the reasonable value of the licenses granted by such Participant under Sections 2.1 or 2.2 shall be taken into account in determining the amount or value of any payment or license.\n\n      6.4. In the event of termination under Sections 6.1 or 6.2 above, all end user licenses that have been validly granted by You or any distributor hereunder prior to termination (excluding licenses granted to You by any distributor) shall survive termination.\n\n   7. LIMITATION OF LIABILITY.\n\n   UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER TORT (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL YOU, THE INITIAL DEVELOPER, ANY OTHER CONTRIBUTOR, OR ANY DISTRIBUTOR OF COVERED SOFTWARE, OR ANY SUPPLIER OF ANY OF SUCH PARTIES, BE LIABLE TO ANY PERSON FOR ANY INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, COMPUTER FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER COMMERCIAL DAMAGES OR LOSSES, EVEN IF SUCH PARTY SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF LIABILITY SHALL NOT APPLY TO LIABILITY FOR DEATH OR PERSONAL INJURY RESULTING FROM SUCH PARTY'S NEGLIGENCE TO THE EXTENT APPLICABLE LAW PROHIBITS SUCH LIMITATION. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OR LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THIS EXCLUSION AND LIMITATION MAY NOT APPLY TO YOU.\n\n   8. U.S. GOVERNMENT END USERS.\n\n   The Covered Software is a \"commercial item,\" as that term is defined in 48 C.F.R. 2.101 (Oct. 1995), consisting of \"commercial computer software\" (as that term is defined at 48 C.F.R. § 252.227-7014(a)(1)) and \"commercial computer software documentation\" as such terms are used in 48 C.F.R. 12.212 (Sept. 1995). Consistent with 48 C.F.R. 12.212 and 48 C.F.R. 227.7202-1 through 227.7202-4 (June 1995), all U.S. Government End Users acquire Covered Software with only those rights set forth herein. This U.S. Government Rights clause is in lieu of, and supersedes, any other FAR, DFAR, or other clause or provision that addresses Government rights in computer software under this License.\n\n   9. MISCELLANEOUS.\n\n   This License represents the complete agreement concerning subject matter hereof. If any provision of this License is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable. This License shall be governed by the law of the jurisdiction specified in a notice contained within the Original Software (except to the extent applicable law, if any, provides otherwise), excluding such jurisdiction's conflict-of-law provisions. Any litigation relating to this License shall be subject to the jurisdiction of the courts located in the jurisdiction and venue specified in a notice contained within the Original Software, with the losing party responsible for costs, including, without limitation, court costs and reasonable attorneys' fees and expenses. The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded. Any law or regulation which provides that the language of a contract shall be construed against the drafter shall not apply to this License. You agree that You alone are responsible for compliance with the United States export administration regulations (and the export control laws and regulation of any other countries) when You use, distribute or otherwise make available any Covered Software.\n\n   10. RESPONSIBILITY FOR CLAIMS.\n\n   As between Initial Developer and the Contributors, each party is responsible for claims and damages arising, directly or indirectly, out of its utilization of rights under this License and You agree to work with Initial Developer and Contributors to distribute such responsibility on an equitable basis. Nothing herein is intended or shall be deemed to constitute any admission of liability.\n\nNOTICE PURSUANT TO SECTION 9 OF THE COMMON DEVELOPMENT AND DISTRIBUTION LICENSE (CDDL)\n\nThe code released under the CDDL shall be governed by the laws of the State of California (excluding conflict-of-law provisions). Any litigation relating to this License shall be subject to the jurisdiction of the Federal Courts of the Northern District of California and the state courts of the State of California, with venue lying in Santa Clara County, California."],"licenseIds":["CDDL-1.1"],"keywords":["new versions oracle","versions oracle is","oracle is the","6 3 if","participant software directly","or license 6","of liability notice","liability notice pursuant","notice pursuant to","to section 9","section 9 of","9 of the","the common development","license cddl the","cddl the code","the code released","code released under","under the cddl","the cddl shall","cddl shall be","the state courts","cddl version 1 1","1 new versions oracle","new versions oracle is","versions oracle is the","oracle is the initial","participant 6 3 if","6 3 if you","the participant software directly","participant software directly or","payment or license 6","or license 6 4","license 6 4 in","admission of liability notice","of liability notice pursuant","liability notice pursuant to","notice pursuant to section","pursuant to section 9","to section 9 of","section 9 of the","9 of the common","of the common development","the common development and","distribution license cddl the","license cddl the code","cddl the code released","the code released under","code released under the","released under the cddl","under the cddl shall","the cddl shall be","cddl shall be governed","california and the state","and the state courts","the state courts of","state courts of the","license cddl version 1 1","cddl version 1 1 1","4 1 new versions oracle","1 new versions oracle is","new versions oracle is the","versions oracle is the initial","oracle is the initial license","with participant 6 3 if","participant 6 3 if you","6 3 if you assert","against participant alleging that the","that the participant software directly","the participant software directly or","participant software directly or indirectly","any payment or license 6","payment or license 6 4","or license 6 4 in","license 6 4 in the","any admission of liability notice","admission of liability notice pursuant","of liability notice pursuant to","liability notice pursuant to section","notice pursuant to section 9","pursuant to section 9 of","to section 9 of the","section 9 of the common","9 of the common development","of the common development and","the common development and distribution","and distribution license cddl the","distribution license cddl the code","license cddl the code released","cddl the code released under","the code released under the","code released under the cddl","released under the cddl shall","under the cddl shall be","the cddl shall be governed","cddl shall be governed by","district of california and the","of california and the state","california and the state courts","and the state courts of","the state courts of the","state courts of the state"]},{"licenseTexts":["Community Data License Agreement - Permissive - Version 1.0\n\nThis is the Community Data License Agreement - Permissive, Version 1.0 (\"Agreement\"). Data is provided to You under this Agreement by each of the Data Providers. Your exercise of any of the rights and permissions granted below constitutes Your acceptance and agreement to be bound by the terms and conditions of this Agreement.\n\nThe benefits that each Data Provider receives from making Data available and that You receive from Data or otherwise under these terms and conditions shall be deemed sufficient consideration for the formation of this Agreement. Accordingly, Data Provider(s) and You (the \"Parties\") agree as follows:\n\n   Section 1. Definitions\n\n      1.1 \"Add\" means to supplement Data with Your own or someone else's Data, resulting in Your \"Additions.\" Additions do not include Results.\n\n      1.2 \"Computational Use\" means Your analysis (through the use of computational devices or otherwise) or other interpretation of Data. By way of example and not limitation, \"Computational Use\" includes the application of any computational analytical technique, the purpose of which is the analysis of any Data in digital form to generate information about Data such as patterns, trends, correlations, inferences, insights and attributes.\n\n      1.3 \"Data\" means the information (including copyrightable information, such as images or text), collectively or individually, whether created or gathered by a Data Provider or an Entity acting on its behalf, to which rights are granted under this Agreement.\n\n      1.4 \"Data Provider\" means any Entity (including any employee or contractor of such Entity authorized to Publish Data on behalf of such Entity) that Publishes Data under this Agreement prior to Your Receiving it.\n\n      1.5 \"Enhanced Data\" means the subset of Data that You Publish and that is composed of (a) Your Additions and/or (b) Modifications to Data You have received under this Agreement.\n\n      1.6 \"Entity\" means any natural person or organization that exists under the laws of the jurisdiction in which it is organized, together with all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, \"control\" means (a) the power, directly or indirectly, to cause the direction or management of such entity, whether by contract or otherwise, (b) the ownership of more than fifty percent (50%) of the outstanding shares or securities, (c) the beneficial ownership of such entity or, (d) the ability to appoint, whether by agreement or right, the majority of directors of an Entity.\n\n      1.7 \"Modify\" means to delete, erase, correct or re-arrange Data, resulting in \"Modifications.\" Modifications do not include Results.\n\n      1.8 \"Publish\" means to make all or a subset of Data (including Your Enhanced Data) available in any manner which enables its Use, including by providing a copy on physical media or remote access. For any form of Entity, that is to make the Data available to any individual who is not employed by that Entity or engaged as a contractor or agent to perform work on that Entity's behalf. A \"Publication\" occurs each time You Publish Data.\n\n      1.9 \"Receive\" or \"Receives\" means to have been given access to Data, locally or remotely.\n\n      1.10 \"Results\" means the outcomes or outputs that You obtain from Your Computational Use of Data. Results shall not include more than a de minimis portion of the Data on which the Computational Use is based.\n\n      1.11 \"Sui Generis Database Rights\" means rights, other than copyright, resulting from Directive 96/9/EC of the European Parliament and of the Council of 11 March 1996 on the legal protection of databases, as amended and/or succeeded, as well as other equivalent rights anywhere in the world.\n\n      1.12 \"Use\" means using Data (including accessing, copying, studying, reviewing, adapting, analyzing, evaluating, or making Computational Use of it), either by machines or humans, or a combination of both.\n\n      1.13 \"You\" or \"Your\" means any Entity that Receives Data under this Agreement.\n\n   Section 2. Right and License to Use and to Publish\n\n      2.1 Subject to the conditions set forth in Section 3 of this Agreement, Data Provider(s) hereby grant(s) to You a worldwide, non-exclusive, irrevocable (except as provided in Section 5) right to: (a) Use Data; and (b) Publish Data.\n\n      2.2 To the extent that the Data or the coordination, selection or arrangement of Data is protected or protectable under copyright, Sui Generis Database Rights, or other law, Data Provider(s) further agree(s) that such Data or coordination, selection or arrangement is hereby licensed to You and to anyone else who Receives Data under this Agreement for Use and Publication, subject to the conditions set forth in Section 3 of this Agreement.\n\n      2.3 Except for these rights and licenses expressly granted, no other intellectual property rights are granted or should be implied.\n\n   Section 3. Conditions on Rights Granted\n\n      3.1 If You Publish Data You Receive or Enhanced Data:\n\n         (a) You may do so under a license of Your choice provided that You give anyone who Receives the Data from You the text of this Agreement, the name of this Agreement and/or a hyperlink or other method reasonably likely to provide a copy of the text of this Agreement; and\n\n         (b) You must cause any Data files containing Enhanced Data to carry prominent notices that You have changed those files; and\n\n         (c) If You Publish Data You Receive, You must preserve all credit or attribution to the Data Provider(s). Such retained credit or attribution includes any of the following to the extent they exist in Data as You have Received it: legal notices or metadata; identification of the Data Provider(s); or hyperlinks to Data to the extent it is practical to do so.\n\n      3.2 You may provide additional or different license terms and conditions for use, reproduction, or distribution of that Enhanced Data, or for any combination of Data and Enhanced Data as a whole, provided that Your Use and Publication of that combined Data otherwise complies with the conditions stated in this License.\n\n      3.3 You and each Data Provider agree that Enhanced Data shall not be considered a work of joint authorship by virtue of its relationship to Data licensed under this Agreement and shall not require either any obligation of accounting to or the consent of any Data Provider.\n\n      3.4 This Agreement imposes no obligations or restrictions on Your Use or Publication of Results.\n\n   Section 4. Data Provider(s)' Representations\n\n      4.1 Each Data Provider represents that the Data Provider has exercised reasonable care, to assure that: (a) the Data it Publishes was created or generated by it or was obtained from others with the right to Publish the Data under this Agreement; and (b) Publication of such Data does not violate any privacy or confidentiality obligation undertaken by the Data Provider.\n\n   Section 5. Termination\n\n      5.1 All of Your rights under this Agreement will terminate, and Your right to Receive, Use or Publish the Data will be revoked or modified if You materially fail to comply with the terms and conditions of this Agreement and You do not cure such failure in a reasonable period of time after becoming aware of such noncompliance. If Your rights under this Agreement terminate, You agree to cease Receipt, Use and Publication of Data. However, Your obligations and any rights and permissions granted by You under this Agreement relating to Data that You Published prior to such termination will continue and survive.\n\n      5.2 If You institute litigation against a Data Provider or anyone else who Receives the Data (including a cross-claim in a lawsuit) based on the Data, other than a claim asserting breach of this Agreement, then any rights previously granted to You to Receive, Use and Publish Data under this Agreement will terminate as of the date such litigation is filed.\n\n   Section 6. Disclaimer of Warranties and Limitation of Liability\n\n      6.1 EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE DATA (INCLUDING ENHANCED DATA) IS PROVIDED ON AN \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.\n\n      6.2 NEITHER YOU NOR ANY DATA PROVIDERS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE DATA OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\n   Section 7. Miscellaneous\n\n      7.1 You agree that it is solely Your responsibility to comply with all applicable laws with regard to Your Use or Publication of Data, including any applicable privacy, data protection, security and export laws. You agree to take reasonable steps to assist a Data Provider fulfilling responsibilities to comply with applicable laws with regard to Use or Publication of Data Received hereunder.\n\n      7.2 You and Data Provider(s), collectively and individually, waive and/or agree not to assert, to the extent permitted by law, any moral rights You or they hold in Data.\n\n      7.3 This Agreement confers no rights or remedies upon any person or entity other than the Parties and their respective heirs, executors, successors and assigns.\n\n      7.4 The Data Provider(s) reserve no right or expectation of privacy, data protection or confidentiality in any Data that they Publish under this Agreement. If You choose to Publish Data under this Agreement, You similarly do so with no reservation or expectation of any rights of privacy or confidentiality in that Data.\n\n      7.5 The Community Data License Agreement workgroup under The Linux Foundation is the steward of this Agreement (\"Steward\"). No one other than the Steward has the right to modify or publish new versions of this Agreement. Each version will be given a distinguishing version number. You may Use and Publish Data Received hereunder under the terms of the version of the Agreement under which You originally Received the Data, or under the terms of any subsequent version published by the Steward."],"licenseIds":["CDLA-Permissive-1.0"],"keywords":["1 7 modify","7 modify means","results 1 8","1 8 publish","8 publish means","data 1 9","1 9 receive","9 receive or","remotely 1 10","1 10 results","10 results means","based 1 11","1 11 sui","11 sui generis","world 1 12","1 12 use","12 use means","both 1 13","data a you","that you give","you give anyone","the data from","data from you","from you the","you the text","of that enhanced","for any combination","combination of data","data and enhanced","and enhanced data","enhanced data as","whole provided that","publication of that","of that combined","that combined data","combined data otherwise","data otherwise complies","3 you and","provider 3 4","3 4 this","entity 1 7 modify","1 7 modify means","7 modify means to","include results 1 8","results 1 8 publish","1 8 publish means","8 publish means to","publish data 1 9","data 1 9 receive","1 9 receive or","9 receive or receives","or remotely 1 10","remotely 1 10 results","1 10 results means","10 results means the","is based 1 11","based 1 11 sui","1 11 sui generis","11 sui generis database","the world 1 12","world 1 12 use","1 12 use means","12 use means using","of both 1 13","both 1 13 you","enhanced data a you","data a you may","a you may do","may do so under","provided that you give","that you give anyone","you give anyone who","give anyone who receives","receives the data from","the data from you","data from you the","from you the text","you the text of","agreement and b you","2 you may provide","you may provide additional","or distribution of that","distribution of that enhanced","of that enhanced data","that enhanced data or","enhanced data or for","data or for any","or for any combination","for any combination of","any combination of data","combination of data and","of data and enhanced","data and enhanced data","and enhanced data as","enhanced data as a","data as a whole","a whole provided that","whole provided that your","provided that your use","that your use and","your use and publication","and publication of that","publication of that combined","of that combined data","that combined data otherwise","combined data otherwise complies","data otherwise complies with","license 3 3 you","3 3 you and","3 you and each","data provider 3 4","provider 3 4 this","3 4 this agreement","4 this agreement imposes","permissive version 1 0 this","permissive version 1 0 agreement","an entity 1 7 modify","entity 1 7 modify means","1 7 modify means to","7 modify means to delete","not include results 1 8","include results 1 8 publish","results 1 8 publish means","1 8 publish means to","8 publish means to make","you publish data 1 9","publish data 1 9 receive","data 1 9 receive or","1 9 receive or receives","9 receive or receives means","locally or remotely 1 10","or remotely 1 10 results","remotely 1 10 results means","1 10 results means the","10 results means the outcomes","use is based 1 11","is based 1 11 sui","based 1 11 sui generis","1 11 sui generis database","11 sui generis database rights","in the world 1 12","the world 1 12 use","world 1 12 use means","1 12 use means using","12 use means using data","combination of both 1 13","of both 1 13 you","both 1 13 you or","or enhanced data a you","enhanced data a you may","data a you may do","a you may do so","you may do so under","may do so under a","so under a license of","choice provided that you give","provided that you give anyone","that you give anyone who","you give anyone who receives","give anyone who receives the","who receives the data from","receives the data from you","the data from you the","data from you the text","from you the text of","you the text of this","text of this agreement and","this agreement and b you","agreement and b you must","3 2 you may provide","2 you may provide additional","you may provide additional or","reproduction or distribution of that","or distribution of that enhanced","distribution of that enhanced data","of that enhanced data or","that enhanced data or for","enhanced data or for any","data or for any combination","or for any combination of","for any combination of data","any combination of data and","combination of data and enhanced","of data and enhanced data","data and enhanced data as","and enhanced data as a","enhanced data as a whole","data as a whole provided","as a whole provided that","a whole provided that your","whole provided that your use","provided that your use and","that your use and publication","your use and publication of","use and publication of that","and publication of that combined","publication of that combined data","of that combined data otherwise","that combined data otherwise complies","combined data otherwise complies with"]},{"licenseTexts":["Community Data License Agreement - Sharing - Version 1.0\n\nThis is the Community Data License Agreement - Sharing, Version 1.0 (\"Agreement\"). Data is provided to You under this Agreement by each of the Data Providers. Your exercise of any of the rights and permissions granted below constitutes Your acceptance and agreement to be bound by the terms and conditions of this Agreement.\n\nThe benefits that each Data Provider receives from making Data available and that You receive from Data or otherwise under these terms and conditions shall be deemed sufficient consideration for the formation of this Agreement. Accordingly, Data Provider(s) and You (the \"Parties\") agree as follows:\n\n   Section 1. Definitions\n\n      1.1 \"Add\" means to supplement Data with Your own or someone else's Data, resulting in Your \"Additions.\" Additions do not include Results.\n\n      1.2 \"Computational Use\" means Your analysis (through the use of computational devices or otherwise) or other interpretation of Data. By way of example and not limitation, \"Computational Use\" includes the application of any computational analytical technique, the purpose of which is the analysis of any Data in digital form to generate information about Data such as patterns, trends, correlations, inferences, insights and attributes.\n\n      1.3 \"Data\" means the information (including copyrightable information, such as images or text), collectively or individually, whether created or gathered by a Data Provider or an Entity acting on its behalf, to which rights are granted under this Agreement.\n\n      1.4 \"Data Provider\" means any Entity (including any employee or contractor of such Entity authorized to Publish Data on behalf of such Entity) that Publishes Data under this Agreement prior to Your Receiving it.\n\n      1.5 \"Enhanced Data\" means the subset of Data that You Publish and that is composed of (a) Your Additions and/or (b) Modifications to Data You have received under this Agreement.\n\n      1.6 \"Entity\" means any natural person or organization that exists under the laws of the jurisdiction in which it is organized, together with all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, \"control\" means (a) the power, directly or indirectly, to cause the direction or management of such entity, whether by contract or otherwise, (b) the ownership of more than fifty percent (50%) of the outstanding shares or securities, (c) the beneficial ownership of such entity or, (d) the ability to appoint, whether by agreement or right, the majority of directors of an Entity.\n\n      1.7 \"Ledger\" means a digital record of Data or grants of rights in Data governed by this Agreement, using any technology having functionality to record and store Data or grants, contributions, or licenses to Data governed by this Agreement.\n\n      1.8 \"Modify\" means to delete, erase, correct or re-arrange Data, resulting in \"Modifications.\" Modifications do not include Results.\n\n      1.9 \"Publish\" means to make all or a subset of Data (including Your Enhanced Data) available in any manner which enables its Use, including by providing a copy on physical media or remote access. For any form of Entity, that is to make the Data available to any individual who is not employed by that Entity or engaged as a contractor or agent to perform work on that Entity's behalf. A \"Publication\" occurs each time You Publish Data.\n\n      1.10 \"Receive\" or \"Receives\" means to have been given access to Data, locally or remotely.\n\n      1.11 \"Results\" means the outcomes or outputs that You obtain from Your Computational Use of Data. Results shall not include more than a de minimis portion of the Data on which the Computational Use is based.\n\n      1.12 \"Sui Generis Database Rights\" means rights, other than copyright, resulting from Directive 96/9/EC of the European Parliament and of the Council of 11 March 1996 on the legal protection of databases, as amended and/or succeeded, as well as other equivalent rights anywhere in the world.\n\n      1.13 \"Use\" means using Data (including accessing, copying, studying, reviewing, adapting, analyzing, evaluating, or making Computational Use of it), either by machines or humans, or a combination of both.\n\n      1.14 \"You\" or \"Your\" means any Entity that Receives Data under this Agreement.\n\n   Section 2. Right and License to Use and to Publish\n\n      2.1 Subject to the conditions set forth in Section 3 of this Agreement, Data Provider(s) hereby grant(s) to You a worldwide, non-exclusive, irrevocable (except as provided in Section 5) right to: (a) Use Data; and (b) Publish Data.\n\n      2.2 To the extent that the Data or the coordination, selection or arrangement of Data is protected or protectable under copyright, Sui Generis Database Rights, or other law, Data Provider(s) further agree(s) that such Data or coordination, selection or arrangement is hereby licensed to You and to anyone else who Receives Data under this Agreement for Use and Publication, subject to the conditions set forth in Section 3 of this Agreement.\n\n      2.3 Except for these rights and licenses expressly granted, no other intellectual property rights are granted or should be implied.\n\n   Section 3. Conditions on Rights Granted\n\n      3.1 If You Publish Data You Receive or Enhanced Data:\n\n         (a) The Data (including the Enhanced Data) must be Published under this Agreement in accordance with this Section 3; and\n\n         (b) You must cause any Data files containing Enhanced Data to carry prominent notices that You have changed those files; and\n\n         (c) If You Publish Data You Receive, You must preserve all credit or attribution to the Data Provider(s). Such retained credit or attribution includes any of the following to the extent they exist in Data as You have Received it: legal notices or metadata; identification of the Data Provider(s); or hyperlinks to Data to the extent it is practical to do so.\n\n      3.2 You may not restrict or deter the ability of anyone who Receives the Data (a) to Publish the Data in a publicly-accessible manner or (b) if the project has designated a Ledger for recording Data or grants of rights in Data for purposes of this Agreement, to record the Data or grants of rights in Data in the Ledger.\n\n      3.3 If You Publish Data You Receive, You must do so under an unmodified form of this Agreement and include the text of this Agreement, the name of this Agreement and/or a hyperlink or other method reasonably likely to provide a copy of the text of this Agreement. You may not modify this Agreement or impose any further restrictions on the exercise of the rights granted under this Agreement, including by adding any restriction on commercial or non-commercial Use of Data (including Your Enhanced Data) or by limiting permitted Use of such Data to any particular platform, technology or field of endeavor. Notices that purport to modify this Agreement shall be of no effect.\n\n      3.4 You and each Data Provider agree that Enhanced Data shall not be considered a work of joint authorship by virtue of its relationship to Data licensed under this Agreement and shall not require either any obligation of accounting to or the consent of any Data Provider.\n\n      3.5 This Agreement imposes no obligations or restrictions on Your Use or Publication of Results.\n\n   Section 4. Data Provider(s)' Representations\n\n      4.1 Each Data Provider represents that the Data Provider has exercised reasonable care, to assure that: (a) the Data it Publishes was created or generated by it or was obtained from others with the right to Publish the Data under this Agreement; and (b) Publication of such Data does not violate any privacy or confidentiality obligation undertaken by the Data Provider.\n\n   Section 5. Termination\n\n      5.1 All of Your rights under this Agreement will terminate, and Your right to Receive, Use or Publish the Data will be revoked or modified if You materially fail to comply with the terms and conditions of this Agreement and You do not cure such failure in a reasonable period of time after becoming aware of such noncompliance. If Your rights under this Agreement terminate, You agree to cease Receipt, Use and Publication of Data. However, Your obligations and any rights and permissions granted by You under this Agreement relating to Data that You Published prior to such termination will continue and survive.\n\n      5.2 If You institute litigation against a Data Provider or anyone else who Receives the Data (including a cross-claim in a lawsuit) based on the Data, other than a claim asserting breach of this Agreement, then any rights previously granted to You to Receive, Use and Publish Data under this Agreement will terminate as of the date such litigation is filed.\n\n   Section 6. Disclaimer of Warranties and Limitation of Liability\n\n      6.1 EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE DATA (INCLUDING ENHANCED DATA) IS PROVIDED ON AN \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.\n\n      6.2 NEITHER YOU NOR ANY DATA PROVIDERS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE DATA OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\n   Section 7. Miscellaneous\n\n      7.1 You agree that it is solely Your responsibility to comply with all applicable laws with regard to Your Use or Publication of Data, including any applicable privacy, data protection, security and export laws. You agree to take reasonable steps to assist a Data Provider fulfilling responsibilities to comply with applicable laws with regard to Use or Publication of Data Received hereunder.\n\n      7.2 You and Data Provider(s), collectively and individually, waive and/or agree not to assert, to the extent permitted by law, any moral rights You or they hold in Data.\n\n      7.3 This Agreement confers no rights or remedies upon any person or entity other than the Parties and their respective heirs, executors, successors and assigns.\n\n      7.4 The Data Provider(s) reserve no right or expectation of privacy, data protection or confidentiality in any Data that they Publish under this Agreement. If You choose to Publish Data under this Agreement, You similarly do so with no reservation or expectation of any rights of privacy or confidentiality in that Data.\n\n      7.5 The Community Data License Agreement workgroup under The Linux Foundation is the steward of this Agreement (\"Steward\"). No one other than the Steward has the right to modify or publish new versions of this Agreement. Each version will be given a distinguishing version number. You may Use and Publish Data Received hereunder under the terms of the version of the Agreement under which You originally Received the Data, or under the terms of any subsequent version published by the Steward."],"licenseIds":["CDLA-Sharing-1.0"],"keywords":["1 7 ledger","7 ledger means","ledger means a","means a digital","a digital record","digital record of","record of data","in data governed","this agreement using","agreement using any","using any technology","any technology having","technology having functionality","having functionality to","functionality to record","to record and","record and store","and store data","store data or","or grants contributions","grants contributions or","contributions or licenses","licenses to data","to data governed","agreement 1 8","1 8 modify","8 modify means","results 1 9","1 9 publish","9 publish means","data 1 10","1 10 receive","10 receive or","remotely 1 11","1 11 results","11 results means","based 1 12","1 12 sui","12 sui generis","world 1 13","1 13 use","13 use means","both 1 14","data a the","data including the","including the enhanced","the enhanced data","enhanced data must","data must be","must be published","be published under","agreement in accordance","may not restrict","restrict or deter","or deter the","deter the ability","ability of anyone","of anyone who","the data a","data a to","a to publish","the data in","in a publicly","publicly accessible manner","accessible manner or","manner or b","or b if","if the project","the project has","project has designated","has designated a","designated a ledger","a ledger for","ledger for recording","for recording data","recording data or","in data for","data for purposes","agreement to record","to record the","record the data","in data in","in the ledger","the ledger 3","ledger 3 3","so under an","under an unmodified","an unmodified form","unmodified form of","agreement and include","not modify this","agreement or impose","agreement including by","including by adding","by adding any","adding any restriction","any restriction on","restriction on commercial","on commercial or","data or by","or by limiting","by limiting permitted","limiting permitted use","permitted use of","such data to","data to any","to any particular","any particular platform","particular platform technology","platform technology or","technology or field","or field of","of endeavor notices","endeavor notices that","notices that purport","purport to modify","of no effect","no effect 3","effect 3 4","4 you and","provider 3 5","3 5 this","entity 1 7 ledger","1 7 ledger means","7 ledger means a","ledger means a digital","means a digital record","a digital record of","digital record of data","record of data or","of data or grants","rights in data governed","in data governed by","by this agreement using","this agreement using any","agreement using any technology","using any technology having","any technology having functionality","technology having functionality to","having functionality to record","functionality to record and","to record and store","record and store data","and store data or","store data or grants","data or grants contributions","or grants contributions or","grants contributions or licenses","contributions or licenses to","or licenses to data","licenses to data governed","to data governed by","by this agreement 1","this agreement 1 8","agreement 1 8 modify","1 8 modify means","8 modify means to","include results 1 9","results 1 9 publish","1 9 publish means","9 publish means to","publish data 1 10","data 1 10 receive","1 10 receive or","10 receive or receives","or remotely 1 11","remotely 1 11 results","1 11 results means","11 results means the","is based 1 12","based 1 12 sui","1 12 sui generis","12 sui generis database","the world 1 13","world 1 13 use","1 13 use means","13 use means using","of both 1 14","both 1 14 you","enhanced data a the","data a the data","a the data including","the data including the","data including the enhanced","including the enhanced data","the enhanced data must","enhanced data must be","data must be published","must be published under","be published under this","published under this agreement","this agreement in accordance","agreement in accordance with","section 3 and b","2 you may not","you may not restrict","may not restrict or","not restrict or deter","restrict or deter the","or deter the ability"]},{"licenseTexts":["CONTRAT DE LICENCE DE LOGICIEL LIBRE CeCILL Avertissement\n\nCe contrat est une licence de logiciel libre issue d'une concertation entre ses auteurs afin que le respect de deux grands principes préside à sa rédaction:\n\n   • d'une part, sa conformité au droit français, tant au regard du droit de la responsabilité civile que du droit de la propriété intellectuelle et de la protection qu'il offre aux auteurs et titulaires des droits patrimoniaux sur un logiciel.\n\n   • d'autre part, le respect des principes de diffusion des logiciels libres: accès au code source, droits étendus conférés aux utilisateurs.\n\nLes auteurs de la licence CeCILL1 sont:\n\nCommissariat à l'Energie Atomique – CEA, établissement public de caractère scientifique technique et industriel, dont le siège est situé 31-33 rue de la Fédération, 75752 PARIS cedex 15.\n\nCentre National de la Recherche Scientifique – CNRS, établissement public à caractère scientifique et technologique, dont le siège est situé 3 rue Michel-Ange 75794 Paris cedex 16.\n\nInstitut National de Recherche en Informatique et en Automatique – INRIA, établissement public à caractère scientifique et technologique, dont le siège est situé Domaine de Voluceau, Rocquencourt, BP 105, 78153 Le Chesnay cedex.\n\nPREAMBULE\n\nCe contrat est une licence de logiciel libre dont l'objectif est de conférer aux utilisateurs la liberté de modification et de redistribution du logiciel régi par cette licence dans le cadre d'un modèle de diffusion «open source».\n\nL'exercice de ces libertés est assorti de certains devoirs à la charge des utilisateurs afin de préserver ce statut au cours des redistributions ultérieures.\n\nL'accessibilité au code source et les droits de copie, de modification et de redistribution qui en découlent ont pour contrepartie de n'offrir aux utilisateurs qu'une garantie limitée et de ne faire peser sur l'auteur du logiciel, le titulaire des droits patrimoniaux et les concédants successifs qu'une responsabilité restreinte.\n\nA cet égard l'attention de l'utilisateur est attirée sur les risques associés au chargement, à l'utilisation, à la modification et/ou au développement et à la reproduction du logiciel par l'utilisateur étant donné sa spécificité de logiciel libre, qui peut le rendre complexe à manipuler et qui le réserve donc à des développeurs et des professionnels avertis possédant des connaissances informatiques approfondies. Les utilisateurs sont donc invités à charger et tester l'adéquation du Logiciel à leurs besoins dans des conditions permettant d'assurer la sécurité de leurs systèmes et ou de leurs données et, plus généralement, à l'utiliser et l'exploiter dans les même conditions de sécurité. Ce contrat peut être reproduit et diffusé librement, sous réserve de le conserver en l'état, sans ajout ni suppression de clauses.\n\nCe contrat est susceptible de s'appliquer à tout logiciel dont le titulaire des droits patrimoniaux décide de soumettre l'exploitation aux dispositions qu'il contient.\n\nArticle 1er - DEFINITIONS\n\nDans ce contrat, les termes suivants, lorsqu'ils seront écrits avec une lettre capitale, auront la signification suivante:\n\nContrat: désigne le présent contrat de licence, ses éventuelles versions postérieures et annexes.\n\nLogiciel: désigne le logiciel sous sa forme de Code Objet et/ou de Code Source et le cas échéant sa documentation, dans leur état au moment de l'acceptation du\n\nContrat par le Licencié.\n\nLogiciel Initial: désigne le Logiciel sous sa forme de Code Source et de Code Objet et le cas échéant sa documentation, dans leur état au moment de leur première diffusion sous les termes du Contrat.\n\nLogiciel Modifié: désigne le Logiciel modifié par au moins une Contribution.\n\nCode Source: désigne l'ensemble des instructions et des lignes de programme du Logiciel et auquel l'accès est nécessaire en vue de modifier le Logiciel.\n\nCode Objet: désigne les fichiers binaires issus de la compilation du Code Source.\n\nTitulaire : désigne le détenteur des droits patrimoniaux d'auteur sur le Logiciel Initial.\n\nLicencié(s): désigne le ou les utilisateur(s) du Logiciel ayant accepté le Contrat.\n\nContributeur: désigne le Licencié auteur d'au moins une Contribution.\n\nConcédant: désigne le Titulaire ou toute personne physique ou morale distribuant le Logiciel sous le Contrat.\n\nContributions: désigne l'ensemble des modifications, corrections, traductions, adaptations et/ou nouvelles fonctionnalités intégrées dans le Logiciel par tout\n\nContributeur, ainsi que les Modules Statiques.\n\nModule: désigne un ensemble de fichiers sources y compris leur documentation qui, une fois compilé sous forme exécutable, permet de réaliser des fonctionnalités ou\n\nservices supplémentaires à ceux fournis par le Logiciel.\n\nModule Dynamique: désigne tout Module, créé par le Contributeur, indépendant du Logiciel, tel que ce Module et le Logiciel sont sous forme de deux exécutables indépendants qui s'exécutent dans un espace d'adressage indépendant, l'un appelant l'autre au moment de leur exécution.\n\nModule Statique: désigne tout Module créé par le Contributeur et lié au Logiciel par un lien statique rendant leur code objet dépendant l'un de l'autre. Ce Module et le Logiciel auquel il est lié, sont regroupés en un seul exécutable.\n\nParties: désigne collectivement le Licencié et le Concédant.\n\nCes termes s'entendent au singulier comme au pluriel.\n\nArticle 2 - OBJET\n\nLe Contrat a pour objet la concession par le Concédant au Licencié d'une Licence non exclusive, transférable et mondiale du Logiciel telle que définie ci-après à l'article 5 pour toute la durée de protection des droits portant sur ce Logiciel.\n\nArticle 3 - ACCEPTATION\n\n   3.1. L'acceptation par le Licencié des termes du Contrat est réputée acquise du fait du premier des faits suivants:\n\n      • (i) le chargement du Logiciel par tout moyen notamment par téléchargement à partir d'un serveur distant ou par chargement à partir d'un support physique;\n\n      • (ii) le premier exercice par le Licencié de l'un quelconque des droits concédés par le Contrat.\n\n   3.2. Un exemplaire du Contrat, contenant notamment un avertissement relatif aux spécificités du Logiciel, à la restriction de garantie et à la limitation à un usage par des utilisateurs expérimentés a été mis à disposition du Licencié préalablement à son acceptation telle que définie à l'article 3.1 ci dessus et le Licencié reconnaît en avoir pris connaissances.\n\nArticle 4 - ENTREE EN VIGUEUR ET DUREE\n\n   4.1. ENTREE EN VIGUEUR\n\n   Le Contrat entre en vigueur à la date de son acceptation par le Licencié telle que définie en 3.1.\n\n   4.2. DUREE\n\n   Le Contrat produira ses effets pendant toute la durée légale de protection des droits patrimoniaux portant sur le Logiciel.\n\nArticle 5 - ETENDUE DES DROITS CONCEDES\n\nLe Concédant concède au Licencié, qui accepte, les droits suivants sur le Logiciel pour toutes destinations et pour la durée du Contrat dans les conditions ci-après détaillées.\n\nPar ailleurs, le Concédant concède au Licencié à titre gracieux les droits d'exploitation du ou des brevets qu'il détient sur tout ou partie des inventions\n\nimplémentées dans le Logiciel.\n\n   5.1. DROITS D'UTILISATION\n\n   Le Licencié est autorisé à utiliser le Logiciel, sans restriction quant aux domaines d'application, étant ci-après précisé que cela comporte:\n\n      1. la reproduction permanente ou provisoire du Logiciel en tout ou partie par tout moyen et sous toute forme.\n\n      2. le chargement, l'affichage, l'exécution, ou le stockage du Logiciel sur tout support.\n\n      3. la possibilité d'en observer, d'en étudier, ou d'en tester le fonctionnement afin de déterminer les idées et principes qui sont à la base de n'importe quel élément de ce Logiciel; et ceci, lorsque le Licencié effectue toute opération de chargement, d'affichage, d'exécution, de transmission ou de stockage du Logiciel qu'il est en droit d'effectuer en vertu du Contrat.\n\n   5.2. DROIT D'APPORTER DES CONTRIBUTIONS\n\n   Le droit d'apporter des Contributions comporte le droit de traduire, d'adapter, d'arranger ou d'apporter toute autre modification du Logiciel et le droit de reproduire le Logiciel en résultant.\n\n   Le Licencié est autorisé à apporter toute Contribution au Logiciel sous réserve de mentionner, de façon explicite, son nom en tant qu'auteur de cette Contribution et la date de création de celle-ci.\n\n   5.3. DROITS DE DISTRIBUTION ET DE DIFFUSION\n\n   Le droit de distribution et de diffusion comporte notamment le droit de transmettre et de communiquer le Logiciel au public sur tout support et par tout moyen ainsi que le droit de mettre sur le marché à titre onéreux ou gratuit, un ou des exemplaires du Logiciel par tout procédé.\n\n   Le Licencié est autorisé à redistribuer des copies du Logiciel, modifié ou non, à des tiers dans les conditions ci-après détaillées.\n\n      5.3.1. REDISTRIBUTION DU LOGICIEL SANS MODIFICATION\n\n      Le Licencié est autorisé à redistribuer des copies conformes du Logiciel, sous forme de Code Source ou de Code Objet, à condition que cette redistribution respecte les dispositions du Contrat dans leur totalité et soit accompagnée:\n\n         1. d'un exemplaire du Contrat,\n\n         2. d'un avertissement relatif à la restriction de garantie et de responsabilité du Concédant telle que prévue aux articles 8 et 9,\n\n         et que, dans le cas où seul le Code Objet du Logiciel est redistribué, le Licencié permette aux futurs Licenciés d'accéder facilement au Code Source complet du Logiciel en indiquant les modalités d'accès, étant entendu que le coût additionnel d'acquisition du Code Source ne devra pas excéder le simple coût de transfert des données.\n\n      5.3.2. REDISTRIBUTION DU LOGICIEL MODIFIE\n\n      Lorsque le Licencié apporte une Contribution au Logiciel, les conditions de redistribution du Logiciel Modifié sont alors soumises à l'intégralité des dispositions du Contrat.\n\n      Le Licencié est autorisé à redistribuer le Logiciel Modifié, sous forme de Code Source ou de Code Objet, à condition que cette redistribution respecte les dispositions du Contrat dans leur totalité et soit accompagnée:\n\n         1. d'un exemplaire du Contrat,\n\n         2. d'un avertissement relatif à la restriction de garantie et de responsabilité du concédant telle que prévue aux articles 8 et 9,\n\n         et que, dans le cas où seul le Code Objet du Logiciel Modifié est redistribué, le Licencié permette aux futurs Licenciés d'accéder facilement au Code Source complet du Logiciel Modifié en indiquant les modalités d'accès, étant entendu que le coût additionnel d'acquisition du Code Source ne devra pas excéder le simple coût de transfert des données.\n\n      5.3.3. REDISTRIBUTION DES MODULES DYNAMIQUES\n\n      Lorsque le Licencié a développé un Module Dynamique les conditions du Contrat ne s'appliquent pas à ce Module Dynamique, qui peut être distribué sous un contrat de licence différent.\n\n      5.3.4. COMPATIBILITE AVEC LA LICENCE GPL\n\n      Dans le cas où le Logiciel, Modifié ou non, est intégré à un code soumis aux dispositions de la licence GPL, le Licencié est autorisé à redistribuer l'ensemble sous la licence GPL.\n\n      Dans le cas où le Logiciel Modifié intègre un code soumis aux dispositions de la licence GPL, le Licencié est autorisé à redistribuer le Logiciel Modifié sous la licence GPL.\n\nArticle 6 - PROPRIETE INTELLECTUELLE\n\n   6.1. SUR LE LOGICIEL INITIAL\n\n   Le Titulaire est détenteur des droits patrimoniaux sur le Logiciel Initial. Toute utilisation du Logiciel Initial est soumise au respect des conditions dans lesquelles le Titulaire a choisi de diffuser son œuvre et nul autre n'a la faculté de modifier les conditions de diffusion de ce Logiciel Initial.\n\n   Le Titulaire s'engage à maintenir la diffusion du Logiciel initial sous les conditions du Contrat et ce, pour la durée visée à l'article 4.2.\n\n   6.2. SUR LES CONTRIBUTIONS\n\n   Les droits de propriété intellectuelle sur les Contributions sont attachés au titulaire de droits patrimoniaux désigné par la législation applicable.\n\n   6.3. SUR LES MODULES DYNAMIQUES\n\n   Le Licencié ayant développé un Module Dynamique est titulaire des droits de propriété intellectuelle sur ce Module Dynamique et reste libre du choix du contrat régissant sa diffusion.\n\n   6.4. DISPOSITIONS COMMUNES\n\n      6.4.1. Le Licencié s'engage expressément:\n\n         1. à ne pas supprimer ou modifier de quelque manière que ce soit les mentions de propriété intellectuelle apposées sur le Logiciel;\n\n         2. à reproduire à l'identique lesdites mentions de propriété intellectuelle sur les copies du Logiciel.\n\n      6.4.2. Le Licencié s'engage à ne pas porter atteinte, directement ou indirectement, aux droits de propriété intellectuelle du Titulaire et/ou des Contributeurs et à prendre, le cas échéant, à l'égard de son personnel toutes les mesures nécessaires pour assurer le respect des dits droits de propriété intellectuelle du Titulaire et/ou des Contributeurs.\n\nArticle 7 - SERVICES ASSOCIES\n\n   7.1. Le Contrat n'oblige en aucun cas le Concédant à la réalisation de prestations d'assistance technique ou de maintenance du Logiciel.\n\n   Cependant le Concédant reste libre de proposer ce type de services. Les termes et conditions d'une telle assistance technique et/ou d'une telle maintenance seront alors déterminés dans un acte séparé. Ces actes de maintenance et/ou assistance technique n'engageront que la seule responsabilité du Concédant qui les propose.\n\n   7.2. De même, tout Concédant est libre de proposer, sous sa seule responsabilité, à ses licenciés une garantie, qui n'engagera que lui, lors de la redistribution du Logiciel et/ou du Logiciel Modifié et ce, dans les conditions qu'il souhaite. Cette garantie et les modalités financières de son application feront l'objet d'un acte séparé entre le Concédant et le Licencié.\n\nArticle 8 - RESPONSABILITE\n\n   8.1. Sous réserve des dispositions de l'article 8.2, si le Concédant n'exécute pas tout ou partie des obligations mises à sa charge par le Contrat, le Licencié a la faculté, sous réserve de prouver la faute du Concédant concerné, de solliciter la réparation du préjudice direct qu'il subit et dont il apportera la preuve.\n\n   8.2. La responsabilité du Concédant est limitée aux engagements pris en application du Contrat et ne saurait être engagée en raison notamment:(i) des dommages dus à l'inexécution, totale ou partielle, de ses obligations par le Licencié, (ii) des dommages directs ou indirects découlant de l'utilisation ou des performances du Logiciel subis par le Licencié lorsqu'il s'agit d'un professionnel utilisant le Logiciel à des fins professionnelles et (iii) des dommages indirects découlant de l'utilisation ou des performances du Logiciel. Les Parties conviennent expressément que tout préjudice financier ou commercial (par exemple perte de données, perte de bénéfices, perte d'exploitation, perte de clientèle ou de commandes, manque à gagner, trouble commercial quelconque) ou toute action dirigée contre le Licencié par un tiers, constitue un dommage indirect et n'ouvre pas droit à réparation par le Concédant.\n\nArticle 9 - GARANTIE\n\n   9.1. Le Licencié reconnaît que l'état actuel des connaissances scientifiques et techniques au moment de la mise en circulation du Logiciel ne permet pas d'en tester et d'en vérifier toutes les utilisations ni de détecter l'existence d'éventuels défauts. L'attention du Licencié a été attirée sur ce point sur les risques associés au chargement, à l'utilisation, la modification et/ou au développement et à la reproduction du Logiciel qui sont réservés à des utilisateurs avertis.\n\n   Il relève de la responsabilité du Licencié de contrôler, par tous moyens, l'adéquation du produit à ses besoins, son bon fonctionnement et de s'assurer qu'il ne causera pas de dommages aux personnes et aux biens.\n\n   9.2. Le Concédant déclare de bonne foi être en droit de concéder l'ensemble des droits attachés au Logiciel (comprenant notamment les droits visés à l'article 5).\n\n   9.3. Le Licencié reconnaît que le Logiciel est fourni «en l'état» par le Concédant sans autre garantie, expresse ou tacite, que celle prévue à l'article 9.2 et notamment sans aucune garantie sur sa valeur commerciale, son caractère sécurisé, innovant ou pertinent.\n\n   En particulier, le Concédant ne garantit pas que le Logiciel est exempt d'erreur, qu'il fonctionnera sans interruption, qu'il sera compatible avec l'équipement du Licencié et sa configuration logicielle ni qu'il remplira les besoins du Licencié.\n\n   9.4. Le Concédant ne garantit pas, de manière expresse ou tacite, que le Logiciel ne porte pas atteinte à un quelconque droit de propriété intellectuelle d'un tiers portant sur un brevet, un logiciel ou sur tout autre droit de propriété. Ainsi, le Concédant exclut toute garantie au profit du Licencié contre les actions en contrefaçon qui pourraient être diligentées au titre de l'utilisation, de la modification, et de la redistribution du Logiciel. Néanmoins, si de telles actions sont exercées contre le Licencié, le Concédant lui apportera son aide technique et juridique pour sa défense. Cette aide technique et juridique est déterminée au cas par cas entre le Concédant concerné et le Licencié dans le cadre d'un protocole d'accord. Le Concédant dégage toute responsabilité quant à l'utilisation de la dénomination du Logiciel par le Licencié. Aucune garantie n'est apportée quant à l'existence de droits antérieurs sur le nom du Logiciel et sur l'existence d'une marque.\n\nArticle 10 - RESILIATION\n\n   10.1. En cas de manquement par le Licencié aux obligations mises à sa charge par le Contrat, le Concédant pourra résilier de plein droit le Contrat trente (30) jours après notification adressée au Licencié et restée sans effet.\n\n   10.2. Le Licencié dont le Contrat est résilié n'est plus autorisé à utiliser, modifier ou distribuer le Logiciel. Cependant, toutes les licences qu'il aura concédées antérieurement à la résiliation du Contrat resteront valides sous réserve qu'elles aient été effectuées en conformité avec le Contrat.\n\nArticle 11 - DISPOSITIONS DIVERSES\n\n   11.1. CAUSE EXTERIEURE\n\n   Aucune des Parties ne sera responsable d'un retard ou d'une défaillance d'exécution du Contrat qui serait dû à un cas de force majeure, un cas fortuit ou une cause extérieure, telle que, notamment, le mauvais fonctionnement ou les interruptions du réseau électrique ou de télécommunication, la paralysie du réseau liée à une attaque informatique, l'intervention des autorités gouvernementales, les catastrophes naturelles, les dégâts des eaux, les tremblements de terre, le feu, les explosions, les grèves et les conflits sociaux, l'état de guerre…\n\n   11.2. Le fait, par l'une ou l'autre des Parties, d'omettre en une ou plusieurs occasions de se prévaloir d'une ou plusieurs dispositions du Contrat, ne pourra en aucun cas impliquer renonciation par la Partie intéressée à s'en prévaloir ultérieurement.\n\n   11.3. Le Contrat annule et remplace toute convention antérieure, écrite ou orale, entre les Parties sur le même objet et constitue l'accord entier entre les Parties sur cet objet. Aucune addition ou modification aux termes du Contrat n'aura d'effet à l'égard des Parties à moins d'être faite par écrit et signée par leurs représentants dûment habilités.\n\n   11.4. Dans l'hypothèse où une ou plusieurs des dispositions du Contrat s'avèrerait contraire à une loi ou à un texte applicable, existants ou futurs, cette loi ou ce texte prévaudrait, et les Parties feraient les amendements nécessaires pour se conformer à cette loi ou à ce texte. Toutes les autres dispositions resteront en vigueur. De même, la nullité, pour quelque raison que ce soit, d'une des dispositions du Contrat ne saurait entraîner la nullité de l'ensemble du Contrat.\n\n   11.5. LANGUE\n\n   Le Contrat est rédigé en langue française et en langue anglaise. En cas de divergence d'interprétation, seule la version française fait foi.\n\nArticle 12 - NOUVELLES VERSIONS DU CONTRAT\n\n   12.1. Toute personne est autorisée à copier et distribuer des copies de ce Contrat.\n\n   12.2. Afin d'en préserver la cohérence, le texte du Contrat est protégé et ne peut être modifié que par les auteurs de la licence, lesquels se réservent le droit de publier périodiquement des mises à jour ou de nouvelles versions du Contrat, qui possèderont chacune un numéro distinct. Ces versions ultérieures seront susceptibles de prendre en compte de nouvelles problématiques rencontrées par les logiciels libres.\n\n   12.3. Tout Logiciel diffusé sous une version donnée du Contrat ne pourra faire l'objet d'une diffusion ultérieure que sous la même version du Contrat ou une version postérieure, sous réserve des dispositions de l'article 5.3.4.\n\nArticle 13 - LOI APPLICABLE ET COMPETENCE TERRITORIALE\n\n   13.1. Le Contrat est régi par la loi française. Les Parties conviennent de tenter de régler à l'amiable les différends ou litiges qui viendraient à se produire par suite ou à l'occasion du Contrat.\n\n   13.2. A défaut d'accord amiable dans un délai de deux (2) mois à compter de leur survenance et sauf situation relevant d'une procédure d'urgence, les différends ou litiges seront portés par la Partie la plus diligente devant les Tribunaux compétents de Paris.\n\n1 Ce: CEA, C: CNRS, I: INRIA, LL: Logiciel Libre Version 1 du 21/06/2004"],"licenseIds":["CECILL-1.0"],"keywords":["libre cecill avertissement","cecill avertissement ce","avertissement ce contrat","logiciel libre issue","libre issue d","issue d une","d une concertation","une concertation entre","concertation entre ses","entre ses auteurs","ses auteurs afin","auteurs afin que","afin que le","que le respect","le respect de","respect de deux","de deux grands","deux grands principes","grands principes pr","principes pr side","pr side sa","side sa r","sa r daction","r daction d","daction d une","d une part","une part sa","part sa conformit","sa conformit au","conformit au droit","fran ais tant","ais tant au","tant au regard","au regard du","regard du droit","la responsabilit civile","responsabilit civile que","civile que du","que du droit","intellectuelle et de","de la protection","la protection qu","protection qu il","qu il offre","il offre aux","offre aux auteurs","aux auteurs et","auteurs et titulaires","et titulaires des","titulaires des droits","patrimoniaux sur un","sur un logiciel","logiciel d autre","d autre part","autre part le","part le respect","respect des principes","des principes de","principes de diffusion","de diffusion des","diffusion des logiciels","logiciels libres acc","libres acc s","acc s au","s au code","code source droits","source droits tendus","droits tendus conf","tendus conf r","conf r s","r s aux","s aux utilisateurs","aux utilisateurs les","utilisateurs les auteurs","la licence cecill1","licence cecill1 sont","cecill1 sont commissariat","sont commissariat l","atomique cea tablissement","cea tablissement public","tablissement public de","public de caract","de caract re","re scientifique technique","scientifique technique et","technique et industriel","et industriel dont","industriel dont le","est situ 31","situ 31 33","cedex 15 centre","15 centre national","scientifique cnrs tablissement","cnrs tablissement public","est situ 3","situ 3 rue","cedex 16 institut","16 institut national","automatique inria tablissement","inria tablissement public","est situ domaine","situ domaine de","chesnay cedex preambule","cedex preambule ce","preambule ce contrat","logiciel libre dont","libre dont l","dont l objectif","l objectif est","objectif est de","est de conf","de conf rer","conf rer aux","rer aux utilisateurs","aux utilisateurs la","utilisateurs la libert","libert de modification","du logiciel r","logiciel r gi","gi par cette","cette licence dans","licence dans le","d un mod","un mod le","mod le de","le de diffusion","de diffusion open","diffusion open source","open source l","source l exercice","l exercice de","exercice de ces","de ces libert","ces libert s","libert s est","s est assorti","est assorti de","assorti de certains","de certains devoirs","certains devoirs la","devoirs la charge","la charge des","charge des utilisateurs","des utilisateurs afin","utilisateurs afin de","afin de pr","de pr server","pr server ce","server ce statut","ce statut au","statut au cours","au cours des","cours des redistributions","des redistributions ult","redistributions ult rieures","ult rieures l","rieures l accessibilit","l accessibilit au","accessibilit au code","source et les","droits de copie","copie de modification","de redistribution qui","redistribution qui en","qui en d","en d coulent","d coulent ont","coulent ont pour","ont pour contrepartie","pour contrepartie de","contrepartie de n","de n offrir","n offrir aux","offrir aux utilisateurs","aux utilisateurs qu","utilisateurs qu une","qu une garantie","une garantie limit","garantie limit e","limit e et","e et de","et de ne","de ne faire","ne faire peser","faire peser sur","peser sur l","sur l auteur","l auteur du","auteur du logiciel","du logiciel le","logiciel le titulaire","droits patrimoniaux et","patrimoniaux et les","et les conc","les conc dants","conc dants successifs","dants successifs qu","successifs qu une","qu une responsabilit","une responsabilit restreinte"]},{"licenseTexts":["FREE SOFTWARE LICENSING AGREEMENT CeCILL Notice\n\nThis Agreement is a free software license that is the result of discussions between its authors in order to ensure compliance with the two main principles guiding its drafting:\n\n   - firstly, its conformity with French law, both as regards the law of torts and intellectual property law, and the protection that it offers to authors and the holders of economic rights over software.\n\n   - secondly, compliance with the principles for the distribution of free software: access to source codes, extended user-rights.\n\nThe following bodies are the authors of this license CeCILL (Ce : CEA, C : CNRS, I : INRIA, LL : Logiciel Libre):\n\n   \n\n   Commissariat à l'Energie Atomique - CEA, a public scientific, technical and industrial establishment, having its principal place of business at 31-33 rue de la Fédération, 75752 PARIS cedex 15, France.\n\n   \n\n   Centre National de la Recherche Scientifique - CNRS, a public scientific and technological establishment, having its principal place of business at 3 rue Michel-Ange 75794 Paris cedex 16, France.\n\n   \n\n   Institut National de Recherche en Informatique et en Automatique - INRIA, a public scientific and technological establishment, having its principal place of business at Domaine de Voluceau, Rocquencourt, BP 105, 78153 Le Chesnay cedex.\n\n   \n\n   PREAMBLE\n\n   The purpose of this Free Software Licensing Agreement is to grant users the right to modify and redistribute the software governed by this license within the framework of an \"open source\" distribution model.\n\n   The exercising of these rights is conditional upon certain obligations for users so as to ensure that this status is retained for subsequent redistribution operations.\n\n   As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors only have limited liability.\n\n   In this respect, it is brought to the user's attention that the risks associated with loading, using, modifying and/or developing or reproducing the software by the user given its nature of Free Software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the Software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions of security. This Agreement may be freely reproduced and published, provided it is not altered, and that no Articles are either added or removed herefrom.\n\n   This Agreement may apply to any or all software for which the holder of the economic rights decides to submit the operation thereof to its provisions.\n\n   Article 1 - DEFINITIONS\n\n   For the purposes of this Agreement, when the following expressions commence with a capital letter, they shall have the following meaning:\n\n      \n\n      Agreement: means this Licensing Agreement, and any or all of its subsequent versions.\n\n      \n\n      Software: means the software in its Object Code and/or Source Code form and, where applicable, its documentation, \"as is\" at the time when the Licensee accepts the Agreement.\n\n      \n\n      Initial Software: means the Software in its Source Code and/or Object Code form and, where applicable, its documentation, \"as is\" at the time when it is distributed for the first time under the terms and conditions of the Agreement.\n\n      \n\n      Modified Software: means the Software modified by at least one Contribution.\n\n      \n\n      Source Code: means all the Software's instructions and program lines to which access is required so as to modify the Software.\n\n      \n\n      Object Code: means the binary files originating from the compilation of the Source Code.\n\n      \n\n      Holder: means the holder of the economic rights over the Initial Software.\n\n      \n\n      Licensee(s): mean(s) the Software user(s) having accepted the Agreement.\n\n      \n\n      Contributor: means a Licensee having made at least one Contribution.\n\n      \n\n      Licensor: means the Holder, or any or all other individual or legal entity, that distributes the Software under the Agreement.\n\n      \n\n      Contributions: mean any or all modifications, corrections, translations, adaptations and/or new functionalities integrated into the Software by any or all Contributor, and the Static Modules.\n\n      \n\n      Module: means a set of sources files including their documentation that, once compiled in executable form, enables supplementary functionalities or services to be developed in addition to those offered by the Software.\n\n      \n\n      Dynamic Module: means any or all module, created by the Contributor, that is independent of the Software, so that this module and the Software are in two different executable forms that are run in separate address spaces, with one calling the other when they are run.\n\n      \n\n      Static Module: means any or all module, created by the Contributor and connected to the Software by a static link that makes their object codes interdependent. This module and the Software to which it is connected, are combined in a single executable.\n\n      \n\n      Parties: mean both the Licensee and the Licensor.\n\n   These expressions may be used both in singular and plural form.\n\n   Article 2 - PURPOSE\n\n   The purpose of the Agreement is to enable the Licensor to grant the Licensee a free, non-exclusive, transferable and worldwide License for the Software as set forth in Article 5 hereinafter for the whole term of protection of the rights over said Software.\n\n   Article 3 - ACCEPTANCE\n\n      3.1. The Licensee shall be deemed as having accepted the terms and conditions of this Agreement by the occurrence of the first of the following events:\n\n         (i) loading the Software by any or all means, notably, by downloading from a remote server, or by loading from a physical medium;\n\n         (ii) the first time the Licensee exercises any of the rights granted hereunder.\n\n      3.2. One copy of the Agreement, containing a notice relating to the specific nature of the Software, to the limited warranty, and to the limitation to use by experienced users has been provided to the Licensee prior to its acceptance as set forth in Article 3.1 hereinabove, and the Licensee hereby acknowledges that it is aware thereof.\n\n   Article 4 - EFFECTIVE DATE AND TERM\n\n      4.1. EFFECTIVE DATE\n\n      The Agreement shall become effective on the date when it is accepted by the Licensee as set forth in Article 3.1.\n\n      4.2. TERM\n\n      The Agreement shall remain in force during the whole legal term of protection of the economic rights over the Software.\n\n   Article 5 - SCOPE OF THE RIGHTS GRANTED ---------------------------------------\n\n   The Licensor hereby grants to the Licensee, that accepts such, the following rights as regards the Software for any or all use, and for the term of the Agreement, on the basis of the terms and conditions set forth hereinafter.\n\n   Otherwise, the Licensor grants to the Licensee free of charge exploitation rights on the patents he holds on whole or part of the inventions implemented in the Software.\n\n      5.1. RIGHTS OF USE\n\n      The Licensee is authorized to use the Software, unrestrictedly, as regards the fields of application, with it being hereinafter specified that this relates to:\n\n         1. permanent or temporary reproduction of all or part of the Software by any or all means and in any or all form.\n\n         2. loading, displaying, running, or storing the Software on any or all medium.\n\n         3. entitlement to observe, study or test the operation thereof so as to establish the ideas and principles that form the basis for any or all constituent elements of said Software. This shall apply when the Licensee carries out any or all loading, displaying, running, transmission or storage operation as regards the Software, that it is entitled to carry out hereunder.\n\n      5.2. ENTITLEMENT TO MAKE CONTRIBUTIONS\n\n      The right to make Contributions includes the right to translate, adapt, arrange, or make any or all modification to the Software, and the right to reproduce the resulting Software.\n\n      The Licensee is authorized to make any or all Contribution to the Software provided that it explicitly mentions its name as the author of said Contribution and the date of the development thereof.\n\n      5.3. DISTRIBUTION AND PUBLICATION RIGHTS\n\n      In particular, the right of distribution and publication includes the right to transmit and communicate the Software to the general public on any or all medium, and by any or all means, and the right to market, either in consideration of a fee, or free of charge, a copy or copies of the Software by means of any or all process. The Licensee is further authorized to redistribute copies of the modified or unmodified Software to third parties according to the terms and conditions set forth hereinafter.\n\n         5.3.1. REDISTRIBUTION OF SOFTWARE WITHOUT MODIFICATION\n\n         The Licensee is authorized to redistribute true copies of the Software in Source Code or Object Code form, provided that said redistribution complies with all the provisions of the Agreement and is accompanied by:\n\n            1. a copy of the Agreement,\n\n            2. a notice relating to the limitation of both the Licensor's warranty and liability as set forth in Articles 8 and 9,\n\n         and that, in the event that only the Software's Object Code is redistributed, the Licensee allows future Licensees unhindered access to the Software's full Source Code by providing them with the terms and conditions for access thereto, it being understood that the additional cost of acquiring the Source Code shall not exceed the cost of transferring the data.\n\n         5.3.2. REDISTRIBUTION OF MODIFIED SOFTWARE\n\n         When the Licensee makes a Contribution to the Software, the terms and conditions for the redistribution of the Modified Software shall then be subject to all the provisions hereof.\n\n         The Licensee is authorized to redistribute the Modified Software, in Source Code or Object Code form, provided that said redistribution complies with all the provisions of the Agreement and is accompanied by:\n\n            1. a copy of the Agreement,\n\n            2. a notice relating to the limitation of both the Licensor's warranty and liability as set forth in Articles 8 and 9,\n\n         and that, in the event that only the Modified Software's Object Code is redistributed, the Licensee allows future Licensees unhindered access to the Modified Software's full Source Code by providing them with the terms and conditions for access thereto, it being understood that the additional cost of acquiring the Source Code shall not exceed the cost of transferring the data.\n\n         5.3.3. REDISTRIBUTION OF DYNAMIC MODULES\n\n         When the Licensee has developed a Dynamic Module, the terms and conditions hereof do not apply to said Dynamic Module, that may be distributed under a separate Licensing Agreement.\n\n         5.3.4. COMPATIBILITY WITH THE GPL LICENSE\n\n         In the event that the Modified or unmodified Software is included in a code that is subject to the provisions of the GPL License, the Licensee is authorized to redistribute the whole under the GPL License.\n\n         In the event that the Modified Software includes a code that is subject to the provisions of the GPL License, the Licensee is authorized to redistribute the Modified Software under the GPL License.\n\n   Article 6 - INTELLECTUAL PROPERTY\n\n      6.1. OVER THE INITIAL SOFTWARE\n\n      The Holder owns the economic rights over the Initial Software. Any or all use of the Initial Software is subject to compliance with the terms and conditions under which the Holder has elected to distribute its work and no one shall be entitled to and it shall have sole entitlement to modify the terms and conditions for the distribution of said Initial Software.\n\n      The Holder undertakes to maintain the distribution of the Initial Software under the conditions of the Agreement, for the duration set forth in article 4.2..\n\n      6.2. OVER THE CONTRIBUTIONS\n\n      The intellectual property rights over the Contributions belong to the holder of the economic rights as designated by effective legislation.\n\n      6.3. OVER THE DYNAMIC MODULES\n\n      The Licensee having developed a Dynamic Module is the holder of the intellectual property rights over said Dynamic Module and is free to choose the agreement that shall govern its distribution.\n\n      6.4. JOINT PROVISIONS\n\n         \n\n         6.4.1. The Licensee expressly undertakes:\n\n            1. not to remove, or modify, in any or all manner, the intellectual property notices affixed to the Software;\n\n            2. to reproduce said notices, in an identical manner, in the copies of the Software.\n\n         \n\n         6.4.2. The Licensee undertakes not to directly or indirectly infringe the intellectual property rights of the Holder and/or Contributors and to take, where applicable, vis-à-vis its staff, any or all measures required to ensure respect for said intellectual property rights of the Holder and/or Contributors.\n\n   Article 7 - RELATED SERVICES\n\n      7.1. Under no circumstances shall the Agreement oblige the Licensor to provide technical assistance or maintenance services for the Software.\n\n      However, the Licensor is entitled to offer this type of service. The terms and conditions of such technical assistance, and/or such maintenance, shall then be set forth in a separate instrument. Only the Licensor offering said maintenance and/or technical assistance services shall incur liability therefor.\n\n      7.2. Similarly, any or all Licensor shall be entitled to offer to its Licensees, under its own responsibility, a warranty, that shall only be binding upon itself, for the redistribution of the Software and/or the Modified Software, under terms and conditions that it shall decide upon itself. Said warranty, and the financial terms and conditions of its application, shall be subject to a separate instrument executed between the Licensor and the Licensee.\n\n   Article 8 - LIABILITY\n\n      8.1. Subject to the provisions of Article 8.2, should the Licensor fail to fulfill all or part of its obligations hereunder, the Licensee shall be entitled to claim compensation for the direct loss suffered as a result of a fault on the part of the Licensor, subject to providing evidence of it.\n\n      8.2. The Licensor's liability is limited to the commitments made under this Licensing Agreement and shall not be incurred as a result , in particular: (i) of loss due the Licensee's total or partial failure to fulfill its obligations, (ii) direct or consequential loss due to the Software's use or performance that is suffered by the Licensee, when the latter is a professional using said Software for professional purposes and (iii) consequential loss due to the Software's use or performance. The Parties expressly agree that any or all pecuniary or business loss (i.e. loss of data, loss of profits, operating loss, loss of customers or orders, opportunity cost, any disturbance to business activities) or any or all legal proceedings instituted against the Licensee by a third party, shall constitute consequential loss and shall not provide entitlement to any or all compensation from the Licensor.\n\n   Article 9 - WARRANTY\n\n      9.1. The Licensee acknowledges that the current situation as regards scientific and technical know-how at the time when the Software was distributed did not enable all possible uses to be tested and verified, nor for the presence of any or all faults to be detected. In this respect, the Licensee's attention has been drawn to the risks associated with loading, using, modifying and/or developing and reproducing the Software that are reserved for experienced users.\n\n      The Licensee shall be responsible for verifying, by any or all means, the product's suitability for its requirements, its due and proper functioning, and for ensuring that it shall not cause damage to either persons or property.\n\n      9.2. The Licensor hereby represents, in good faith, that it is entitled to grant all the rights on the Software (including in particular the rights set forth in Article 5 hereof over the Software).\n\n      9.3. The Licensee acknowledges that the Software is supplied \"as is\" by the Licensor without any or all other express or tacit warranty, other than that provided for in Article 9.2 and, in particular, without any or all warranty as to its market value, its secured, innovative or relevant nature.\n\n      Specifically, the Licensor does not warrant that the Software is free from any or all error, that it shall operate continuously, that it shall be compatible with the Licensee's own equipment and its software configuration, nor that it shall meet the Licensee's requirements.\n\n      9.4. The Licensor does not either expressly or tacitly warrant that the Software does not infringe any or all third party intellectual right relating to a patent, software or to any or all other property right. Moreover, the Licensor shall not hold the Licensee harmless against any or all proceedings for infringement that may be instituted in respect of the use, modification and redistribution of the Software. Nevertheless, should such proceedings be instituted against the Licensee, the Licensor shall provide it with technical and legal assistance for its defense. Such technical and legal assistance shall be decided upon on a case-by-case basis between the relevant Licensor and the Licensee pursuant to a memorandum of understanding. The Licensor disclaims any or all liability as regards the Licensee's use of the Software's name. No warranty shall be provided as regards the existence of prior rights over the name of the Software and as regards the existence of a trademark.\n\n   Article 10 - TERMINATION\n\n      10.1. In the event of a breach by the Licensee of its obligations hereunder, the Licensor may automatically terminate this Agreement thirty (30) days after notice has been sent to the Licensee and has remained ineffective.\n\n      10.2. The Licensee whose Agreement is terminated shall no longer be authorized to use, modify or distribute the Software. However, any or all licenses that it may have granted prior to termination of the Agreement shall remain valid subject to their having been granted in compliance with the terms and conditions hereof.\n\n   Article 11 - MISCELLANEOUS PROVISIONS\n\n      11.1. EXCUSABLE EVENTS\n\n      Neither Party shall be liable for any or all delay, or failure to perform the Agreement, that may be attributable to an event of force majeure, an act of God or an outside cause, such as, notably, defective functioning, or interruptions affecting the electricity or telecommunications networks, blocking of the network following a virus attack, the intervention of the government authorities, natural disasters, water damage, earthquakes, fire, explosions, strikes and labor unrest, war, etc.\n\n      11.2. The fact that either Party may fail, on one or several occasions, to invoke one or several of the provisions hereof, shall under no circumstances be interpreted as being a waiver by the interested Party of its entitlement to invoke said provision(s) subsequently.\n\n      11.3. The Agreement cancels and replaces any or all previous agreement, whether written or oral, between the Parties and having the same purpose, and constitutes the entirety of the agreement between said Parties concerning said purpose. No supplement or modification to the terms and conditions hereof shall be effective as regards the Parties unless it is made in writing and signed by their duly authorized representatives.\n\n      11.4. In the event that one or several of the provisions hereof were to conflict with a current or future applicable act or legislative text, said act or legislative text shall take precedence, and the Parties shall make the necessary amendments so as to be in compliance with said act or legislative text. All the other provisions shall remain effective. Similarly, the fact that a provision of the Agreement may be null and void, for any reason whatsoever, shall not cause the Agreement as a whole to be null and void.\n\n      11.5. LANGUAGE\n\n      The Agreement is drafted in both French and English. In the event of a conflict as regards construction, the French version shall be deemed authentic.\n\n   Article 12 - NEW VERSIONS OF THE AGREEMENT\n\n      12.1. Any or all person is authorized to duplicate and distribute copies of this Agreement.\n\n      12.2. So as to ensure coherence, the wording of this Agreement is protected and may only be modified by the authors of the License, that reserve the right to periodically publish updates or new versions of the Agreement, each with a separate number. These subsequent versions may address new issues encountered by Free Software.\n\n      12.3. Any or all Software distributed under a given version of the Agreement may only be subsequently distributed under the same version of the Agreement, or a subsequent version, subject to the provisions of article 5.3.4.\n\n   Article 13 - GOVERNING LAW AND JURISDICTION\n\n      13.1. The Agreement is governed by French law. The Parties agree to endeavor to settle the disagreements or disputes that may arise during the performance of the Agreement out-of-court.\n\n      13.2. In the absence of an out-of-court settlement within two (2) months as from their occurrence, and unless emergency proceedings are necessary, the disagreements or disputes shall be referred to the Paris Courts having jurisdiction, by the first Party to take action.\n\nVersion 1.1 of 10/26/2004"],"licenseIds":["CECILL-1.1"],"keywords":["licensing agreement cecill","agreement cecill notice","cecill notice this","software license that","drafting firstly its","firstly its conformity","its conformity with","conformity with french","with french law","french law both","law both as","offers to authors","to authors and","authors and the","and the holders","the holders of","holders of economic","of economic rights","over software secondly","software secondly compliance","secondly compliance with","the principles for","principles for the","to source codes","source codes extended","codes extended user","extended user rights","user rights the","rights the following","the following bodies","following bodies are","bodies are the","are the authors","this license cecill","license cecill ce","cecill ce cea","logiciel libre commissariat","libre commissariat l","and industrial establishment","industrial establishment having","business at 31","at 31 33","cedex 15 france","15 france centre","chesnay cedex preamble","cedex preamble the","licensing agreement is","that this status","this status is","status is retained","is retained for","retained for subsequent","for subsequent redistribution","subsequent redistribution operations","redistribution operations as","operations as a","as a counterpart","a counterpart to","counterpart to the","to the access","the access to","code and rights","this respect it","respect it is","it is brought","is brought to","s attention that","attention that the","that the risks","the user given","user given its","given its nature","its nature of","nature of free","that may mean","may mean that","mean that it","it is complicated","is complicated to","complicated to manipulate","to manipulate and","manipulate and that","and that also","that also therefore","also therefore means","therefore means that","it is reserved","test the software","software s suitability","s suitability as","suitability as regards","that no articles","no articles are","articles are either","submit the operation","operation thereof to","means this licensing","and any or","of its subsequent","its subsequent versions","subsequent versions software","versions software means","and or object","time when it","is distributed for","distributed for the","for the first","first time under","time under the","software licensee s","licensee s mean","s mean s","mean s the","s the software","all other individual","the agreement contributions","agreement contributions mean","contributions mean any","mean any or","or new functionalities","new functionalities integrated","functionalities integrated into","or all contributor","all contributor and","and the static","the static modules","static modules module","documentation that once","that once compiled","once compiled in","compiled in executable","executable form enables","form enables supplementary","enables supplementary functionalities","supplementary functionalities or","functionalities or services","or services to","services to be","to be developed","be developed in","developed in addition","the software dynamic","software dynamic module","dynamic module means","the contributor that","contributor that is","that is independent","is independent of","software are in","are in two","in two different","two different executable","different executable forms","executable forms that","forms that are","that are run","are run in","are run static","run static module","static module means","contributor and connected","and connected to","software by a","by a static","a static link","static link that","link that makes","that makes their","makes their object","their object codes","object codes interdependent","codes interdependent this","interdependent this module","it is connected","is connected are","connected are combined","are combined in","combined in a","a single executable","single executable parties","executable parties mean","to enable the","enable the licensor","licensor to grant","grant the licensee","the licensee a","licensee a free","a free non","by the occurrence","to the specific","the specific nature","specific nature of","the limitation to","limitation to use","use by experienced","by experienced users","it is aware","is aware thereof","aware thereof article","in force during"]},{"licenseTexts":["CeCILL FREE SOFTWARE LICENSE AGREEMENT Notice\n\nThis Agreement is a Free Software license agreement that is the result of discussions between its authors in order to ensure compliance with the two main principles guiding its drafting:\n\n   * firstly, compliance with the principles governing the distribution of Free Software: access to source code, broad rights granted to users,\n\n   * secondly, the election of a governing law, French law, with which it is conformant, both as regards the law of torts and intellectual property law, and the protection that it offers to both authors and holders of the economic rights over software.\n\nThe authors of the CeCILL¹ license are:\n\n   \n\n   Commissariat à l'Energie Atomique - CEA, a public scientific, technical and industrial research establishment, having its principal place of business at 25 rue Leblanc, immeuble Le Ponant D, 75015 Paris, France.\n\n   \n\n   Centre National de la Recherche Scientifique - CNRS, a public scientific and technological establishment, having its principal place of business at 3 rue Michel-Ange, 75794 Paris cedex 16, France.\n\n   \n\n   Institut National de Recherche en Informatique et en Automatique - INRIA, a public scientific and technological establishment, having its principal place of business at Domaine de Voluceau, Rocquencourt, BP 105, 78153 Le Chesnay cedex, France.\n\n   Preamble The purpose of this Free Software license agreement is to grant users the right to modify and redistribute the software governed by this license within the framework of an open source distribution model.\n\n   The exercising of these rights is conditional upon certain obligations for users so as to preserve this status for all subsequent redistributions.\n\n   In consideration of access to the source code and the rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors only have limited liability.\n\n   In this respect, the risks associated with loading, using, modifying and/or developing or reproducing the software by the user are brought to the user's attention, given its Free Software status, which may make it complicated to use, with the result that its use is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the suitability of the software as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions of security. This Agreement may be freely reproduced and published, provided it is not altered, and that no provisions are either added or removed herefrom.\n\n   This Agreement may apply to any or all software for which the holder of the economic rights decides to submit the use thereof to its provisions.\n\n   Article 1 - DEFINITIONS\n\n   For the purpose of this Agreement, when the following expressions commence with a capital letter, they shall have the following meaning:\n\n      \n\n      Agreement: means this license agreement, and its possible subsequent versions and annexes.\n\n      \n\n      Software: means the software in its Object Code and/or Source Code form and, where applicable, its documentation, \"as is\" when the Licensee accepts the Agreement.\n\n      \n\n      Initial Software: means the Software in its Source Code and possibly its Object Code form and, where applicable, its documentation, \"as is\" when it is first distributed under the terms and conditions of the Agreement.\n\n      \n\n      Modified Software: means the Software modified by at least one Contribution.\n\n      \n\n      Source Code: means all the Software's instructions and program lines to which access is required so as to modify the Software.\n\n      \n\n      Object Code: means the binary files originating from the compilation of the Source Code.\n\n      \n\n      Holder: means the holder(s) of the economic rights over the Initial Software.\n\n      \n\n      Licensee: means the Software user(s) having accepted the Agreement.\n\n      \n\n      Contributor: means a Licensee having made at least one Contribution.\n\n      \n\n      Licensor: means the Holder, or any other individual or legal entity, who distributes the Software under the Agreement.\n\n      \n\n      Contribution: means any or all modifications, corrections, translations, adaptations and/or new functions integrated into the Software by any or all Contributors, as well as any or all Internal Modules.\n\n      \n\n      Module: means a set of sources files including their documentation that enables supplementary functions or services in addition to those offered by the Software.\n\n      \n\n      External Module: means any or all Modules, not derived from the Software, so that this Module and the Software run in separate address spaces, with one calling the other when they are run.\n\n      \n\n      Internal Module: means any or all Module, connected to the Software so that they both execute in the same address space.\n\n      \n\n      GNU GPL: means the GNU General Public License version 2 or any subsequent version, as published by the Free Software Foundation Inc.\n\n      \n\n      Parties: mean both the Licensee and the Licensor.\n\n   These expressions may be used both in singular and plural form.\n\n   Article 2 - PURPOSE\n\n   The purpose of the Agreement is the grant by the Licensor to the Licensee of a non-exclusive, transferable and worldwide license for the Software as set forth in Article 5 hereinafter for the whole term of the protection granted by the rights over said Software.\n\n   Article 3 - ACCEPTANCE\n\n      3.1 The Licensee shall be deemed as having accepted the terms and conditions of this Agreement upon the occurrence of the first of the following events:\n\n         (i) loading the Software by any or all means, notably, by downloading from a remote server, or by loading from a physical medium;\n\n         (ii) the first time the Licensee exercises any of the rights granted hereunder.\n\n      3.2 One copy of the Agreement, containing a notice relating to the characteristics of the Software, to the limited warranty, and to the fact that its use is restricted to experienced users has been provided to the Licensee prior to its acceptance as set forth in Article 3.1 hereinabove, and the Licensee hereby acknowledges that it has read and understood it.\n\n   Article 4 - EFFECTIVE DATE AND TERM\n\n      4.1 EFFECTIVE DATE\n\n      The Agreement shall become effective on the date when it is accepted by the Licensee as set forth in Article 3.1.\n\n      4.2 TERM\n\n      The Agreement shall remain in force for the entire legal term of protection of the economic rights over the Software.\n\n   Article 5 - SCOPE OF RIGHTS GRANTED\n\n   The Licensor hereby grants to the Licensee, who accepts, the following rights over the Software for any or all use, and for the term of the Agreement, on the basis of the terms and conditions set forth hereinafter.\n\n   Besides, if the Licensor owns or comes to own one or more patents protecting all or part of the functions of the Software or of its components, the Licensor undertakes not to enforce the rights granted by these patents against successive Licensees using, exploiting or modifying the Software. If these patents are transferred, the Licensor undertakes to have the transferees subscribe to the obligations set forth in this paragraph.\n\n      5.1 RIGHT OF USE\n\n      The Licensee is authorized to use the Software, without any limitation as to its fields of application, with it being hereinafter specified that this comprises:\n\n         1. permanent or temporary reproduction of all or part of the Software by any or all means and in any or all form.\n\n         2. loading, displaying, running, or storing the Software on any or all medium.\n\n         3. entitlement to observe, study or test its operation so as to determine the ideas and principles behind any or all constituent elements of said Software. This shall apply when the Licensee carries out any or all loading, displaying, running, transmission or storage operation as regards the Software, that it is entitled to carry out hereunder.\n\n      5.2 ENTITLEMENT TO MAKE CONTRIBUTIONS\n\n      The right to make Contributions includes the right to translate, adapt, arrange, or make any or all modifications to the Software, and the right to reproduce the resulting software.\n\n      The Licensee is authorized to make any or all Contributions to the Software provided that it includes an explicit notice that it is the author of said Contribution and indicates the date of the creation thereof.\n\n      5.3 RIGHT OF DISTRIBUTION\n\n      In particular, the right of distribution includes the right to publish, transmit and communicate the Software to the general public on any or all medium, and by any or all means, and the right to market, either in consideration of a fee, or free of charge, one or more copies of the Software by any means.\n\n      The Licensee is further authorized to distribute copies of the modified or unmodified Software to third parties according to the terms and conditions set forth hereinafter.\n\n         5.3.1. DISTRIBUTION OF SOFTWARE WITHOUT MODIFICATION\n\n         The Licensee is authorized to distribute true copies of the Software in Source Code or Object Code form, provided that said distribution complies with all the provisions of the Agreement and is accompanied by:\n\n            1. a copy of the Agreement,\n\n            2. a notice relating to the limitation of both the Licensor's warranty and liability as set forth in Articles 8 and 9,\n\n         and that, in the event that only the Object Code of the Software is redistributed, the Licensee allows future Licensees unhindered access to the full Source Code of the Software by indicating how to access it, it being understood that the additional cost of acquiring the Source Code shall not exceed the cost of transferring the data.\n\n         5.3.2. DISTRIBUTION OF MODIFIED SOFTWARE\n\n         When the Licensee makes a Contribution to the Software, the terms and conditions for the distribution of the resulting Modified Software become subject to all the provisions of this Agreement.\n\n         The Licensee is authorized to distribute the Modified Software, in source code or object code form, provided that said distribution complies with all the provisions of the Agreement and is accompanied by:\n\n            1. a copy of the Agreement,\n\n            2. a notice relating to the limitation of both the Licensor's warranty and liability as set forth in Articles 8 and 9,\n\n         and that, in the event that only the object code of the Modified Software is redistributed, the Licensee allows future Licensees unhindered access to the full source code of the Modified Software by indicating how to access it, it being understood that the additional cost of acquiring the source code shall not exceed the cost of transferring the data.\n\n         5.3.3. DISTRIBUTION OF EXTERNAL MODULES\n\n         When the Licensee has developed an External Module, the terms and conditions of this Agreement do not apply to said External Module, that may be distributed under a separate license agreement.\n\n         5.3.4. COMPATIBILITY WITH THE GNU GPL\n\n         The Licensee can include a code that is subject to the provisions of one of the versions of the GNU GPL in the Modified or unmodified Software, and distribute that entire code under the terms of the same version of the GNU GPL.\n\n         The Licensee can include the Modified or unmodified Software in a code that is subject to the provisions of one of the versions of the GNU GPL, and distribute that entire code under the terms of the same version of the GNU GPL.\n\n   Article 6 - INTELLECTUAL PROPERTY\n\n      6.1 OVER THE INITIAL SOFTWARE\n\n      The Holder owns the economic rights over the Initial Software. Any or all use of the Initial Software is subject to compliance with the terms and conditions under which the Holder has elected to distribute its work and no one shall be entitled to modify the terms and conditions for the distribution of said Initial Software.\n\n      The Holder undertakes that the Initial Software will remain ruled at least by this Agreement, for the duration set forth in Article 4.2.\n\n      6.2 OVER THE CONTRIBUTIONS\n\n      The Licensee who develops a Contribution is the owner of the intellectual property rights over this Contribution as defined by applicable law.\n\n      6.3 OVER THE EXTERNAL MODULES\n\n      The Licensee who develops an External Module is the owner of the intellectual property rights over this External Module as defined by applicable law and is free to choose the type of agreement that shall govern its distribution.\n\n      6.4 JOINT PROVISIONS\n\n      The Licensee expressly undertakes:\n\n         1. not to remove, or modify, in any manner, the intellectual property notices attached to the Software;\n\n         2. to reproduce said notices, in an identical manner, in the copies of the Software modified or not.\n\n      The Licensee undertakes not to directly or indirectly infringe the intellectual property rights of the Holder and/or Contributors on the Software and to take, where applicable, vis-à-vis its staff, any and all measures required to ensure respect of said intellectual property rights of the Holder and/or Contributors.\n\n   Article 7 - RELATED SERVICES\n\n      7.1 Under no circumstances shall the Agreement oblige the Licensor to provide technical assistance or maintenance services for the Software.\n\n      However, the Licensor is entitled to offer this type of services. The terms and conditions of such technical assistance, and/or such maintenance, shall be set forth in a separate instrument. Only the Licensor offering said maintenance and/or technical assistance services shall incur liability therefor.\n\n      7.2 Similarly, any Licensor is entitled to offer to its licensees, under its sole responsibility, a warranty, that shall only be binding upon itself, for the redistribution of the Software and/or the Modified Software, under terms and conditions that it is free to decide. Said warranty, and the financial terms and conditions of its application, shall be subject of a separate instrument executed between the Licensor and the Licensee.\n\n   Article 8 - LIABILITY\n\n      8.1 Subject to the provisions of Article 8.2, the Licensee shall be entitled to claim compensation for any direct loss it may have suffered from the Software as a result of a fault on the part of the relevant Licensor, subject to providing evidence thereof.\n\n      8.2 The Licensor's liability is limited to the commitments made under this Agreement and shall not be incurred as a result of in particular: (i) loss due the Licensee's total or partial failure to fulfill its obligations, (ii) direct or consequential loss that is suffered by the Licensee due to the use or performance of the Software, and (iii) more generally, any consequential loss. In particular the Parties expressly agree that any or all pecuniary or business loss (i.e. loss of data, loss of profits, operating loss, loss of customers or orders, opportunity cost, any disturbance to business activities) or any or all legal proceedings instituted against the Licensee by a third party, shall constitute consequential loss and shall not provide entitlement to any or all compensation from the Licensor.\n\n   Article 9 - WARRANTY\n\n      9.1 The Licensee acknowledges that the scientific and technical state-of-the-art when the Software was distributed did not enable all possible uses to be tested and verified, nor for the presence of possible defects to be detected. In this respect, the Licensee's attention has been drawn to the risks associated with loading, using, modifying and/or developing and reproducing the Software which are reserved for experienced users.\n\n      The Licensee shall be responsible for verifying, by any or all means, the suitability of the product for its requirements, its good working order, and for ensuring that it shall not cause damage to either persons or properties.\n\n      9.2 The Licensor hereby represents, in good faith, that it is entitled to grant all the rights over the Software (including in particular the rights set forth in Article 5).\n\n      9.3 The Licensee acknowledges that the Software is supplied \"as is\" by the Licensor without any other express or tacit warranty, other than that provided for in Article 9.2 and, in particular, without any warranty as to its commercial value, its secured, safe, innovative or relevant nature.\n\n      Specifically, the Licensor does not warrant that the Software is free from any error, that it will operate without interruption, that it will be compatible with the Licensee's own equipment and software configuration, nor that it will meet the Licensee's requirements.\n\n      9.4 The Licensor does not either expressly or tacitly warrant that the Software does not infringe any third party intellectual property right relating to a patent, software or any other property right. Therefore, the Licensor disclaims any and all liability towards the Licensee arising out of any or all proceedings for infringement that may be instituted in respect of the use, modification and redistribution of the Software. Nevertheless, should such proceedings be instituted against the Licensee, the Licensor shall provide it with technical and legal assistance for its defense. Such technical and legal assistance shall be decided on a case-by-case basis between the relevant Licensor and the Licensee pursuant to a memorandum of understanding. The Licensor disclaims any and all liability as regards the Licensee's use of the name of the Software. No warranty is given as regards the existence of prior rights over the name of the Software or as regards the existence of a trademark.\n\n   Article 10 - TERMINATION\n\n      10.1 In the event of a breach by the Licensee of its obligations hereunder, the Licensor may automatically terminate this Agreement thirty (30) days after notice has been sent to the Licensee and has remained ineffective.\n\n      10.2 A Licensee whose Agreement is terminated shall no longer be authorized to use, modify or distribute the Software. However, any licenses that it may have granted prior to termination of the Agreement shall remain valid subject to their having been granted in compliance with the terms and conditions hereof.\n\n   Article 11 - MISCELLANEOUS\n\n      11.1 EXCUSABLE EVENTS\n\n      Neither Party shall be liable for any or all delay, or failure to perform the Agreement, that may be attributable to an event of force majeure, an act of God or an outside cause, such as defective functioning or interruptions of the electricity or telecommunications networks, network paralysis following a virus attack, intervention by government authorities, natural disasters, water damage, earthquakes, fire, explosions, strikes and labor unrest, war, etc.\n\n      11.2 Any failure by either Party, on one or more occasions, to invoke one or more of the provisions hereof, shall under no circumstances be interpreted as being a waiver by the interested Party of its right to invoke said provision(s) subsequently.\n\n      11.3 The Agreement cancels and replaces any or all previous agreements, whether written or oral, between the Parties and having the same purpose, and constitutes the entirety of the agreement between said Parties concerning said purpose. No supplement or modification to the terms and conditions hereof shall be effective as between the Parties unless it is made in writing and signed by their duly authorized representatives.\n\n      11.4 In the event that one or more of the provisions hereof were to conflict with a current or future applicable act or legislative text, said act or legislative text shall prevail, and the Parties shall make the necessary amendments so as to comply with said act or legislative text. All other provisions shall remain effective. Similarly, invalidity of a provision of the Agreement, for any reason whatsoever, shall not cause the Agreement as a whole to be invalid.\n\n      11.5 LANGUAGE\n\n      The Agreement is drafted in both French and English and both versions are deemed authentic.\n\n   Article 12 - NEW VERSIONS OF THE AGREEMENT\n\n      12.1 Any person is authorized to duplicate and distribute copies of this Agreement.\n\n      12.2 So as to ensure coherence, the wording of this Agreement is protected and may only be modified by the authors of the License, who reserve the right to periodically publish updates or new versions of the Agreement, each with a separate number. These subsequent versions may address new issues encountered by Free Software.\n\n      12.3 Any Software distributed under a given version of the Agreement may only be subsequently distributed under the same version of the Agreement or a subsequent version, subject to the provisions of Article 5.3.4.\n\n   Article 13 - GOVERNING LAW AND JURISDICTION\n\n      13.1 The Agreement is governed by French law. The Parties agree to endeavor to seek an amicable solution to any disagreements or disputes that may arise during the performance of the Agreement.\n\n      13.2 Failing an amicable solution within two (2) months as from their occurrence, and unless emergency proceedings are necessary, the disagreements or disputes shall be referred to the Paris Courts having jurisdiction, by the more diligent Party.\n\nVersion 2.0 dated 2006-09-05. 1 CeCILL stands for Ce(a) C(nrs) I(nria) L(ogiciel) L(ibre)"],"licenseIds":["CECILL-2.0"],"keywords":["foundation inc parties","inc parties mean","modified software by","gnu gpl in","gpl in the","gpl and distribute","gnu gpl article","party version 2","2 0 dated","software foundation inc parties","foundation inc parties mean","inc parties mean both","the software by indicating","the modified software by","modified software by indicating","compatibility with the gnu","with the gnu gpl","the gnu gpl in","gnu gpl in the","gpl in the modified","gnu gpl and distribute","gpl and distribute that","the gnu gpl article","gnu gpl article 6","gpl article 6 intellectual","diligent party version 2","party version 2 0","version 2 0 dated","2 0 dated 2006","free software foundation inc parties","software foundation inc parties mean","foundation inc parties mean both","inc parties mean both the","code of the software by","of the software by indicating","the software by indicating how","of the modified software by","the modified software by indicating","modified software by indicating how","4 compatibility with the gnu","compatibility with the gnu gpl","with the gnu gpl the","of the gnu gpl in","the gnu gpl in the","gnu gpl in the modified","gpl in the modified or","of the gnu gpl the","the gnu gpl and distribute","gnu gpl and distribute that","gpl and distribute that entire","of the gnu gpl article","the gnu gpl article 6","gnu gpl article 6 intellectual","gpl article 6 intellectual property","more diligent party version 2","diligent party version 2 0","party version 2 0 dated","version 2 0 dated 2006","2 0 dated 2006 09"]},{"licenseTexts":["CeCILL FREE SOFTWARE LICENSE AGREEMENT\n\nVersion 2.1 dated 2013-06-21 Notice\n\nThis Agreement is a Free Software license agreement that is the result of discussions between its authors in order to ensure compliance with the two main principles guiding its drafting:\n\n   * firstly, compliance with the principles governing the distribution of Free Software: access to source code, broad rights granted to users,\n\n   * secondly, the election of a governing law, French law, with which it is conformant, both as regards the law of torts and intellectual property law, and the protection that it offers to both authors and holders of the economic rights over software.\n\nThe authors of the CeCILL¹ license are:\n\n   \n\n   Commissariat à l'énergie atomique et aux énergies alternatives - CEA, a public scientific, technical and industrial research establishment, having its principal place of business at 25 rue Leblanc, immeuble Le Ponant D, 75015 Paris, France.\n\n   \n\n   Centre National de la Recherche Scientifique - CNRS, a public scientific and technological establishment, having its principal place of business at 3 rue Michel-Ange, 75794 Paris cedex 16, France.\n\n   \n\n   Institut National de Recherche en Informatique et en Automatique - Inria, a public scientific and technological establishment, having its principal place of business at Domaine de Voluceau, Rocquencourt, BP 105, 78153 Le Chesnay cedex, France.\n\n   Preamble The purpose of this Free Software license agreement is to grant users the right to modify and redistribute the software governed by this license within the framework of an open source distribution model.\n\n   The exercising of this right is conditional upon certain obligations for users so as to preserve this status for all subsequent redistributions.\n\n   In consideration of access to the source code and the rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors only have limited liability.\n\n   In this respect, the risks associated with loading, using, modifying and/or developing or reproducing the software by the user are brought to the user's attention, given its Free Software status, which may make it complicated to use, with the result that its use is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the suitability of the software as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions of security. This Agreement may be freely reproduced and published, provided it is not altered, and that no provisions are either added or removed herefrom.\n\n   This Agreement may apply to any or all software for which the holder of the economic rights decides to submit the use thereof to its provisions.\n\n   Frequently asked questions can be found on the official website of the CeCILL licenses family (http://www.cecill.info/index.en.html) for any necessary clarification.\n\n   Article 1 - DEFINITIONS\n\n   For the purpose of this Agreement, when the following expressions commence with a capital letter, they shall have the following meaning:\n\n      \n\n      Agreement: means this license agreement, and its possible subsequent versions and annexes.\n\n      \n\n      Software: means the software in its Object Code and/or Source Code form and, where applicable, its documentation, \"as is\" when the Licensee accepts the Agreement.\n\n      \n\n      Initial Software: means the Software in its Source Code and possibly its Object Code form and, where applicable, its documentation, \"as is\" when it is first distributed under the terms and conditions of the Agreement.\n\n      \n\n      Modified Software: means the Software modified by at least one Contribution.\n\n      \n\n      Source Code: means all the Software's instructions and program lines to which access is required so as to modify the Software.\n\n      \n\n      Object Code: means the binary files originating from the compilation of the Source Code.\n\n      \n\n      Holder: means the holder(s) of the economic rights over the Initial Software.\n\n      \n\n      Licensee: means the Software user(s) having accepted the Agreement.\n\n      \n\n      Contributor: means a Licensee having made at least one Contribution.\n\n      \n\n      Licensor: means the Holder, or any other individual or legal entity, who distributes the Software under the Agreement.\n\n      \n\n      Contribution: means any or all modifications, corrections, translations, adaptations and/or new functions integrated into the Software by any or all Contributors, as well as any or all Internal Modules.\n\n      \n\n      Module: means a set of sources files including their documentation that enables supplementary functions or services in addition to those offered by the Software.\n\n      \n\n      External Module: means any or all Modules, not derived from the Software, so that this Module and the Software run in separate address spaces, with one calling the other when they are run.\n\n      \n\n      Internal Module: means any or all Module, connected to the Software so that they both execute in the same address space.\n\n      \n\n      GNU GPL: means the GNU General Public License version 2 or any subsequent version, as published by the Free Software Foundation Inc.\n\n      \n\n      GNU Affero GPL: means the GNU Affero General Public License version 3 or any subsequent version, as published by the Free Software Foundation Inc.\n\n      \n\n      EUPL: means the European Union Public License version 1.1 or any subsequent version, as published by the European Commission.\n\n      \n\n      Parties: mean both the Licensee and the Licensor.\n\n   These expressions may be used both in singular and plural form.\n\n   Article 2 - PURPOSE\n\n   The purpose of the Agreement is the grant by the Licensor to the Licensee of a non-exclusive, transferable and worldwide license for the Software as set forth in Article 5 \u003c#scope\u003e hereinafter for the whole term of the protection granted by the rights over said Software.\n\n   Article 3 - ACCEPTANCE\n\n      3.1 The Licensee shall be deemed as having accepted the terms and conditions of this Agreement upon the occurrence of the first of the following events:\n\n         (i) loading the Software by any or all means, notably, by downloading from a remote server, or by loading from a physical medium;\n\n         (ii) the first time the Licensee exercises any of the rights granted hereunder.\n\n      3.2 One copy of the Agreement, containing a notice relating to the characteristics of the Software, to the limited warranty, and to the fact that its use is restricted to experienced users has been provided to the Licensee prior to its acceptance as set forth in Article 3.1 \u003c#accepting\u003e hereinabove, and the Licensee hereby acknowledges that it has read and understood it.\n\n   Article 4 - EFFECTIVE DATE AND TERM\n\n      4.1 EFFECTIVE DATE\n\n      The Agreement shall become effective on the date when it is accepted by the Licensee as set forth in Article 3.1 \u003c#accepting\u003e .\n\n      4.2 TERM\n\n      The Agreement shall remain in force for the entire legal term of protection of the economic rights over the Software.\n\n   Article 5 - SCOPE OF RIGHTS GRANTED\n\n   The Licensor hereby grants to the Licensee, who accepts, the following rights over the Software for any or all use, and for the term of the Agreement, on the basis of the terms and conditions set forth hereinafter.\n\n   Besides, if the Licensor owns or comes to own one or more patents protecting all or part of the functions of the Software or of its components, the Licensor undertakes not to enforce the rights granted by these patents against successive Licensees using, exploiting or modifying the Software. If these patents are transferred, the Licensor undertakes to have the transferees subscribe to the obligations set forth in this paragraph.\n\n      5.1 RIGHT OF USE\n\n      The Licensee is authorized to use the Software, without any limitation as to its fields of application, with it being hereinafter specified that this comprises:\n\n         1. permanent or temporary reproduction of all or part of the Software by any or all means and in any or all form.\n\n         2. loading, displaying, running, or storing the Software on any or all medium.\n\n         3. entitlement to observe, study or test its operation so as to determine the ideas and principles behind any or all constituent elements of said Software. This shall apply when the Licensee carries out any or all loading, displaying, running, transmission or storage operation as regards the Software, that it is entitled to carry out hereunder.\n\n      5.2 ENTITLEMENT TO MAKE CONTRIBUTIONS\n\n      The right to make Contributions includes the right to translate, adapt, arrange, or make any or all modifications to the Software, and the right to reproduce the resulting software.\n\n      The Licensee is authorized to make any or all Contributions to the Software provided that it includes an explicit notice that it is the author of said Contribution and indicates the date of the creation thereof.\n\n      5.3 RIGHT OF DISTRIBUTION\n\n      In particular, the right of distribution includes the right to publish, transmit and communicate the Software to the general public on any or all medium, and by any or all means, and the right to market, either in consideration of a fee, or free of charge, one or more copies of the Software by any means.\n\n      The Licensee is further authorized to distribute copies of the modified or unmodified Software to third parties according to the terms and conditions set forth hereinafter.\n\n         5.3.1. DISTRIBUTION OF SOFTWARE WITHOUT MODIFICATION\n\n         The Licensee is authorized to distribute true copies of the Software in Source Code or Object Code form, provided that said distribution complies with all the provisions of the Agreement and is accompanied by:\n\n            1. a copy of the Agreement,\n\n            2. a notice relating to the limitation of both the Licensor's warranty and liability as set forth in Articles 8 and 9,\n\n         and that, in the event that only the Object Code of the Software is redistributed, the Licensee allows effective access to the full Source Code of the Software for a period of at least three years from the distribution of the Software, it being understood that the additional acquisition cost of the Source Code shall not exceed the cost of the data transfer.\n\n         5.3.2. DISTRIBUTION OF MODIFIED SOFTWARE\n\n         When the Licensee makes a Contribution to the Software, the terms and conditions for the distribution of the resulting Modified Software become subject to all the provisions of this Agreement.\n\n         The Licensee is authorized to distribute the Modified Software, in source code or object code form, provided that said distribution complies with all the provisions of the Agreement and is accompanied by:\n\n            1. a copy of the Agreement,\n\n            2. a notice relating to the limitation of both the Licensor's warranty and liability as set forth in Articles 8 and 9,\n\n         and, in the event that only the object code of the Modified Software is redistributed,\n\n            3. a note stating the conditions of effective access to the full source code of the Modified Software for a period of at least three years from the distribution of the Modified Software, it being understood that the additional acquisition cost of the source code shall not exceed the cost of the data transfer.\n\n         5.3.3. DISTRIBUTION OF EXTERNAL MODULES\n\n         When the Licensee has developed an External Module, the terms and conditions of this Agreement do not apply to said External Module, that may be distributed under a separate license agreement.\n\n         5.3.4. COMPATIBILITY WITH OTHER LICENSES\n\n         The Licensee can include a code that is subject to the provisions of one of the versions of the GNU GPL, GNU Affero GPL and/or EUPL in the Modified or unmodified Software, and distribute that entire code under the terms of the same version of the GNU GPL, GNU Affero GPL and/or EUPL.\n\n         The Licensee can include the Modified or unmodified Software in a code that is subject to the provisions of one of the versions of the GNU GPL, GNU Affero GPL and/or EUPL and distribute that entire code under the terms of the same version of the GNU GPL, GNU Affero GPL and/or EUPL.\n\n   Article 6 - INTELLECTUAL PROPERTY\n\n      6.1 OVER THE INITIAL SOFTWARE\n\n      The Holder owns the economic rights over the Initial Software. Any or all use of the Initial Software is subject to compliance with the terms and conditions under which the Holder has elected to distribute its work and no one shall be entitled to modify the terms and conditions for the distribution of said Initial Software.\n\n      The Holder undertakes that the Initial Software will remain ruled at least by this Agreement, for the duration set forth in Article 4.2 \u003c#term\u003e .\n\n      6.2 OVER THE CONTRIBUTIONS\n\n      The Licensee who develops a Contribution is the owner of the intellectual property rights over this Contribution as defined by applicable law.\n\n      6.3 OVER THE EXTERNAL MODULES\n\n      The Licensee who develops an External Module is the owner of the intellectual property rights over this External Module as defined by applicable law and is free to choose the type of agreement that shall govern its distribution.\n\n      6.4 JOINT PROVISIONS\n\n      The Licensee expressly undertakes:\n\n         1. not to remove, or modify, in any manner, the intellectual property notices attached to the Software;\n\n         2. to reproduce said notices, in an identical manner, in the copies of the Software modified or not.\n\n      The Licensee undertakes not to directly or indirectly infringe the intellectual property rights on the Software of the Holder and/or Contributors, and to take, where applicable, vis-à-vis its staff, any and all measures required to ensure respect of said intellectual property rights of the Holder and/or Contributors.\n\n   Article 7 - RELATED SERVICES\n\n      7.1 Under no circumstances shall the Agreement oblige the Licensor to provide technical assistance or maintenance services for the Software.\n\n      However, the Licensor is entitled to offer this type of services. The terms and conditions of such technical assistance, and/or such maintenance, shall be set forth in a separate instrument. Only the Licensor offering said maintenance and/or technical assistance services shall incur liability therefor.\n\n      7.2 Similarly, any Licensor is entitled to offer to its licensees, under its sole responsibility, a warranty, that shall only be binding upon itself, for the redistribution of the Software and/or the Modified Software, under terms and conditions that it is free to decide. Said warranty, and the financial terms and conditions of its application, shall be subject of a separate instrument executed between the Licensor and the Licensee.\n\n   Article 8 - LIABILITY\n\n      8.1 Subject to the provisions of Article 8.2, the Licensee shall be entitled to claim compensation for any direct loss it may have suffered from the Software as a result of a fault on the part of the relevant Licensor, subject to providing evidence thereof.\n\n      8.2 The Licensor's liability is limited to the commitments made under this Agreement and shall not be incurred as a result of in particular: (i) loss due the Licensee's total or partial failure to fulfill its obligations, (ii) direct or consequential loss that is suffered by the Licensee due to the use or performance of the Software, and (iii) more generally, any consequential loss. In particular the Parties expressly agree that any or all pecuniary or business loss (i.e. loss of data, loss of profits, operating loss, loss of customers or orders, opportunity cost, any disturbance to business activities) or any or all legal proceedings instituted against the Licensee by a third party, shall constitute consequential loss and shall not provide entitlement to any or all compensation from the Licensor.\n\n   Article 9 - WARRANTY\n\n      9.1 The Licensee acknowledges that the scientific and technical state-of-the-art when the Software was distributed did not enable all possible uses to be tested and verified, nor for the presence of possible defects to be detected. In this respect, the Licensee's attention has been drawn to the risks associated with loading, using, modifying and/or developing and reproducing the Software which are reserved for experienced users.\n\n      The Licensee shall be responsible for verifying, by any or all means, the suitability of the product for its requirements, its good working order, and for ensuring that it shall not cause damage to either persons or properties.\n\n      9.2 The Licensor hereby represents, in good faith, that it is entitled to grant all the rights over the Software (including in particular the rights set forth in Article 5 \u003c#scope\u003e ).\n\n      9.3 The Licensee acknowledges that the Software is supplied \"as is\" by the Licensor without any other express or tacit warranty, other than that provided for in Article 9.2 \u003c#good-faith\u003e and, in particular, without any warranty as to its commercial value, its secured, safe, innovative or relevant nature.\n\n      Specifically, the Licensor does not warrant that the Software is free from any error, that it will operate without interruption, that it will be compatible with the Licensee's own equipment and software configuration, nor that it will meet the Licensee's requirements.\n\n      9.4 The Licensor does not either expressly or tacitly warrant that the Software does not infringe any third party intellectual property right relating to a patent, software or any other property right. Therefore, the Licensor disclaims any and all liability towards the Licensee arising out of any or all proceedings for infringement that may be instituted in respect of the use, modification and redistribution of the Software. Nevertheless, should such proceedings be instituted against the Licensee, the Licensor shall provide it with technical and legal expertise for its defense. Such technical and legal expertise shall be decided on a case-by-case basis between the relevant Licensor and the Licensee pursuant to a memorandum of understanding. The Licensor disclaims any and all liability as regards the Licensee's use of the name of the Software. No warranty is given as regards the existence of prior rights over the name of the Software or as regards the existence of a trademark.\n\n   Article 10 - TERMINATION\n\n      10.1 In the event of a breach by the Licensee of its obligations hereunder, the Licensor may automatically terminate this Agreement thirty (30) days after notice has been sent to the Licensee and has remained ineffective.\n\n      10.2 A Licensee whose Agreement is terminated shall no longer be authorized to use, modify or distribute the Software. However, any licenses that it may have granted prior to termination of the Agreement shall remain valid subject to their having been granted in compliance with the terms and conditions hereof.\n\n   Article 11 - MISCELLANEOUS\n\n      11.1 EXCUSABLE EVENTS\n\n      Neither Party shall be liable for any or all delay, or failure to perform the Agreement, that may be attributable to an event of force majeure, an act of God or an outside cause, such as defective functioning or interruptions of the electricity or telecommunications networks, network paralysis following a virus attack, intervention by government authorities, natural disasters, water damage, earthquakes, fire, explosions, strikes and labor unrest, war, etc.\n\n      11.2 Any failure by either Party, on one or more occasions, to invoke one or more of the provisions hereof, shall under no circumstances be interpreted as being a waiver by the interested Party of its right to invoke said provision(s) subsequently.\n\n      11.3 The Agreement cancels and replaces any or all previous agreements, whether written or oral, between the Parties and having the same purpose, and constitutes the entirety of the agreement between said Parties concerning said purpose. No supplement or modification to the terms and conditions hereof shall be effective as between the Parties unless it is made in writing and signed by their duly authorized representatives.\n\n      11.4 In the event that one or more of the provisions hereof were to conflict with a current or future applicable act or legislative text, said act or legislative text shall prevail, and the Parties shall make the necessary amendments so as to comply with said act or legislative text. All other provisions shall remain effective. Similarly, invalidity of a provision of the Agreement, for any reason whatsoever, shall not cause the Agreement as a whole to be invalid.\n\n      11.5 LANGUAGE\n\n      The Agreement is drafted in both French and English and both versions are deemed authentic.\n\n   Article 12 - NEW VERSIONS OF THE AGREEMENT\n\n      12.1 Any person is authorized to duplicate and distribute copies of this Agreement.\n\n      12.2 So as to ensure coherence, the wording of this Agreement is protected and may only be modified by the authors of the License, who reserve the right to periodically publish updates or new versions of the Agreement, each with a separate number. These subsequent versions may address new issues encountered by Free Software.\n\n      12.3 Any Software distributed under a given version of the Agreement may only be subsequently distributed under the same version of the Agreement or a subsequent version, subject to the provisions of Article 5.3.4 \u003c#compatibility\u003e .\n\n   Article 13 - GOVERNING LAW AND JURISDICTION\n\n      13.1 The Agreement is governed by French law. The Parties agree to endeavor to seek an amicable solution to any disagreements or disputes that may arise during the performance of the Agreement.\n\n      13.2 Failing an amicable solution within two (2) months as from their occurrence, and unless emergency proceedings are necessary, the disagreements or disputes shall be referred to the Paris Courts having jurisdiction, by the more diligent Party. 1 CeCILL stands for Ce(a) C(nrs) I(nria) L(ogiciel) L(ibre)"],"licenseIds":["CECILL-2.1"],"keywords":["agreement version 2","2 1 dated","1 dated 2013","dated 2013 06","2013 06 21","06 21 notice","21 notice this","commissariat l nergie","l nergie atomique","nergie atomique et","atomique et aux","et aux nergies","aux nergies alternatives","nergies alternatives cea","alternatives cea a","its provisions frequently","provisions frequently asked","frequently asked questions","asked questions can","questions can be","be found on","on the official","the official website","official website of","website of the","the cecill licenses","cecill licenses family","licenses family http","family http www","http www cecill","www cecill info","cecill info index","info index en","index en html","en html for","html for any","for any necessary","any necessary clarification","necessary clarification article","clarification article 1","foundation inc gnu","inc gnu affero","affero gpl means","foundation inc eupl","inc eupl means","eupl means the","means the european","european commission parties","commission parties mean","5 scope hereinafter","scope hereinafter for","1 accepting hereinabove","accepting hereinabove and","1 accepting 4","accepting 4 2","9 and in","is redistributed 3","redistributed 3 a","3 a note","a note stating","note stating the","stating the conditions","conditions of effective","of effective access","modified software for","compatibility with other","other licenses the","licenses the licensee","or eupl in","eupl in the","or eupl the","eupl the licensee","or eupl and","eupl and distribute","or eupl article","eupl article 6","2 term 6","term 6 2","property rights on","the software of","5 scope 9","scope 9 3","9 2 good","2 good faith","good faith and","faith and in","legal expertise for","expertise for its","legal expertise shall","expertise shall be","4 compatibility article","compatibility article 13","diligent party 1","party 1 cecill","software license agreement version","license agreement version 2","agreement version 2 1","version 2 1 dated","2 1 dated 2013","1 dated 2013 06","dated 2013 06 21","2013 06 21 notice","06 21 notice this","21 notice this agreement","are commissariat l nergie","commissariat l nergie atomique","l nergie atomique et","nergie atomique et aux","atomique et aux nergies","et aux nergies alternatives","aux nergies alternatives cea","nergies alternatives cea a","alternatives cea a public","to its provisions frequently","its provisions frequently asked","provisions frequently asked questions","frequently asked questions can","asked questions can be","questions can be found","can be found on","be found on the","found on the official","on the official website","the official website of","official website of the","website of the cecill","of the cecill licenses","the cecill licenses family","cecill licenses family http","licenses family http www","family http www cecill","http www cecill info","www cecill info index","cecill info index en","info index en html","index en html for","en html for any","html for any necessary","for any necessary clarification","any necessary clarification article","necessary clarification article 1","clarification article 1 definitions","software foundation inc gnu","foundation inc gnu affero","inc gnu affero gpl","gnu affero gpl means","affero gpl means the","means the gnu affero","version 3 or any","3 or any subsequent","software foundation inc eupl","foundation inc eupl means","inc eupl means the","eupl means the european","means the european union","the european union public","1 or any subsequent","published by the european","the european commission parties","european commission parties mean","commission parties mean both","article 5 scope hereinafter","5 scope hereinafter for","scope hereinafter for the","3 1 accepting hereinabove","1 accepting hereinabove and","accepting hereinabove and the","3 1 accepting 4","1 accepting 4 2","accepting 4 2 term","the software for a","transfer 5 3 2","and 9 and in","9 and in the","software is redistributed 3","is redistributed 3 a","redistributed 3 a note","3 a note stating","a note stating the","note stating the conditions","stating the conditions of","the conditions of effective","conditions of effective access","of effective access to","the modified software for","modified software for a","transfer 5 3 3","4 compatibility with other","compatibility with other licenses","with other licenses the","other licenses the licensee","licenses the licensee can","and or eupl in","or eupl in the","eupl in the modified","and or eupl the","or eupl the licensee","eupl the licensee can","and or eupl and","or eupl and distribute"]},{"licenseTexts":["CeCILL-B FREE SOFTWARE LICENSE AGREEMENT Notice\n\nThis Agreement is a Free Software license agreement that is the result of discussions between its authors in order to ensure compliance with the two main principles guiding its drafting:\n\n   * firstly, compliance with the principles governing the distribution of Free Software: access to source code, broad rights granted to users,\n\n   * secondly, the election of a governing law, French law, with which it is conformant, both as regards the law of torts and intellectual property law, and the protection that it offers to both authors and holders of the economic rights over software.\n\nThe authors of the CeCILL¹ license are:\n\n   \n\n   Commissariat à l'Energie Atomique - CEA, a public scientific, technical and industrial research establishment, having its principal place of business at 25 rue Leblanc, immeuble Le Ponant D, 75015 Paris, France.\n\n   \n\n   Centre National de la Recherche Scientifique - CNRS, a public scientific and technological establishment, having its principal place of business at 3 rue Michel-Ange, 75794 Paris cedex 16, France.\n\n   \n\n   Institut National de Recherche en Informatique et en Automatique - INRIA, a public scientific and technological establishment, having its principal place of business at Domaine de Voluceau, Rocquencourt, BP 105, 78153 Le Chesnay cedex, France.\n\n   Preamble This Agreement is an open source software license intended to give users significant freedom to modify and redistribute the software licensed hereunder.\n\n   The exercising of this freedom is conditional upon a strong obligation of giving credits for everybody that distributes a software incorporating a software ruled by the current license so as all contributions to be properly identified and acknowledged.\n\n   In consideration of access to the source code and the rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors only have limited liability.\n\n   In this respect, the risks associated with loading, using, modifying and/or developing or reproducing the software by the user are brought to the user's attention, given its Free Software status, which may make it complicated to use, with the result that its use is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the suitability of the software as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions of security. This Agreement may be freely reproduced and published, provided it is not altered, and that no provisions are either added or removed herefrom.\n\n   This Agreement may apply to any or all software for which the holder of the economic rights decides to submit the use thereof to its provisions.\n\n   Article 1 - DEFINITIONS\n\n   For the purpose of this Agreement, when the following expressions commence with a capital letter, they shall have the following meaning:\n\n      \n\n      Agreement: means this license agreement, and its possible subsequent versions and annexes.\n\n      \n\n      Software: means the software in its Object Code and/or Source Code form and, where applicable, its documentation, \"as is\" when the Licensee accepts the Agreement.\n\n      \n\n      Initial Software: means the Software in its Source Code and possibly its Object Code form and, where applicable, its documentation, \"as is\" when it is first distributed under the terms and conditions of the Agreement.\n\n      \n\n      Modified Software: means the Software modified by at least one Contribution.\n\n      \n\n      Source Code: means all the Software's instructions and program lines to which access is required so as to modify the Software.\n\n      \n\n      Object Code: means the binary files originating from the compilation of the Source Code.\n\n      \n\n      Holder: means the holder(s) of the economic rights over the Initial Software.\n\n      \n\n      Licensee: means the Software user(s) having accepted the Agreement.\n\n      \n\n      Contributor: means a Licensee having made at least one Contribution.\n\n      \n\n      Licensor: means the Holder, or any other individual or legal entity, who distributes the Software under the Agreement.\n\n      \n\n      Contribution: means any or all modifications, corrections, translations, adaptations and/or new functions integrated into the Software by any or all Contributors, as well as any or all Internal Modules.\n\n      \n\n      Module: means a set of sources files including their documentation that enables supplementary functions or services in addition to those offered by the Software.\n\n      \n\n      External Module: means any or all Modules, not derived from the Software, so that this Module and the Software run in separate address spaces, with one calling the other when they are run.\n\n      \n\n      Internal Module: means any or all Module, connected to the Software so that they both execute in the same address space.\n\n      \n\n      Parties: mean both the Licensee and the Licensor.\n\n   These expressions may be used both in singular and plural form.\n\n   Article 2 - PURPOSE\n\n   The purpose of the Agreement is the grant by the Licensor to the Licensee of a non-exclusive, transferable and worldwide license for the Software as set forth in Article 5 hereinafter for the whole term of the protection granted by the rights over said Software.\n\n   Article 3 - ACCEPTANCE\n\n      3.1 The Licensee shall be deemed as having accepted the terms and conditions of this Agreement upon the occurrence of the first of the following events:\n\n         (i) loading the Software by any or all means, notably, by downloading from a remote server, or by loading from a physical medium;\n\n         (ii) the first time the Licensee exercises any of the rights granted hereunder.\n\n      3.2 One copy of the Agreement, containing a notice relating to the characteristics of the Software, to the limited warranty, and to the fact that its use is restricted to experienced users has been provided to the Licensee prior to its acceptance as set forth in Article 3.1 hereinabove, and the Licensee hereby acknowledges that it has read and understood it.\n\n   Article 4 - EFFECTIVE DATE AND TERM\n\n      4.1 EFFECTIVE DATE\n\n      The Agreement shall become effective on the date when it is accepted by the Licensee as set forth in Article 3.1.\n\n      4.2 TERM\n\n      The Agreement shall remain in force for the entire legal term of protection of the economic rights over the Software.\n\n   Article 5 - SCOPE OF RIGHTS GRANTED\n\n   The Licensor hereby grants to the Licensee, who accepts, the following rights over the Software for any or all use, and for the term of the Agreement, on the basis of the terms and conditions set forth hereinafter.\n\n   Besides, if the Licensor owns or comes to own one or more patents protecting all or part of the functions of the Software or of its components, the Licensor undertakes not to enforce the rights granted by these patents against successive Licensees using, exploiting or modifying the Software. If these patents are transferred, the Licensor undertakes to have the transferees subscribe to the obligations set forth in this paragraph.\n\n      5.1 RIGHT OF USE\n\n      The Licensee is authorized to use the Software, without any limitation as to its fields of application, with it being hereinafter specified that this comprises:\n\n         1. permanent or temporary reproduction of all or part of the Software by any or all means and in any or all form.\n\n         2. loading, displaying, running, or storing the Software on any or all medium.\n\n         3. entitlement to observe, study or test its operation so as to determine the ideas and principles behind any or all constituent elements of said Software. This shall apply when the Licensee carries out any or all loading, displaying, running, transmission or storage operation as regards the Software, that it is entitled to carry out hereunder.\n\n      5.2 ENTITLEMENT TO MAKE CONTRIBUTIONS\n\n      The right to make Contributions includes the right to translate, adapt, arrange, or make any or all modifications to the Software, and the right to reproduce the resulting software.\n\n      The Licensee is authorized to make any or all Contributions to the Software provided that it includes an explicit notice that it is the author of said Contribution and indicates the date of the creation thereof.\n\n      5.3 RIGHT OF DISTRIBUTION\n\n      In particular, the right of distribution includes the right to publish, transmit and communicate the Software to the general public on any or all medium, and by any or all means, and the right to market, either in consideration of a fee, or free of charge, one or more copies of the Software by any means.\n\n      The Licensee is further authorized to distribute copies of the modified or unmodified Software to third parties according to the terms and conditions set forth hereinafter.\n\n         5.3.1. DISTRIBUTION OF SOFTWARE WITHOUT MODIFICATION\n\n         The Licensee is authorized to distribute true copies of the Software in Source Code or Object Code form, provided that said distribution complies with all the provisions of the Agreement and is accompanied by:\n\n            1. a copy of the Agreement,\n\n            2. a notice relating to the limitation of both the Licensor's warranty and liability as set forth in Articles 8 and 9,\n\n         and that, in the event that only the Object Code of the Software is redistributed, the Licensee allows effective access to the full Source Code of the Software at a minimum during the entire period of its distribution of the Software, it being understood that the additional cost of acquiring the Source Code shall not exceed the cost of transferring the data.\n\n         5.3.2. DISTRIBUTION OF MODIFIED SOFTWARE\n\n         If the Licensee makes any Contribution to the Software, the resulting Modified Software may be distributed under a license agreement other than this Agreement subject to compliance with the provisions of Article 5.3.4.\n\n         5.3.3. DISTRIBUTION OF EXTERNAL MODULES\n\n         When the Licensee has developed an External Module, the terms and conditions of this Agreement do not apply to said External Module, that may be distributed under a separate license agreement.\n\n         5.3.4. CREDITS\n\n         Any Licensee who may distribute a Modified Software hereby expressly agrees to:\n\n            1. indicate in the related documentation that it is based on the Software licensed hereunder, and reproduce the intellectual property notice for the Software,\n\n            2. ensure that written indications of the Software intended use, intellectual property notice and license hereunder are included in easily accessible format from the Modified Software interface,\n\n            3. mention, on a freely accessible website describing the Modified Software, at least throughout the distribution term thereof, that it is based on the Software licensed hereunder, and reproduce the Software intellectual property notice,\n\n            4. where it is distributed to a third party that may distribute a Modified Software without having to make its source code available, make its best efforts to ensure that said third party agrees to comply with the obligations set forth in this Article .\n\n         If the Software, whether or not modified, is distributed with an External Module designed for use in connection with the Software, the Licensee shall submit said External Module to the foregoing obligations.\n\n         5.3.5. COMPATIBILITY WITH THE CeCILL AND CeCILL-C LICENSES\n\n         Where a Modified Software contains a Contribution subject to the CeCILL license, the provisions set forth in Article 5.3.4 shall be optional.\n\n         A Modified Software may be distributed under the CeCILL-C license. In such a case the provisions set forth in Article 5.3.4 shall be optional.\n\n   Article 6 - INTELLECTUAL PROPERTY\n\n      6.1 OVER THE INITIAL SOFTWARE\n\n      The Holder owns the economic rights over the Initial Software. Any or all use of the Initial Software is subject to compliance with the terms and conditions under which the Holder has elected to distribute its work and no one shall be entitled to modify the terms and conditions for the distribution of said Initial Software.\n\n      The Holder undertakes that the Initial Software will remain ruled at least by this Agreement, for the duration set forth in Article 4.2.\n\n      6.2 OVER THE CONTRIBUTIONS\n\n      The Licensee who develops a Contribution is the owner of the intellectual property rights over this Contribution as defined by applicable law.\n\n      6.3 OVER THE EXTERNAL MODULES\n\n      The Licensee who develops an External Module is the owner of the intellectual property rights over this External Module as defined by applicable law and is free to choose the type of agreement that shall govern its distribution.\n\n      6.4 JOINT PROVISIONS\n\n      The Licensee expressly undertakes:\n\n         1. not to remove, or modify, in any manner, the intellectual property notices attached to the Software;\n\n         2. to reproduce said notices, in an identical manner, in the copies of the Software modified or not.\n\n      The Licensee undertakes not to directly or indirectly infringe the intellectual property rights of the Holder and/or Contributors on the Software and to take, where applicable, vis-à-vis its staff, any and all measures required to ensure respect of said intellectual property rights of the Holder and/or Contributors.\n\n   Article 7 - RELATED SERVICES\n\n      7.1 Under no circumstances shall the Agreement oblige the Licensor to provide technical assistance or maintenance services for the Software.\n\n      However, the Licensor is entitled to offer this type of services. The terms and conditions of such technical assistance, and/or such maintenance, shall be set forth in a separate instrument. Only the Licensor offering said maintenance and/or technical assistance services shall incur liability therefor.\n\n      7.2 Similarly, any Licensor is entitled to offer to its licensees, under its sole responsibility, a warranty, that shall only be binding upon itself, for the redistribution of the Software and/or the Modified Software, under terms and conditions that it is free to decide. Said warranty, and the financial terms and conditions of its application, shall be subject of a separate instrument executed between the Licensor and the Licensee.\n\n   Article 8 - LIABILITY\n\n      8.1 Subject to the provisions of Article 8.2, the Licensee shall be entitled to claim compensation for any direct loss it may have suffered from the Software as a result of a fault on the part of the relevant Licensor, subject to providing evidence thereof.\n\n      8.2 The Licensor's liability is limited to the commitments made under this Agreement and shall not be incurred as a result of in particular: (i) loss due the Licensee's total or partial failure to fulfill its obligations, (ii) direct or consequential loss that is suffered by the Licensee due to the use or performance of the Software, and (iii) more generally, any consequential loss. In particular the Parties expressly agree that any or all pecuniary or business loss (i.e. loss of data, loss of profits, operating loss, loss of customers or orders, opportunity cost, any disturbance to business activities) or any or all legal proceedings instituted against the Licensee by a third party, shall constitute consequential loss and shall not provide entitlement to any or all compensation from the Licensor.\n\n   Article 9 - WARRANTY\n\n      9.1 The Licensee acknowledges that the scientific and technical state-of-the-art when the Software was distributed did not enable all possible uses to be tested and verified, nor for the presence of possible defects to be detected. In this respect, the Licensee's attention has been drawn to the risks associated with loading, using, modifying and/or developing and reproducing the Software which are reserved for experienced users.\n\n      The Licensee shall be responsible for verifying, by any or all means, the suitability of the product for its requirements, its good working order, and for ensuring that it shall not cause damage to either persons or properties.\n\n      9.2 The Licensor hereby represents, in good faith, that it is entitled to grant all the rights over the Software (including in particular the rights set forth in Article 5).\n\n      9.3 The Licensee acknowledges that the Software is supplied \"as is\" by the Licensor without any other express or tacit warranty, other than that provided for in Article 9.2 and, in particular, without any warranty as to its commercial value, its secured, safe, innovative or relevant nature.\n\n      Specifically, the Licensor does not warrant that the Software is free from any error, that it will operate without interruption, that it will be compatible with the Licensee's own equipment and software configuration, nor that it will meet the Licensee's requirements.\n\n      9.4 The Licensor does not either expressly or tacitly warrant that the Software does not infringe any third party intellectual property right relating to a patent, software or any other property right. Therefore, the Licensor disclaims any and all liability towards the Licensee arising out of any or all proceedings for infringement that may be instituted in respect of the use, modification and redistribution of the Software. Nevertheless, should such proceedings be instituted against the Licensee, the Licensor shall provide it with technical and legal assistance for its defense. Such technical and legal assistance shall be decided on a case-by-case basis between the relevant Licensor and the Licensee pursuant to a memorandum of understanding. The Licensor disclaims any and all liability as regards the Licensee's use of the name of the Software. No warranty is given as regards the existence of prior rights over the name of the Software or as regards the existence of a trademark.\n\n   Article 10 - TERMINATION\n\n      10.1 In the event of a breach by the Licensee of its obligations hereunder, the Licensor may automatically terminate this Agreement thirty (30) days after notice has been sent to the Licensee and has remained ineffective.\n\n      10.2 A Licensee whose Agreement is terminated shall no longer be authorized to use, modify or distribute the Software. However, any licenses that it may have granted prior to termination of the Agreement shall remain valid subject to their having been granted in compliance with the terms and conditions hereof.\n\n   Article 11 - MISCELLANEOUS\n\n      11.1 EXCUSABLE EVENTS\n\n      Neither Party shall be liable for any or all delay, or failure to perform the Agreement, that may be attributable to an event of force majeure, an act of God or an outside cause, such as defective functioning or interruptions of the electricity or telecommunications networks, network paralysis following a virus attack, intervention by government authorities, natural disasters, water damage, earthquakes, fire, explosions, strikes and labor unrest, war, etc.\n\n      11.2 Any failure by either Party, on one or more occasions, to invoke one or more of the provisions hereof, shall under no circumstances be interpreted as being a waiver by the interested Party of its right to invoke said provision(s) subsequently.\n\n      11.3 The Agreement cancels and replaces any or all previous agreements, whether written or oral, between the Parties and having the same purpose, and constitutes the entirety of the agreement between said Parties concerning said purpose. No supplement or modification to the terms and conditions hereof shall be effective as between the Parties unless it is made in writing and signed by their duly authorized representatives.\n\n      11.4 In the event that one or more of the provisions hereof were to conflict with a current or future applicable act or legislative text, said act or legislative text shall prevail, and the Parties shall make the necessary amendments so as to comply with said act or legislative text. All other provisions shall remain effective. Similarly, invalidity of a provision of the Agreement, for any reason whatsoever, shall not cause the Agreement as a whole to be invalid.\n\n      11.5 LANGUAGE\n\n      The Agreement is drafted in both French and English and both versions are deemed authentic.\n\n   Article 12 - NEW VERSIONS OF THE AGREEMENT\n\n      12.1 Any person is authorized to duplicate and distribute copies of this Agreement.\n\n      12.2 So as to ensure coherence, the wording of this Agreement is protected and may only be modified by the authors of the License, who reserve the right to periodically publish updates or new versions of the Agreement, each with a separate number. These subsequent versions may address new issues encountered by Free Software.\n\n      12.3 Any Software distributed under a given version of the Agreement may only be subsequently distributed under the same version of the Agreement or a subsequent version.\n\n   Article 13 - GOVERNING LAW AND JURISDICTION\n\n      13.1 The Agreement is governed by French law. The Parties agree to endeavor to seek an amicable solution to any disagreements or disputes that may arise during the performance of the Agreement.\n\n      13.2 Failing an amicable solution within two (2) months as from their occurrence, and unless emergency proceedings are necessary, the disagreements or disputes shall be referred to the Paris Courts having jurisdiction, by the more diligent Party.\n\nVersion 1.0 dated 2006-09-05. 1 CeCILL stands for Ce(a) C(nrs) I(nria) L(ogiciel) L(ibre)"],"licenseIds":["CECILL-B"],"keywords":["cecill b free","b free software","france preamble this","preamble this agreement","agreement is an","is an open","source software license","software license intended","license intended to","to give users","give users significant","users significant freedom","significant freedom to","freedom to modify","licensed hereunder the","hereunder the exercising","of this freedom","this freedom is","freedom is conditional","conditional upon a","upon a strong","a strong obligation","strong obligation of","obligation of giving","of giving credits","giving credits for","credits for everybody","for everybody that","everybody that distributes","that distributes a","distributes a software","a software incorporating","software incorporating a","incorporating a software","a software ruled","software ruled by","ruled by the","the current license","current license so","license so as","so as all","as all contributions","contributions to be","to be properly","be properly identified","properly identified and","identified and acknowledged","and acknowledged in","acknowledged in consideration","address space parties","space parties mean","modified software if","licensee makes any","makes any contribution","any contribution to","software the resulting","4 5 3","3 4 credits","4 credits any","credits any licensee","any licensee who","licensee who may","modified software hereby","software hereby expressly","hereby expressly agrees","expressly agrees to","agrees to 1","to 1 indicate","1 indicate in","indicate in the","in the related","the related documentation","related documentation that","documentation that it","reproduce the intellectual","property notice for","software 2 ensure","2 ensure that","ensure that written","that written indications","written indications of","indications of the","software intended use","intended use intellectual","use intellectual property","property notice and","and license hereunder","license hereunder are","hereunder are included","included in easily","in easily accessible","easily accessible format","accessible format from","format from the","modified software interface","software interface 3","interface 3 mention","3 mention on","mention on a","on a freely","freely accessible website","accessible website describing","website describing the","software at least","at least throughout","least throughout the","throughout the distribution","the distribution term","distribution term thereof","term thereof that","thereof that it","reproduce the software","the software intellectual","software intellectual property","property notice 4","notice 4 where","4 where it","distributed to a","party that may","that may distribute","modified software without","software without having","having to make","to make its","make its source","code available make","available make its","make its best","its best efforts","best efforts to","efforts to ensure","ensure that said","that said third","said third party","third party agrees","party agrees to","agrees to comply","with the obligations","in this article","this article if","article if the","the software whether","software whether or","or not modified","not modified is","modified is distributed","distributed with an","with an external","external module designed","module designed for","licensee shall submit","shall submit said","submit said external","external module to","module to the","the foregoing obligations","foregoing obligations 5","obligations 5 3","5 3 5","3 5 compatibility","5 compatibility with","the cecill and","cecill and cecill","and cecill c","cecill c licenses","c licenses where","licenses where a","where a modified","contains a contribution","a contribution subject","cecill license the","be optional a","optional a modified","under the cecill","the cecill c","cecill c license","c license in","be optional article","cecill b free software","b free software license","cedex france preamble this","france preamble this agreement","preamble this agreement is","this agreement is an","agreement is an open","is an open source","an open source software","open source software license","source software license intended","software license intended to","license intended to give","intended to give users","to give users significant","give users significant freedom","users significant freedom to","significant freedom to modify","freedom to modify and","redistribute the software licensed","software licensed hereunder the","licensed hereunder the exercising"]},{"licenseTexts":["CeCILL-C FREE SOFTWARE LICENSE AGREEMENT Notice\n\nThis Agreement is a Free Software license agreement that is the result of discussions between its authors in order to ensure compliance with the two main principles guiding its drafting:\n\n   * firstly, compliance with the principles governing the distribution of Free Software: access to source code, broad rights granted to users,\n\n   * secondly, the election of a governing law, French law, with which it is conformant, both as regards the law of torts and intellectual property law, and the protection that it offers to both authors and holders of the economic rights over software.\n\nThe authors of the CeCILL¹ license are:\n\n   \n\n   Commissariat à l'Energie Atomique - CEA, a public scientific, technical and industrial research establishment, having its principal place of business at 25 rue Leblanc, immeuble Le Ponant D, 75015 Paris, France.\n\n   \n\n   Centre National de la Recherche Scientifique - CNRS, a public scientific and technological establishment, having its principal place of business at 3 rue Michel-Ange, 75794 Paris cedex 16, France.\n\n   \n\n   Institut National de Recherche en Informatique et en Automatique - INRIA, a public scientific and technological establishment, having its principal place of business at Domaine de Voluceau, Rocquencourt, BP 105, 78153 Le Chesnay cedex, France.\n\n   Preamble The purpose of this Free Software license agreement is to grant users the right to modify and re-use the software governed by this license.\n\n   The exercising of this right is conditional upon the obligation to make available to the community the modifications made to the source code of the software so as to contribute to its evolution.\n\n   In consideration of access to the source code and the rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors only have limited liability.\n\n   In this respect, the risks associated with loading, using, modifying and/or developing or reproducing the software by the user are brought to the user's attention, given its Free Software status, which may make it complicated to use, with the result that its use is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the suitability of the software as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions of security. This Agreement may be freely reproduced and published, provided it is not altered, and that no provisions are either added or removed herefrom.\n\n   This Agreement may apply to any or all software for which the holder of the economic rights decides to submit the use thereof to its provisions.\n\n   Article 1 - DEFINITIONS\n\n   For the purpose of this Agreement, when the following expressions commence with a capital letter, they shall have the following meaning:\n\n      \n\n      Agreement: means this license agreement, and its possible subsequent versions and annexes.\n\n      \n\n      Software: means the software in its Object Code and/or Source Code form and, where applicable, its documentation, \"as is\" when the Licensee accepts the Agreement.\n\n      \n\n      Initial Software: means the Software in its Source Code and possibly its Object Code form and, where applicable, its documentation, \"as is\" when it is first distributed under the terms and conditions of the Agreement.\n\n      \n\n      Modified Software: means the Software modified by at least one Integrated Contribution.\n\n      \n\n      Source Code: means all the Software's instructions and program lines to which access is required so as to modify the Software.\n\n      \n\n      Object Code: means the binary files originating from the compilation of the Source Code.\n\n      \n\n      Holder: means the holder(s) of the economic rights over the Initial Software.\n\n      \n\n      Licensee: means the Software user(s) having accepted the Agreement.\n\n      \n\n      Contributor: means a Licensee having made at least one Integrated Contribution.\n\n      \n\n      Licensor: means the Holder, or any other individual or legal entity, who distributes the Software under the Agreement.\n\n      \n\n      Integrated Contribution: means any or all modifications, corrections, translations, adaptations and/or new functions integrated into the Source Code by any or all Contributors.\n\n      \n\n      Related Module: means a set of sources files including their documentation that, without modification to the Source Code, enables supplementary functions or services in addition to those offered by the Software.\n\n      \n\n      Derivative Software: means any combination of the Software, modified or not, and of a Related Module.\n\n      \n\n      Parties: mean both the Licensee and the Licensor.\n\n   These expressions may be used both in singular and plural form.\n\n   Article 2 - PURPOSE\n\n   The purpose of the Agreement is the grant by the Licensor to the Licensee of a non-exclusive, transferable and worldwide license for the Software as set forth in Article 5 hereinafter for the whole term of the protection granted by the rights over said Software.\n\n   Article 3 - ACCEPTANCE\n\n      3.1 The Licensee shall be deemed as having accepted the terms and conditions of this Agreement upon the occurrence of the first of the following events:\n\n         (i) loading the Software by any or all means, notably, by downloading from a remote server, or by loading from a physical medium;\n\n         (ii) the first time the Licensee exercises any of the rights granted hereunder.\n\n      3.2 One copy of the Agreement, containing a notice relating to the characteristics of the Software, to the limited warranty, and to the fact that its use is restricted to experienced users has been provided to the Licensee prior to its acceptance as set forth in Article 3.1 hereinabove, and the Licensee hereby acknowledges that it has read and understood it.\n\n   Article 4 - EFFECTIVE DATE AND TERM\n\n      4.1 EFFECTIVE DATE\n\n      The Agreement shall become effective on the date when it is accepted by the Licensee as set forth in Article 3.1.\n\n      4.2 TERM\n\n      The Agreement shall remain in force for the entire legal term of protection of the economic rights over the Software.\n\n   Article 5 - SCOPE OF RIGHTS GRANTED\n\n   The Licensor hereby grants to the Licensee, who accepts, the following rights over the Software for any or all use, and for the term of the Agreement, on the basis of the terms and conditions set forth hereinafter.\n\n   Besides, if the Licensor owns or comes to own one or more patents protecting all or part of the functions of the Software or of its components, the Licensor undertakes not to enforce the rights granted by these patents against successive Licensees using, exploiting or modifying the Software. If these patents are transferred, the Licensor undertakes to have the transferees subscribe to the obligations set forth in this paragraph.\n\n      5.1 RIGHT OF USE\n\n      The Licensee is authorized to use the Software, without any limitation as to its fields of application, with it being hereinafter specified that this comprises:\n\n         1. permanent or temporary reproduction of all or part of the Software by any or all means and in any or all form.\n\n         2. loading, displaying, running, or storing the Software on any or all medium.\n\n         3. entitlement to observe, study or test its operation so as to determine the ideas and principles behind any or all constituent elements of said Software. This shall apply when the Licensee carries out any or all loading, displaying, running, transmission or storage operation as regards the Software, that it is entitled to carry out hereunder.\n\n      5.2 RIGHT OF MODIFICATION\n\n      The right of modification includes the right to translate, adapt, arrange, or make any or all modifications to the Software, and the right to reproduce the resulting software. It includes, in particular, the right to create a Derivative Software.\n\n      The Licensee is authorized to make any or all modification to the Software provided that it includes an explicit notice that it is the author of said modification and indicates the date of the creation thereof.\n\n      5.3 RIGHT OF DISTRIBUTION\n\n      In particular, the right of distribution includes the right to publish, transmit and communicate the Software to the general public on any or all medium, and by any or all means, and the right to market, either in consideration of a fee, or free of charge, one or more copies of the Software by any means.\n\n      The Licensee is further authorized to distribute copies of the modified or unmodified Software to third parties according to the terms and conditions set forth hereinafter.\n\n         5.3.1. DISTRIBUTION OF SOFTWARE WITHOUT MODIFICATION\n\n         The Licensee is authorized to distribute true copies of the Software in Source Code or Object Code form, provided that said distribution complies with all the provisions of the Agreement and is accompanied by:\n\n            1. a copy of the Agreement,\n\n            2. a notice relating to the limitation of both the Licensor's warranty and liability as set forth in Articles 8 and 9,\n\n         and that, in the event that only the Object Code of the Software is redistributed, the Licensee allows effective access to the full Source Code of the Software at a minimum during the entire period of its distribution of the Software, it being understood that the additional cost of acquiring the Source Code shall not exceed the cost of transferring the data.\n\n         5.3.2. DISTRIBUTION OF MODIFIED SOFTWARE\n\n         When the Licensee makes an Integrated Contribution to the Software, the terms and conditions for the distribution of the resulting Modified Software become subject to all the provisions of this Agreement.\n\n         The Licensee is authorized to distribute the Modified Software, in source code or object code form, provided that said distribution complies with all the provisions of the Agreement and is accompanied by:\n\n            1. a copy of the Agreement,\n\n            2. a notice relating to the limitation of both the Licensor's warranty and liability as set forth in Articles 8 and 9,\n\n         and that, in the event that only the object code of the Modified Software is redistributed, the Licensee allows effective access to the full source code of the Modified Software at a minimum during the entire period of its distribution of the Modified Software, it being understood that the additional cost of acquiring the source code shall not exceed the cost of transferring the data.\n\n         5.3.3. DISTRIBUTION OF DERIVATIVE SOFTWARE\n\n         When the Licensee creates Derivative Software, this Derivative Software may be distributed under a license agreement other than this Agreement, subject to compliance with the requirement to include a notice concerning the rights over the Software as defined in Article 6.4. In the event the creation of the Derivative Software required modification of the Source Code, the Licensee undertakes that:\n\n            1. the resulting Modified Software will be governed by this Agreement,\n\n            2. the Integrated Contributions in the resulting Modified Software will be clearly identified and documented,\n\n            3. the Licensee will allow effective access to the source code of the Modified Software, at a minimum during the entire period of distribution of the Derivative Software, such that such modifications may be carried over in a subsequent version of the Software; it being understood that the additional cost of purchasing the source code of the Modified Software shall not exceed the cost of transferring the data.\n\n         5.3.4. COMPATIBILITY WITH THE CeCILL LICENSE\n\n         When a Modified Software contains an Integrated Contribution subject to the CeCILL license agreement, or when a Derivative Software contains a Related Module subject to the CeCILL license agreement, the provisions set forth in the third item of Article 6.4 are optional.\n\n   Article 6 - INTELLECTUAL PROPERTY\n\n      6.1 OVER THE INITIAL SOFTWARE\n\n      The Holder owns the economic rights over the Initial Software. Any or all use of the Initial Software is subject to compliance with the terms and conditions under which the Holder has elected to distribute its work and no one shall be entitled to modify the terms and conditions for the distribution of said Initial Software.\n\n      The Holder undertakes that the Initial Software will remain ruled at least by this Agreement, for the duration set forth in Article 4.2.\n\n      6.2 OVER THE INTEGRATED CONTRIBUTIONS\n\n      The Licensee who develops an Integrated Contribution is the owner of the intellectual property rights over this Contribution as defined by applicable law.\n\n      6.3 OVER THE RELATED MODULES\n\n      The Licensee who develops a Related Module is the owner of the intellectual property rights over this Related Module as defined by applicable law and is free to choose the type of agreement that shall govern its distribution under the conditions defined in Article 5.3.3.\n\n      6.4 NOTICE OF RIGHTS\n\n      The Licensee expressly undertakes:\n\n         1. not to remove, or modify, in any manner, the intellectual property notices attached to the Software;\n\n         2. to reproduce said notices, in an identical manner, in the copies of the Software modified or not;\n\n         3. to ensure that use of the Software, its intellectual property notices and the fact that it is governed by the Agreement is indicated in a text that is easily accessible, specifically from the interface of any Derivative Software.\n\n      The Licensee undertakes not to directly or indirectly infringe the intellectual property rights of the Holder and/or Contributors on the Software and to take, where applicable, vis-à-vis its staff, any and all measures required to ensure respect of said intellectual property rights of the Holder and/or Contributors.\n\n   Article 7 - RELATED SERVICES\n\n      7.1 Under no circumstances shall the Agreement oblige the Licensor to provide technical assistance or maintenance services for the Software.\n\n      However, the Licensor is entitled to offer this type of services. The terms and conditions of such technical assistance, and/or such maintenance, shall be set forth in a separate instrument. Only the Licensor offering said maintenance and/or technical assistance services shall incur liability therefor.\n\n      7.2 Similarly, any Licensor is entitled to offer to its licensees, under its sole responsibility, a warranty, that shall only be binding upon itself, for the redistribution of the Software and/or the Modified Software, under terms and conditions that it is free to decide. Said warranty, and the financial terms and conditions of its application, shall be subject of a separate instrument executed between the Licensor and the Licensee.\n\n   Article 8 - LIABILITY\n\n      8.1 Subject to the provisions of Article 8.2, the Licensee shall be entitled to claim compensation for any direct loss it may have suffered from the Software as a result of a fault on the part of the relevant Licensor, subject to providing evidence thereof.\n\n      8.2 The Licensor's liability is limited to the commitments made under this Agreement and shall not be incurred as a result of in particular: (i) loss due the Licensee's total or partial failure to fulfill its obligations, (ii) direct or consequential loss that is suffered by the Licensee due to the use or performance of the Software, and (iii) more generally, any consequential loss. In particular the Parties expressly agree that any or all pecuniary or business loss (i.e. loss of data, loss of profits, operating loss, loss of customers or orders, opportunity cost, any disturbance to business activities) or any or all legal proceedings instituted against the Licensee by a third party, shall constitute consequential loss and shall not provide entitlement to any or all compensation from the Licensor.\n\n   Article 9 - WARRANTY\n\n      9.1 The Licensee acknowledges that the scientific and technical state-of-the-art when the Software was distributed did not enable all possible uses to be tested and verified, nor for the presence of possible defects to be detected. In this respect, the Licensee's attention has been drawn to the risks associated with loading, using, modifying and/or developing and reproducing the Software which are reserved for experienced users.\n\n      The Licensee shall be responsible for verifying, by any or all means, the suitability of the product for its requirements, its good working order, and for ensuring that it shall not cause damage to either persons or properties.\n\n      9.2 The Licensor hereby represents, in good faith, that it is entitled to grant all the rights over the Software (including in particular the rights set forth in Article 5).\n\n      9.3 The Licensee acknowledges that the Software is supplied \"as is\" by the Licensor without any other express or tacit warranty, other than that provided for in Article 9.2 and, in particular, without any warranty as to its commercial value, its secured, safe, innovative or relevant nature.\n\n      Specifically, the Licensor does not warrant that the Software is free from any error, that it will operate without interruption, that it will be compatible with the Licensee's own equipment and software configuration, nor that it will meet the Licensee's requirements.\n\n      9.4 The Licensor does not either expressly or tacitly warrant that the Software does not infringe any third party intellectual property right relating to a patent, software or any other property right. Therefore, the Licensor disclaims any and all liability towards the Licensee arising out of any or all proceedings for infringement that may be instituted in respect of the use, modification and redistribution of the Software. Nevertheless, should such proceedings be instituted against the Licensee, the Licensor shall provide it with technical and legal assistance for its defense. Such technical and legal assistance shall be decided on a case-by-case basis between the relevant Licensor and the Licensee pursuant to a memorandum of understanding. The Licensor disclaims any and all liability as regards the Licensee's use of the name of the Software. No warranty is given as regards the existence of prior rights over the name of the Software or as regards the existence of a trademark.\n\n   Article 10 - TERMINATION\n\n      10.1 In the event of a breach by the Licensee of its obligations hereunder, the Licensor may automatically terminate this Agreement thirty (30) days after notice has been sent to the Licensee and has remained ineffective.\n\n      10.2 A Licensee whose Agreement is terminated shall no longer be authorized to use, modify or distribute the Software. However, any licenses that it may have granted prior to termination of the Agreement shall remain valid subject to their having been granted in compliance with the terms and conditions hereof.\n\n   Article 11 - MISCELLANEOUS\n\n      11.1 EXCUSABLE EVENTS\n\n      Neither Party shall be liable for any or all delay, or failure to perform the Agreement, that may be attributable to an event of force majeure, an act of God or an outside cause, such as defective functioning or interruptions of the electricity or telecommunications networks, network paralysis following a virus attack, intervention by government authorities, natural disasters, water damage, earthquakes, fire, explosions, strikes and labor unrest, war, etc.\n\n      11.2 Any failure by either Party, on one or more occasions, to invoke one or more of the provisions hereof, shall under no circumstances be interpreted as being a waiver by the interested Party of its right to invoke said provision(s) subsequently.\n\n      11.3 The Agreement cancels and replaces any or all previous agreements, whether written or oral, between the Parties and having the same purpose, and constitutes the entirety of the agreement between said Parties concerning said purpose. No supplement or modification to the terms and conditions hereof shall be effective as between the Parties unless it is made in writing and signed by their duly authorized representatives.\n\n      11.4 In the event that one or more of the provisions hereof were to conflict with a current or future applicable act or legislative text, said act or legislative text shall prevail, and the Parties shall make the necessary amendments so as to comply with said act or legislative text. All other provisions shall remain effective. Similarly, invalidity of a provision of the Agreement, for any reason whatsoever, shall not cause the Agreement as a whole to be invalid.\n\n      11.5 LANGUAGE\n\n      The Agreement is drafted in both French and English and both versions are deemed authentic.\n\n   Article 12 - NEW VERSIONS OF THE AGREEMENT\n\n      12.1 Any person is authorized to duplicate and distribute copies of this Agreement.\n\n      12.2 So as to ensure coherence, the wording of this Agreement is protected and may only be modified by the authors of the License, who reserve the right to periodically publish updates or new versions of the Agreement, each with a separate number. These subsequent versions may address new issues encountered by Free Software.\n\n      12.3 Any Software distributed under a given version of the Agreement may only be subsequently distributed under the same version of the Agreement or a subsequent version.\n\n   Article 13 - GOVERNING LAW AND JURISDICTION\n\n      13.1 The Agreement is governed by French law. The Parties agree to endeavor to seek an amicable solution to any disagreements or disputes that may arise during the performance of the Agreement.\n\n      13.2 Failing an amicable solution within two (2) months as from their occurrence, and unless emergency proceedings are necessary, the disagreements or disputes shall be referred to the Paris Courts having jurisdiction, by the more diligent Party.\n\nVersion 1.0 dated 2006-09-05. 1 CeCILL stands for Ce(a) C(nrs) I(nria) L(ogiciel) L(ibre)"],"licenseIds":["CECILL-C"],"keywords":["cecill c free","c free software","modify and re","license the exercising","conditional upon the","upon the obligation","obligation to make","the community the","community the modifications","software so as","as to contribute","to contribute to","contribute to its","to its evolution","its evolution in","evolution in consideration","integrated contribution source","integrated contribution licensor","the agreement integrated","agreement integrated contribution","integrated contribution means","code by any","all contributors related","contributors related module","related module means","documentation that without","that without modification","without modification to","source code enables","code enables supplementary","software derivative software","derivative software means","means any combination","or not and","not and of","and of a","of a related","related module parties","module parties mean","5 2 right","2 right of","of modification the","modification the right","of modification includes","modification includes the","resulting software it","software it includes","it includes in","includes in particular","of said modification","said modification and","modification and indicates","licensee makes an","makes an integrated","integrated contribution to","of derivative software","derivative software when","the licensee creates","licensee creates derivative","creates derivative software","derivative software this","software this derivative","this derivative software","derivative software may","with the requirement","requirement to include","a notice concerning","notice concerning the","concerning the rights","the event the","event the creation","derivative software required","software required modification","required modification of","code the licensee","licensee undertakes that","undertakes that 1","1 the resulting","2 the integrated","integrated contributions in","contributions in the","in the resulting","will be clearly","clearly identified and","identified and documented","and documented 3","documented 3 the","licensee will allow","will allow effective","allow effective access","period of distribution","derivative software such","software such that","such that such","such modifications may","may be carried","be carried over","carried over in","over in a","in a subsequent","cost of purchasing","of purchasing the","purchasing the source","cecill license when","license when a","when a modified","software contains an","contains an integrated","integrated contribution subject","license agreement or","agreement or when","or when a","when a derivative","derivative software contains","contains a related","related module subject","module subject to","agreement the provisions","in the third","the third item","third item of","item of article","of article 6","6 4 are","4 are optional","are optional article","over the integrated","integrated contributions the","develops an integrated","integrated contribution is","over the related","the related modules","related modules the","develops a related","related module is","over this related","this related module","related module as","its distribution under","the conditions defined","conditions defined in","3 3 6","3 6 4","6 4 notice","4 notice of","notice of rights","of rights the","rights the licensee","or not 3","not 3 to","3 to ensure","ensure that use","software its intellectual","property notices and","and the fact","fact that it","by the agreement","agreement is indicated","is indicated in","indicated in a","a text that","text that is","that is easily","is easily accessible","easily accessible specifically","accessible specifically from","specifically from the","from the interface","the interface of","interface of any","any derivative software","cecill c free software","c free software license","to modify and re","modify and re use","re use the software","use the software governed","this license the exercising","license the exercising of","is conditional upon the","conditional upon the obligation","upon the obligation to","the obligation to make","obligation to make available","to the community the","the community the modifications","community the modifications made","made to the source","the software so as","software so as to","so as to contribute","as to contribute to","to contribute to its","contribute to its evolution","to its evolution in","its evolution in consideration","evolution in consideration of","one integrated contribution source","integrated contribution source code","one integrated contribution licensor"]},{"licenseTexts":["CERN OHL v1.1\n\n2011-07-08 - CERN, Geneva, Switzerland\n\nCERN Open Hardware Licence v1.1\n\nPreamble\n\nThrough this CERN Open Hardware Licence (\"CERN OHL\") version 1.1, the Organization wishes to disseminate its hardware designs (as published on http://www.ohwr.org/) as widely as possible, and generally to foster collaboration among public research hardware designers. The CERN OHL is copyright of CERN. Anyone is welcome to use the CERN OHL, in unmodified form only, for the distribution of his own Open Hardware designs. Any other right is reserved.\n\n1. Definitions\n\nIn this Licence, the following terms have the following meanings:\n\n\"Licence\" means this CERN OHL.\n\n\"Documentation\" means schematic diagrams, designs, circuit or circuit board layouts, mechanical drawings, flow charts and descriptive text, and other explanatory material that is explicitly stated as being made available under the conditions of this Licence. The Documentation may be in any medium, including but not limited to computer files and representations on paper, film, or any other media.\n\n\"Product\" means either an entire, or any part of a, device built using the Documentation or the modified Documentation.\n\n\"Licensee\" means any natural or legal person exercising rights under this Licence.\n\n\"Licensor\" means any natural or legal person that creates or modifies Documentation and subsequently communicates to the public and/ or distributes the resulting Documentation under the terms and conditions of this Licence.\n\nA Licensee may at the same time be a Licensor, and vice versa.\n\n\n\n2. Applicability\n\n   2.1 This Licence governs the use, copying, modification, communication to the public and distribution of the Documentation, and the manufacture and distribution of Products. By exercising any right granted under this Licence, the Licensee irrevocably accepts these terms and conditions.\n\n   2.2 This Licence is granted by the Licensor directly to the Licensee, and shall apply worldwide and without limitation in time. The Licensee may assign his licence rights or grant sub-licences.\n\n   2.3 This Licence does not apply to software, firmware, or code loaded into programmable devices which may be used in conjunction with the Documentation, the modified Documentation or with Products. The use of such software, firmware, or code is subject to the applicable licence terms and conditions.\n\n3. Copying, modification, communication to the public and distribution of the Documentation\n\n   3.1 The Licensee shall keep intact all copyright and trademarks notices and all notices that refer to this Licence and to the disclaimer of warranties that is included in the Documentation. He shall include a copy thereof in every copy of the documentation or, as the case may be, modified Documentation, that he communicates to the public or distributes.\n\n   3.2 The Licensee may use, copy, communicate to the public and distribute verbatim copies of the Documentation, in any medium, subject to the requirements specified in section 3.1.\n\n   3.3 The Licensee may modify the Documentation or any portion thereof. The Licensee may communicate to the public and distribute the modified Documentation (thereby in addition to being a Licensee also becoming a Licensor), always provided that he shall:\n\n      a. comply with section 3.1;\n\n      b. cause the modified Documentation to carry prominent notices stating that the Licensee has modified the Documentation, with the date and details of the modifications;\n\n      c. license the modified Documentation under the terms and conditions of this Licence or, where applicable, a later version of this Licence as may be issued by CERN; and\n\n      d. send a copy of the modified Documentation to all Licensors that contributed to the parts of the Documentation that were modified, as well as to any other Licensor who has requested to receive a copy of the modified Documentation and has provided a means of contact with the Documentation.\n\n   3.4 The Licence includes a licence to those patents or registered designs that are held by the Licensor, to the extent necessary to make use of the rights granted under this Licence. The scope of this section 3.4 shall be strictly limited to the parts of the Documentation or modified Documentation created by the Licensor.\n\n4. Manufacture and distribution of Products\n\n   4.1 The Licensee may manufacture or distribute Products always provided that the Licensee distributes to each recipient of such Products a copy of the Documentation or modified Documentation, as applicable, and complies with section 3.\n\n   4.2 The Licensee is invited to inform in writing any Licensor who has indicated its wish to receive this information about the type, quantity and dates of production of Products the Licensee has (had) manufactured.\n\n5. Warranty and liability\n\n   5.1 DISCLAIMER – The Documentation and any modified Documentation are provided \"as is\" and any express or implied warranties, including, but not limited to, implied warranties of merchantability, of satisfactory quality, and fitness for a particular purpose or use are disclaimed in respect of the Documentation, the modified Documentation or any Product. The Licensor makes no representation that the Documentation, modified Documentation, or any Product, does or will not infringe any patent, copyright, trade secret or other proprietary right. The entire risk as to the use, quality, and performance of a Product shall be with the Licensee and not the Licensor. This disclaimer of warranty is an essential part of this Licence and a condition for the grant of any rights granted under this Licence. The Licensee warrants that it does not act in a consumer capacity.\n\n   5.2 LIMITATION OF LIABILITY – The Licensor shall have no liability for direct, indirect, special, incidental, consequential, exemplary, punitive or other damages of any character including, without limitation, procurement of substitute goods or services, loss of use, data or profits, or business interruption, however caused and on any theory of contract, warranty, tort (including negligence), product liability or otherwise, arising in any way in relation to the Documentation, modified Documentation and/or the use, manufacture or distribution of a Product, even if advised of the possibility of such damages, and the Licensee shall hold the Licensor(s) free and harmless from any liability, costs, damages, fees and expenses, including claims by third parties, in relation to such use.\n\n6. General\n\n   6.1 The rights granted under this Licence do not imply or represent any transfer or assignment of intellectual property rights to the Licensee.\n\n   6.2 The Licensee shall not use or make reference to any of the names, acronyms, images or logos under which the Licensor is known, save in so far as required to comply with section 3. Any such permitted use or reference shall be factual and shall in no event suggest any kind of endorsement by the Licensor or its personnel of the modified Documentation or any Product, or any kind of implication by the Licensor or its personnel in the preparation of the modified Documentation or Product.\n\n   6.3 CERN may publish updated versions of this Licence which retain the same general provisions as this version, but differ in detail so far this is required and reasonable. New versions will be published with a unique version number.\n\n   6.4 This Licence shall terminate with immediate effect, upon written notice and without involvement of a court if the Licensee fails to comply with any of its terms and conditions, or if the Licensee initiates legal action against Licensor in relation to this Licence. Section 5 shall continue to apply.\n\n   6.5 Except as may be otherwise agreed with the Intergovernmental Organization, any dispute with respect to this Licence involving an Intergovernmental Organization shall, by virtue of the latter's Intergovernmental status, be settled by international arbitration. The arbitration proceedings shall be held at the place where the Intergovernmental Organization has its seat. The arbitral award shall be final and binding upon the parties, who hereby expressly agree to renounce any form of appeal or revision."],"licenseIds":["CERN-OHL-1.1"],"keywords":["ohl v1 1","v1 1 2011","1 2011 07","2011 07 08","07 08 cern","08 cern geneva","licence v1 1","v1 1 preamble","1 preamble through","1 the organization","the organization wishes","organization wishes to","wishes to disseminate","to disseminate its","disseminate its hardware","its hardware designs","hardware designs as","designs as published","as published on","published on http","on http www","http www ohwr","www ohwr org","ohwr org as","org as widely","as widely as","widely as possible","as possible and","possible and generally","and generally to","generally to foster","foster collaboration among","collaboration among public","among public research","public research hardware","research hardware designers","is copyright of","copyright of cern","of cern anyone","distribution of his","of his own","his own open","is reserved 1","reserved 1 definitions","other media product","media product means","versa 2 applicability","with products the","products the use","code is subject","warranties that is","use copy communicate","portion thereof the","thereof the licensee","date and details","and details of","modifications c license","c license the","by cern and","cern and d","and d send","d send a","send a copy","documentation to all","to all licensors","all licensors that","licensors that contributed","that contributed to","documentation that were","that were modified","were modified as","any other licensor","other licensor who","who has requested","has requested to","requested to receive","documentation and has","and has provided","has provided a","provided a means","means of contact","of contact with","contact with the","documentation 3 4","4 the licence","includes a licence","licensee distributes to","distributes to each","such products a","products a copy","applicable and complies","and complies with","complies with section","to inform in","inform in writing","in writing any","writing any licensor","has indicated its","indicated its wish","its wish to","6 1 the","this licence do","licence do not","the names acronyms","names acronyms images","acronyms images or","to apply 6","apply 6 5","6 5 except","5 except as","be otherwise agreed","otherwise agreed with","agreed with the","with the intergovernmental","intergovernmental organization any","organization any dispute","any dispute with","dispute with respect","this licence involving","licence involving an","involving an intergovernmental","an intergovernmental organization","intergovernmental organization shall","organization shall by","shall by virtue","of the latter","the latter s","latter s intergovernmental","s intergovernmental status","intergovernmental status be","status be settled","settled by international","by international arbitration","international arbitration the","arbitration the arbitration","the arbitration proceedings","arbitration proceedings shall","proceedings shall be","be held at","held at the","at the place","the place where","place where the","where the intergovernmental","intergovernmental organization has","organization has its","has its seat","its seat the","seat the arbitral","the arbitral award","arbitral award shall","award shall be","shall be final","be final and","and binding upon","binding upon the","upon the parties","parties who hereby","who hereby expressly","hereby expressly agree","expressly agree to","agree to renounce","to renounce any","renounce any form","form of appeal","of appeal or","appeal or revision","cern ohl v1 1","ohl v1 1 2011","v1 1 2011 07","1 2011 07 08","2011 07 08 cern","07 08 cern geneva","08 cern geneva switzerland","hardware licence v1 1","licence v1 1 preamble","v1 1 preamble through","1 preamble through this","ohl version 1 1","1 1 the organization","1 the organization wishes","the organization wishes to","organization wishes to disseminate","wishes to disseminate its","to disseminate its hardware","disseminate its hardware designs","its hardware designs as","hardware designs as published","designs as published on","as published on http","published on http www","on http www ohwr","http www ohwr org","www ohwr org as","ohwr org as widely","org as widely as","as widely as possible","widely as possible and","as possible and generally","possible and generally to"]},{"licenseTexts":["CERN OHL v1.2\n\n2013-09-06 - CERN, Geneva, Switzerland\n\nCERN Open Hardware Licence v1.2\n\nPreamble\n\nThrough this CERN Open Hardware Licence (\"CERN OHL\") version 1.2, CERN wishes to provide a tool to foster collaboration and sharing among hardware designers. The CERN OHL is copyright CERN. Anyone is welcome to use the CERN OHL, in unmodified form only, for the distribution of their own Open Hardware designs. Any other right is reserved. Release of hardware designs under the CERN OHL does not constitute an endorsement of the licensor or its designs nor does it imply any involvement by CERN in the development of such designs.\n\n1. Definitions\n\nIn this Licence, the following terms have the following meanings:\n\n\"Licence\" means this CERN OHL.\n\n\"Documentation\" means schematic diagrams, designs, circuit or circuit board layouts, mechanical drawings, flow charts and descriptive text, and other explanatory material that is explicitly stated as being made available under the conditions of this Licence. The Documentation may be in any medium, including but not limited to computer files and representations on paper, film, or any other media.\n\n\"Documentation Location\" means a location where the Licensor has placed Documentation, and which he believes will be publicly accessible for at least three years from the first communication to the public or distribution of Documentation.\n\n\"Product\" means either an entire, or any part of a, device built using the Documentation or the modified Documentation.\n\n\"Licensee\" means any natural or legal person exercising rights under this Licence.\n\n\"Licensor\" means any natural or legal person that creates or modifies Documentation and subsequently communicates to the public and/ or distributes the resulting Documentation under the terms and conditions of this Licence.\n\nA Licensee may at the same time be a Licensor, and vice versa.\n\nUse of the masculine gender includes the feminine and neuter genders and is employed solely to facilitate reading.\n\n\n\n2. Applicability\n\n   2.1. This Licence governs the use, copying, modification, communication to the public and distribution of the Documentation, and the manufacture and distribution of Products. By exercising any right granted under this Licence, the Licensee irrevocably accepts these terms and conditions.\n\n   2.2. This Licence is granted by the Licensor directly to the Licensee, and shall apply worldwide and without limitation in time. The Licensee may assign his licence rights or grant sub-licences.\n\n   2.3. This Licence does not extend to software, firmware, or code loaded into programmable devices which may be used in conjunction with the Documentation, the modified Documentation or with Products, unless such software, firmware, or code is explicitly expressed to be subject to this Licence. The use of such software, firmware, or code is otherwise subject to the applicable licence terms and conditions.\n\n3. Copying, modification, communication to the public and distribution of the Documentation\n\n   3.1. The Licensee shall keep intact all copyright and trademarks notices, all notices referring to Documentation Location, and all notices that refer to this Licence and to the disclaimer of warranties that are included in the Documentation. He shall include a copy thereof in every copy of the Documentation or, as the case may be, modified Documentation, that he communicates to the public or distributes.\n\n   3.2. The Licensee may copy, communicate to the public and distribute verbatim copies of the Documentation, in any medium, subject to the requirements specified in section 3.1.\n\n   3.3. The Licensee may modify the Documentation or any portion thereof provided that upon modification of the Documentation, the Licensee shall make the modified Documentation available from a Documentation Location such that it can be easily located by an original Licensor once the Licensee communicates to the public or distributes the modified Documentation under section 3.4, and, where required by section 4.1, by a recipient of a Product. However, the Licensor shall not assert his rights under the foregoing proviso unless or until a Product is distributed.\n\n   3.4. The Licensee may communicate to the public and distribute the modified Documentation (thereby in addition to being a Licensee also becoming a Licensor), always provided that he shall:\n\n      a) comply with section 3.1;\n\n      b) cause the modified Documentation to carry prominent notices stating that the Licensee has modified the Documentation, with the date and description of the modifications;\n\n      c) cause the modified Documentation to carry a new Documentation Location notice if the original Documentation provided for one;\n\n      d) make available the modified Documentation at the same level of abstraction as that of the Documentation, in the preferred format for making modifications to it (e.g. the native format of the CAD tool as applicable), and in the event that format is proprietary, in a format viewable with a tool licensed under an OSI-approved license if the proprietary tool can create it; and\n\n      e) license the modified Documentation under the terms and conditions of this Licence or, where applicable, a later version of this Licence as may be issued by CERN.\n\n   3.5. The Licence includes a non-exclusive licence to those patents or registered designs that are held by, under the control of, or sub-licensable by the Licensor, to the extent necessary to make use of the rights granted under this Licence. The scope of this section 3.5 shall be strictly limited to the parts of the Documentation or modified Documentation created by the Licensor.\n\n4. Manufacture and distribution of Products\n\n   4.1. The Licensee may manufacture or distribute Products always provided that, where such manufacture or distribution requires a licence under this Licence the Licensee provides to each recipient of such Products an easy means of accessing a copy of the Documentation or modified Documentation, as applicable, as set out in section 3.\n\n   4.2. The Licensee is invited to inform any Licensor who has indicated his wish to receive this information about the type, quantity and dates of production of Products the Licensee has (had) manufactured\n\n5. Warranty and liability\n\n   5.1. DISCLAIMER – The Documentation and any modified Documentation are provided \"as is\" and any express or implied warranties, including, but not limited to, implied warranties of merchantability, of satisfactory quality, non-infringement of third party rights, and fitness for a particular purpose or use are disclaimed in respect of the Documentation, the modified Documentation or any Product. The Licensor makes no representation that the Documentation, modified Documentation, or any Product, does or will not infringe any patent, copyright, trade secret or other proprietary right. The entire risk as to the use, quality, and performance of a Product shall be with the Licensee and not the Licensor. This disclaimer of warranty is an essential part of this Licence and a condition for the grant of any rights granted under this Licence. The Licensee warrants that it does not act in a consumer capacity.\n\n   5.2. LIMITATION OF LIABILITY – The Licensor shall have no liability for direct, indirect, special, incidental, consequential, exemplary, punitive or other damages of any character including, without limitation, procurement of substitute goods or services, loss of use, data or profits, or business interruption, however caused and on any theory of contract, warranty, tort (including negligence), product liability or otherwise, arising in any way in relation to the Documentation, modified Documentation and/or the use, manufacture or distribution of a Product, even if advised of the possibility of such damages, and the Licensee shall hold the Licensor(s) free and harmless from any liability, costs, damages, fees and expenses, including claims by third parties, in relation to such use.\n\n6. General\n\n   6.1. Except for the rights explicitly granted hereunder, this Licence does not imply or represent any transfer or assignment of intellectual property rights to the Licensee.\n\n   6.2. The Licensee shall not use or make reference to any of the names (including acronyms and abbreviations), images, or logos under which the Licensor is known, save in so far as required to comply with section 3. Any such permitted use or reference shall be factual and shall in no event suggest any kind of endorsement by the Licensor or its personnel of the modified Documentation or any Product, or any kind of implication by the Licensor or its personnel in the preparation of the modified Documentation or Product.\n\n   6.3. CERN may publish updated versions of this Licence which retain the same general provisions as this version, but differ in detail so far this is required and reasonable. New versions will be published with a unique version number.\n\n   6.4. This Licence shall terminate with immediate effect, upon written notice and without involvement of a court if the Licensee fails to comply with any of its terms and conditions, or if the Licensee initiates legal action against Licensor in relation to this Licence. Section 5 shall continue to apply."],"licenseIds":["CERN-OHL-1.2"],"keywords":["ohl v1 2","v1 2 2013","2 2013 09","2013 09 06","09 06 cern","06 cern geneva","licence v1 2","v1 2 preamble","2 preamble through","1 2 cern","2 cern wishes","cern wishes to","wishes to provide","provide a tool","tool to foster","foster collaboration and","collaboration and sharing","and sharing among","sharing among hardware","copyright cern anyone","distribution of their","of their own","their own open","is reserved release","reserved release of","release of hardware","of hardware designs","hardware designs under","designs under the","under the cern","cern ohl does","ohl does not","does not constitute","not constitute an","an endorsement of","endorsement of the","or its designs","its designs nor","cern in the","in the development","development of such","of such designs","such designs 1","designs 1 definitions","other media documentation","media documentation location","documentation location means","location where the","has placed documentation","placed documentation and","documentation and which","and which he","which he believes","he believes will","believes will be","will be publicly","be publicly accessible","publicly accessible for","the first communication","first communication to","public or distribution","distribution of documentation","of documentation product","documentation product means","vice versa use","versa use of","of the masculine","the masculine gender","masculine gender includes","gender includes the","includes the feminine","the feminine and","feminine and neuter","and neuter genders","neuter genders and","genders and is","and is employed","is employed solely","employed solely to","solely to facilitate","to facilitate reading","facilitate reading 2","reading 2 applicability","extend to software","with products unless","products unless such","unless such software","code is explicitly","is explicitly expressed","explicitly expressed to","expressed to be","licence the use","code is otherwise","is otherwise subject","otherwise subject to","trademarks notices all","notices all notices","all notices referring","notices referring to","referring to documentation","to documentation location","documentation location and","location and all","licensee may copy","may copy communicate","portion thereof provided","thereof provided that","provided that upon","that upon modification","upon modification of","documentation the licensee","licensee shall make","modified documentation available","documentation available from","from a documentation","a documentation location","documentation location such","location such that","be easily located","easily located by","located by an","by an original","an original licensor","original licensor once","licensor once the","once the licensee","the licensee communicates","licensee communicates to","distributes the modified","documentation under section","4 and where","and where required","where required by","4 1 by","1 by a","a product however","product however the","shall not assert","not assert his","assert his rights","his rights under","under the foregoing","the foregoing proviso","foregoing proviso unless","proviso unless or","unless or until","or until a","until a product","distributed 3 4","4 the licensee","date and description","modifications c cause","c cause the","carry a new","a new documentation","new documentation location","documentation location notice","location notice if","notice if the","the original documentation","original documentation provided","documentation provided for","provided for one","for one d","one d make","d make available","available the modified","modified documentation at","documentation at the","the same level","same level of","level of abstraction","of abstraction as","abstraction as that","as that of","the preferred format","preferred format for","format for making","to it e","it e g","e g the","g the native","the native format","native format of","format of the","of the cad","the cad tool","cad tool as","tool as applicable","applicable and in","event that format","that format is","is proprietary in","proprietary in a","a format viewable","format viewable with","a tool licensed","tool licensed under","licensed under an","under an osi"]},{"licenseTexts":["CERN Open Hardware Licence Version 2 - Permissive\n\nPreamble\n\nCERN has developed this licence to promote collaboration among hardware designers and to provide a legal tool which supports the freedom to use, study, modify, share and distribute hardware designs and products based on those designs. Version 2 of the CERN Open Hardware Licence comes in three variants: this licence, CERN-OHL-P (permissive); and two reciprocal licences: CERN- OHL-W (weakly reciprocal) and CERN-OHL-S (strongly reciprocal).\n\nThe CERN-OHL-P is copyright CERN 2020. Anyone is welcome to use it, in unmodified form only.\n\nUse of this Licence does not imply any endorsement by CERN of any Licensor or their designs nor does it imply any involvement by CERN in their development.\n\n   1 Definitions\n\n      1.1 'Licence' means this CERN-OHL-P.\n\n      1.2 'Source' means information such as design materials or digital code which can be applied to Make or test a Product or to prepare a Product for use, Conveyance or sale, regardless of its medium or how it is expressed. It may include Notices.\n\n      1.3 'Covered Source' means Source that is explicitly made available under this Licence.\n\n      1.4 'Product' means any device, component, work or physical object, whether in finished or intermediate form, arising from the use, application or processing of Covered Source.\n\n      1.5 'Make' means to create or configure something, whether by manufacture, assembly, compiling, loading or applying Covered Source or another Product or otherwise.\n\n      1.6 'Notice' means copyright, acknowledgement and trademark notices, references to the location of any Notices, modification notices (subsection 3.3(b)) and all notices that refer to this Licence and to the disclaimer of warranties that are included in the Covered Source.\n\n      1.7 'Licensee' or 'You' means any person exercising rights under this Licence.\n\n      1.8 'Licensor' means a person who creates Source or modifies Covered Source and subsequently Conveys the resulting Covered Source under the terms and conditions of this Licence. A person may be a Licensee and a Licensor at the same time.\n\n      1.9 'Convey' means to communicate to the public or distribute.\n\n   2 Applicability\n\n      2.1 This Licence governs the use, copying, modification, Conveying of Covered Source and Products, and the Making of Products. By exercising any right granted under this Licence, You irrevocably accept these terms and conditions.\n\n      2.2 This Licence is granted by the Licensor directly to You, and shall apply worldwide and without limitation in time.\n\n      2.3 You shall not attempt to restrict by contract or otherwise the rights granted under this Licence to other Licensees.\n\n      2.4 This Licence is not intended to restrict fair use, fair dealing, or any other similar right.\n\n   3 Copying, modifying and Conveying Covered Source\n\n      3.1 You may copy and Convey verbatim copies of Covered Source, in any medium, provided You retain all Notices.\n\n      3.2 You may modify Covered Source, other than Notices.\n\n      You may only delete Notices if they are no longer applicable to the corresponding Covered Source as modified by You and You may add additional Notices applicable to Your modifications.\n\n      3.3 You may Convey modified Covered Source (with the effect that You shall also become a Licensor) provided that You:\n\n         a) retain Notices as required in subsection 3.2; and\n\n         b) add a Notice to the modified Covered Source stating that You have modified it, with the date and brief description of how You have modified it.\n\n      3.4 You may Convey Covered Source or modified Covered Source under licence terms which differ from the terms of this Licence provided that:\n\n         a) You comply at all times with subsection 3.3; and\n\n         b) You provide a copy of this Licence to anyone to whom You Convey Covered Source or modified Covered Source.\n\n   4 Making and Conveying Products\n\n   You may Make Products, and/or Convey them, provided that You ensure that the recipient of the Product has access to any Notices applicable to the Product.\n\n   5 DISCLAIMER AND LIABILITY\n\n      5.1 DISCLAIMER OF WARRANTY -- The Covered Source and any Products are provided 'as is' and any express or implied warranties, including, but not limited to, implied warranties of merchantability, of satisfactory quality, non-infringement of third party rights, and fitness for a particular purpose or use are disclaimed in respect of any Source or Product to the maximum extent permitted by law. The Licensor makes no representation that any Source or Product does not or will not infringe any patent, copyright, trade secret or other proprietary right. The entire risk as to the use, quality, and performance of any Source or Product shall be with You and not the Licensor. This disclaimer of warranty is an essential part of this Licence and a condition for the grant of any rights granted under this Licence.\n\n      5.2 EXCLUSION AND LIMITATION OF LIABILITY -- The Licensor shall, to the maximum extent permitted by law, have no liability for direct, indirect, special, incidental, consequential, exemplary, punitive or other damages of any character including, without limitation, procurement of substitute goods or services, loss of use, data or profits, or business interruption, however caused and on any theory of contract, warranty, tort (including negligence), product liability or otherwise, arising in any way in relation to the Covered Source, modified Covered Source and/or the Making or Conveyance of a Product, even if advised of the possibility of such damages, and You shall hold the Licensor(s) free and harmless from any liability, costs, damages, fees and expenses, including claims by third parties, in relation to such use.\n\n   6 Patents\n\n      6.1 Subject to the terms and conditions of this Licence, each Licensor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section 6, or where terminated by the Licensor for cause) patent license to Make, have Made, use, offer to sell, sell, import, and otherwise transfer the Covered Source and Products, where such licence applies only to those patent claims licensable by such Licensor that are necessarily infringed by exercising rights under the Covered Source as Conveyed by that Licensor.\n\n      6.2 If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Covered Source or a Product constitutes direct or contributory patent infringement, or You seek any declaration that a patent licensed to You under this Licence is invalid or unenforceable then any rights granted to You under this Licence shall terminate as of the date such process is initiated.\n\n   7 General\n\n      7.1 If any provisions of this Licence are or subsequently become invalid or unenforceable for any reason, the remaining provisions shall remain effective.\n\n      7.2 You shall not use any of the name (including acronyms and abbreviations), image, or logo by which the Licensor or CERN is known, except where needed to comply with section 3, or where the use is otherwise allowed by law. Any such permitted use shall be factual and shall not be made so as to suggest any kind of endorsement or implication of involvement by the Licensor or its personnel.\n\n      7.3 CERN may publish updated versions and variants of this Licence which it considers to be in the spirit of this version, but may differ in detail to address new problems or concerns. New versions will be published with a unique version number and a variant identifier specifying the variant. If the Licensor has specified that a given variant applies to the Covered Source without specifying a version, You may treat that Covered Source as being released under any version of the CERN-OHL with that variant. If no variant is specified, the Covered Source shall be treated as being released under CERN-OHL-S. The Licensor may also specify that the Covered Source is subject to a specific version of the CERN-OHL or any later version in which case You may apply this or any later version of CERN-OHL with the same variant identifier published by CERN.\n\n      7.4 This Licence shall not be enforceable except by a Licensor acting as such, and third party beneficiary rights are specifically excluded."],"licenseIds":["CERN-OHL-P-2.0"],"keywords":["version 2 permissive","2 permissive preamble","permissive preamble cern","three variants this","variants this licence","ohl p is","p is copyright","ohl p 1","p 1 2","2 source means","notices 1 3","3 covered source","licence 1 4","1 4 product","4 product means","source 1 5","1 5 make","5 make means","otherwise 1 6","1 6 notice","6 notice means","trademark notices references","notices references to","location of any","of any notices","any notices modification","notices modification notices","source 1 7","1 7 licensee","7 licensee or","licence 1 8","a person who","who creates source","creates source or","source or modifies","source and subsequently","and subsequently conveys","subsequently conveys the","conveys the resulting","resulting covered source","licence a person","time 1 9","1 9 convey","9 convey means","than notices you","and b add","modified it 3","it 3 4","source under licence","under licence terms","licence terms which","this licence provided","licence provided that","a you comply","you comply at","comply at all","times with subsection","b you provide","licence to anyone","you convey covered","covered source 4","source 4 making","that you ensure","you ensure that","product has access","access to any","to any notices","any notices applicable","the product 5","product 5 disclaimer","5 disclaimer and","this licence 5","licence 5 2","5 2 exclusion","use 6 patents","6 patents 6","patents 6 1","6 1 subject","6 or where","or where terminated","where terminated by","terminated by the","licensor for cause","for cause patent","cause patent license","that licensor 6","licensor 6 2","is initiated 7","initiated 7 general","7 general 7","general 7 1","remain effective 7","effective 7 2","its personnel 7","personnel 7 3","7 3 cern","by cern 7","cern 7 4","7 4 this","licence version 2 permissive","version 2 permissive preamble","2 permissive preamble cern","permissive preamble cern has","in three variants this","three variants this licence","variants this licence cern","licence cern ohl p","the cern ohl p","cern ohl p is","ohl p is copyright","p is copyright cern","this cern ohl p","cern ohl p 1","ohl p 1 2","p 1 2 source","1 2 source means","2 source means information","include notices 1 3","notices 1 3 covered","1 3 covered source","3 covered source means","this licence 1 4","licence 1 4 product","1 4 product means","4 product means any","covered source 1 5","source 1 5 make","1 5 make means","5 make means to","or otherwise 1 6","otherwise 1 6 notice","1 6 notice means","6 notice means copyright","and trademark notices references","trademark notices references to","notices references to the","references to the location","the location of any","location of any notices","of any notices modification","any notices modification notices","notices modification notices subsection","covered source 1 7","source 1 7 licensee","1 7 licensee or","7 licensee or you","this licence 1 8","licence 1 8 licensor","8 licensor means a","licensor means a person","means a person who","a person who creates","person who creates source","who creates source or","creates source or modifies","source or modifies covered","modifies covered source and","covered source and subsequently","source and subsequently conveys","and subsequently conveys the","subsequently conveys the resulting","conveys the resulting covered","the resulting covered source","resulting covered source under","this licence a person","licence a person may","same time 1 9","time 1 9 convey","1 9 convey means","9 convey means to","other than notices you","than notices you may","notices you may only","subsection 3 2 and","3 2 and b","2 and b add","and b add a","have modified it 3","modified it 3 4","it 3 4 you","3 4 you may","4 you may convey","covered source under licence","source under licence terms","under licence terms which","licence terms which differ","differ from the terms","of this licence provided","this licence provided that","licence provided that a","provided that a you","that a you comply","a you comply at","you comply at all","comply at all times","all times with subsection","times with subsection 3","subsection 3 3 and","3 3 and b","and b you provide"]},{"licenseTexts":["CERN Open Hardware Licence Version 2 - Strongly Reciprocal\n\nPreamble\n\nCERN has developed this licence to promote collaboration among hardware designers and to provide a legal tool which supports the freedom to use, study, modify, share and distribute hardware designs and products based on those designs. Version 2 of the CERN Open Hardware Licence comes in three variants: CERN-OHL-P (permissive); and two reciprocal licences: CERN-OHL-W (weakly reciprocal) and this licence, CERN-OHL-S (strongly reciprocal).\n\nThe CERN-OHL-S is copyright CERN 2020. Anyone is welcome to use it, in unmodified form only.\n\nUse of this Licence does not imply any endorsement by CERN of any Licensor or their designs nor does it imply any involvement by CERN in their development.\n\n   1 Definitions\n\n      1.1 'Licence' means this CERN-OHL-S.\n\n      1.2 'Compatible Licence' means\n\n         a) any earlier version of the CERN Open Hardware licence, or\n\n         b) any version of the CERN-OHL-S, or\n\n         c) any licence which permits You to treat the Source to which it applies as licensed under CERN-OHL-S provided that on Conveyance of any such Source, or any associated Product You treat the Source in question as being licensed under CERN-OHL-S.\n\n      1.3 'Source' means information such as design materials or digital code which can be applied to Make or test a Product or to prepare a Product for use, Conveyance or sale, regardless of its medium or how it is expressed. It may include Notices.\n\n      1.4 'Covered Source' means Source that is explicitly made available under this Licence.\n\n      1.5 'Product' means any device, component, work or physical object, whether in finished or intermediate form, arising from the use, application or processing of Covered Source.\n\n      1.6 'Make' means to create or configure something, whether by manufacture, assembly, compiling, loading or applying Covered Source or another Product or otherwise.\n\n      1.7 'Available Component' means any part, sub-assembly, library or code which:\n\n         a) is licensed to You as Complete Source under a Compatible Licence; or\n\n         b) is available, at the time a Product or the Source containing it is first Conveyed, to You and any other prospective licensees\n\n            i) as a physical part with sufficient rights and information (including any configuration and programming files and information about its characteristics and interfaces) to enable it either to be Made itself, or to be sourced and used to Make the Product; or\n\n            ii) as part of the normal distribution of a tool used to design or Make the Product.\n\n      1.8 'Complete Source' means the set of all Source necessary to Make a Product, in the preferred form for making modifications, including necessary installation and interfacing information both for the Product, and for any included Available Components. If the format is proprietary, it must also be made available in a format (if the proprietary tool can create it) which is viewable with a tool available to potential licensees and licensed under a licence approved by the Free Software Foundation or the Open Source Initiative. Complete Source need not include the Source of any Available Component, provided that You include in the Complete Source sufficient information to enable a recipient to Make or source and use the Available Component to Make the Product.\n\n      1.9 'Source Location' means a location where a Licensor has placed Covered Source, and which that Licensor reasonably believes will remain easily accessible for at least three years for anyone to obtain a digital copy.\n\n      1.10 'Notice' means copyright, acknowledgement and trademark notices, Source Location references, modification notices (subsection 3.3(b)) and all notices that refer to this Licence and to the disclaimer of warranties that are included in the Covered Source.\n\n      1.11 'Licensee' or 'You' means any person exercising rights under this Licence.\n\n      1.12 'Licensor' means a natural or legal person who creates or modifies Covered Source. A person may be a Licensee and a Licensor at the same time.\n\n      1.13 'Convey' means to communicate to the public or distribute.\n\n   2 Applicability\n\n      2.1 This Licence governs the use, copying, modification, Conveying of Covered Source and Products, and the Making of Products. By exercising any right granted under this Licence, You irrevocably accept these terms and conditions.\n\n      2.2 This Licence is granted by the Licensor directly to You, and shall apply worldwide and without limitation in time.\n\n      2.3 You shall not attempt to restrict by contract or otherwise the rights granted under this Licence to other Licensees.\n\n      2.4 This Licence is not intended to restrict fair use, fair dealing, or any other similar right.\n\n   3 Copying, modifying and Conveying Covered Source\n\n      3.1 You may copy and Convey verbatim copies of Covered Source, in any medium, provided You retain all Notices.\n\n      3.2 You may modify Covered Source, other than Notices, provided that You irrevocably undertake to make that modified Covered Source available from a Source Location should You Convey a Product in circumstances where the recipient does not otherwise receive a copy of the modified Covered Source. In each case subsection 3.3 shall apply.\n\n      You may only delete Notices if they are no longer applicable to the corresponding Covered Source as modified by You and You may add additional Notices applicable to Your modifications. Including Covered Source in a larger work is modifying the Covered Source, and the larger work becomes modified Covered Source.\n\n      3.3 You may Convey modified Covered Source (with the effect that You shall also become a Licensor) provided that You:\n\n         a) retain Notices as required in subsection 3.2;\n\n         b) add a Notice to the modified Covered Source stating that You have modified it, with the date and brief description of how You have modified it;\n\n         c) add a Source Location Notice for the modified Covered Source if You Convey in circumstances where the recipient does not otherwise receive a copy of the modified Covered Source; and\n\n         d) license the modified Covered Source under the terms and conditions of this Licence (or, as set out in subsection 8.3, a later version, if permitted by the licence of the original Covered Source). Such modified Covered Source must be licensed as a whole, but excluding Available Components contained in it, which remain licensed under their own applicable licences.\n\n   4 Making and Conveying Products\n\n   You may Make Products, and/or Convey them, provided that You either provide each recipient with a copy of the Complete Source or ensure that each recipient is notified of the Source Location of the Complete Source. That Complete Source is Covered Source, and You must accordingly satisfy Your obligations set out in subsection 3.3. If specified in a Notice, the Product must visibly and securely display the Source Location on it or its packaging or documentation in the manner specified in that Notice.\n\n   5 Research and Development\n\n   You may Convey Covered Source, modified Covered Source or Products to a legal entity carrying out development, testing or quality assurance work on Your behalf provided that the work is performed on terms which prevent the entity from both using the Source or Products for its own internal purposes and Conveying the Source or Products or any modifications to them to any person other than You. Any modifications made by the entity shall be deemed to be made by You pursuant to subsection 3.2.\n\n   6 DISCLAIMER AND LIABILITY\n\n      6.1 DISCLAIMER OF WARRANTY -- The Covered Source and any Products are provided 'as is' and any express or implied warranties, including, but not limited to, implied warranties of merchantability, of satisfactory quality, non-infringement of third party rights, and fitness for a particular purpose or use are disclaimed in respect of any Source or Product to the maximum extent permitted by law. The Licensor makes no representation that any Source or Product does not or will not infringe any patent, copyright, trade secret or other proprietary right. The entire risk as to the use, quality, and performance of any Source or Product shall be with You and not the Licensor. This disclaimer of warranty is an essential part of this Licence and a condition for the grant of any rights granted under this Licence.\n\n      6.2 EXCLUSION AND LIMITATION OF LIABILITY -- The Licensor shall, to the maximum extent permitted by law, have no liability for direct, indirect, special, incidental, consequential, exemplary, punitive or other damages of any character including, without limitation, procurement of substitute goods or services, loss of use, data or profits, or business interruption, however caused and on any theory of contract, warranty, tort (including negligence), product liability or otherwise, arising in any way in relation to the Covered Source, modified Covered Source and/or the Making or Conveyance of a Product, even if advised of the possibility of such damages, and You shall hold the Licensor(s) free and harmless from any liability, costs, damages, fees and expenses, including claims by third parties, in relation to such use.\n\n   7 Patents\n\n      7.1 Subject to the terms and conditions of this Licence, each Licensor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in subsections 7.2 and 8.4) patent license to Make, have Made, use, offer to sell, sell, import, and otherwise transfer the Covered Source and Products, where such licence applies only to those patent claims licensable by such Licensor that are necessarily infringed by exercising rights under the Covered Source as Conveyed by that Licensor.\n\n      7.2 If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Covered Source or a Product constitutes direct or contributory patent infringement, or You seek any declaration that a patent licensed to You under this Licence is invalid or unenforceable then any rights granted to You under this Licence shall terminate as of the date such process is initiated.\n\n   8 General\n\n      8.1 If any provisions of this Licence are or subsequently become invalid or unenforceable for any reason, the remaining provisions shall remain effective.\n\n      8.2 You shall not use any of the name (including acronyms and abbreviations), image, or logo by which the Licensor or CERN is known, except where needed to comply with section 3, or where the use is otherwise allowed by law. Any such permitted use shall be factual and shall not be made so as to suggest any kind of endorsement or implication of involvement by the Licensor or its personnel.\n\n      8.3 CERN may publish updated versions and variants of this Licence which it considers to be in the spirit of this version, but may differ in detail to address new problems or concerns. New versions will be published with a unique version number and a variant identifier specifying the variant. If the Licensor has specified that a given variant applies to the Covered Source without specifying a version, You may treat that Covered Source as being released under any version of the CERN-OHL with that variant. If no variant is specified, the Covered Source shall be treated as being released under CERN-OHL-S. The Licensor may also specify that the Covered Source is subject to a specific version of the CERN-OHL or any later version in which case You may apply this or any later version of CERN-OHL with the same variant identifier published by CERN.\n\n      8.4 This Licence shall terminate with immediate effect if You fail to comply with any of its terms and conditions.\n\n      8.5 However, if You cease all breaches of this Licence, then Your Licence from any Licensor is reinstated unless such Licensor has terminated this Licence by giving You, while You remain in breach, a notice specifying the breach and requiring You to cure it within 30 days, and You have failed to come into compliance in all material respects by the end of the 30 day period. Should You repeat the breach after receipt of a cure notice and subsequent reinstatement, this Licence will terminate immediately and permanently. Section 6 shall continue to apply after any termination.\n\n      8.6 This Licence shall not be enforceable except by a Licensor acting as such, and third party beneficiary rights are specifically excluded."],"licenseIds":["CERN-OHL-S-2.0"],"keywords":["version 2 strongly","2 strongly reciprocal","strongly reciprocal preamble","reciprocal and this","and this licence","ohl s is","s is copyright","s 1 2","s or c","ohl s provided","s provided that","s 1 3","licensees i as","i as a","as a physical","a physical part","physical part with","part with sufficient","1 8 complete","8 complete source","product 1 9","9 source location","copy 1 10","source 1 11","1 11 licensee","11 licensee or","licence 1 12","1 12 licensor","12 licensor means","time 1 13","1 13 convey","13 convey means","your modifications including","modifications including covered","including covered source","source in a","work is modifying","is modifying the","modifying the covered","source and the","larger work becomes","work becomes modified","becomes modified covered","source 3 3","in it which","it which remain","complete source is","source is covered","is covered source","that notice 5","notice 5 research","by cern 8","cern 8 4","licence version 2 strongly","version 2 strongly reciprocal","2 strongly reciprocal preamble","strongly reciprocal preamble cern","weakly reciprocal and this","reciprocal and this licence","and this licence cern","licence cern ohl s","cern ohl s is","ohl s is copyright","s is copyright cern","this cern ohl s","ohl s 1 2","s 1 2 compatible","ohl s or c","s or c any","cern ohl s provided","ohl s provided that","s provided that on","ohl s 1 3","s 1 3 source","prospective licensees i as","licensees i as a","i as a physical","as a physical part","a physical part with","physical part with sufficient","part with sufficient rights","product 1 8 complete","1 8 complete source","8 complete source means","the product 1 9","product 1 9 source","1 9 source location","9 source location means","digital copy 1 10","copy 1 10 notice","10 notice means copyright","covered source 1 11","source 1 11 licensee","1 11 licensee or","11 licensee or you","this licence 1 12","licence 1 12 licensor","1 12 licensor means","12 licensor means a","same time 1 13","time 1 13 convey","1 13 convey means","13 convey means to","to your modifications including","your modifications including covered","modifications including covered source","including covered source in","covered source in a","source in a larger","larger work is modifying","work is modifying the","is modifying the covered","modifying the covered source","covered source and the","source and the larger","the larger work becomes","larger work becomes modified","work becomes modified covered","becomes modified covered source","modified covered source 3","covered source 3 3","source 3 3 you","contained in it which","in it which remain","it which remain licensed","that complete source is","complete source is covered","source is covered source","is covered source and","in that notice 5","that notice 5 research","notice 5 research and","published by cern 8","by cern 8 4","cern 8 4 this","hardware licence version 2 strongly","licence version 2 strongly reciprocal","version 2 strongly reciprocal preamble","2 strongly reciprocal preamble cern","strongly reciprocal preamble cern has","w weakly reciprocal and this","weakly reciprocal and this licence","reciprocal and this licence cern","and this licence cern ohl","this licence cern ohl s","licence cern ohl s strongly","reciprocal the cern ohl s","the cern ohl s is","cern ohl s is copyright","ohl s is copyright cern","s is copyright cern 2020","means this cern ohl s","this cern ohl s 1","cern ohl s 1 2","ohl s 1 2 compatible","s 1 2 compatible licence","cern ohl s or c","ohl s or c any","s or c any licence","under cern ohl s provided","cern ohl s provided that","ohl s provided that on","s provided that on conveyance","under cern ohl s 1","cern ohl s 1 3","ohl s 1 3 source","s 1 3 source means","other prospective licensees i as","prospective licensees i as a","licensees i as a physical","i as a physical part","as a physical part with","a physical part with sufficient","physical part with sufficient rights","part with sufficient rights and","the product 1 8 complete","product 1 8 complete source","1 8 complete source means","8 complete source means the","make the product 1 9","the product 1 9 source","product 1 9 source location","1 9 source location means","9 source location means a","a digital copy 1 10","digital copy 1 10 notice","copy 1 10 notice means","1 10 notice means copyright","10 notice means copyright acknowledgement","the covered source 1 11","covered source 1 11 licensee","source 1 11 licensee or","1 11 licensee or you","11 licensee or you means","under this licence 1 12","this licence 1 12 licensor","licence 1 12 licensor means","1 12 licensor means a","12 licensor means a natural","the same time 1 13"]},{"licenseTexts":["CERN Open Hardware Licence Version 2 - Weakly Reciprocal\n\nPreamble\n\nCERN has developed this licence to promote collaboration among hardware designers and to provide a legal tool which supports the freedom to use, study, modify, share and distribute hardware designs and products based on those designs. Version 2 of the CERN Open Hardware Licence comes in three variants: CERN-OHL-P (permissive); and two reciprocal licences: this licence, CERN- OHL-W (weakly reciprocal) and CERN-OHL-S (strongly reciprocal).\n\nThe CERN-OHL-W is copyright CERN 2020. Anyone is welcome to use it, in unmodified form only.\n\nUse of this Licence does not imply any endorsement by CERN of any Licensor or their designs nor does it imply any involvement by CERN in their development.\n\n   1 Definitions\n\n      1.1 'Licence' means this CERN-OHL-W.\n\n      1.2 'Compatible Licence' means\n\n         a) any earlier version of the CERN Open Hardware licence, or\n\n         b) any version of the CERN-OHL-S or the CERN-OHL-W, or\n\n         c) any licence which permits You to treat the Source to which it applies as licensed under CERN-OHL-S or CERN-OHL-W provided that on Conveyance of any such Source, or any associated Product You treat the Source in question as being licensed under CERN-OHL-S or CERN-OHL-W as appropriate.\n\n      1.3 'Source' means information such as design materials or digital code which can be applied to Make or test a Product or to prepare a Product for use, Conveyance or sale, regardless of its medium or how it is expressed. It may include Notices.\n\n      1.4 'Covered Source' means Source that is explicitly made available under this Licence.\n\n      1.5 'Product' means any device, component, work or physical object, whether in finished or intermediate form, arising from the use, application or processing of Covered Source.\n\n      1.6 'Make' means to create or configure something, whether by manufacture, assembly, compiling, loading or applying Covered Source or another Product or otherwise.\n\n      1.7 'Available Component' means any part, sub-assembly, library or code which:\n\n         a) is licensed to You as Complete Source under a Compatible Licence; or\n\n         b) is available, at the time a Product or the Source containing it is first Conveyed, to You and any other prospective licensees\n\n            i) with sufficient rights and information (including any configuration and programming files and information about its characteristics and interfaces) to enable it either to be Made itself, or to be sourced and used to Make the Product; or\n\n            ii) as part of the normal distribution of a tool used to design or Make the Product.\n\n      1.8 'External Material' means anything (including Source) which:\n\n         a) is only combined with Covered Source in such a way that it interfaces with the Covered Source using a documented interface which is described in the Covered Source; and\n\n         b) is not a derivative of or contains Covered Source, or, if it is, it is solely to the extent necessary to facilitate such interfacing.\n\n      1.9 'Complete Source' means the set of all Source necessary to Make a Product, in the preferred form for making modifications, including necessary installation and interfacing information both for the Product, and for any included Available Components. If the format is proprietary, it must also be made available in a format (if the proprietary tool can create it) which is viewable with a tool available to potential licensees and licensed under a licence approved by the Free Software Foundation or the Open Source Initiative. Complete Source need not include the Source of any Available Component, provided that You include in the Complete Source sufficient information to enable a recipient to Make or source and use the Available Component to Make the Product.\n\n      1.10 'Source Location' means a location where a Licensor has placed Covered Source, and which that Licensor reasonably believes will remain easily accessible for at least three years for anyone to obtain a digital copy.\n\n      1.11 'Notice' means copyright, acknowledgement and trademark notices, Source Location references, modification notices (subsection 3.3(b)) and all notices that refer to this Licence and to the disclaimer of warranties that are included in the Covered Source.\n\n      1.12 'Licensee' or 'You' means any person exercising rights under this Licence.\n\n      1.13 'Licensor' means a natural or legal person who creates or modifies Covered Source. A person may be a Licensee and a Licensor at the same time.\n\n      1.14 'Convey' means to communicate to the public or distribute.\n\n   2 Applicability\n\n      2.1 This Licence governs the use, copying, modification, Conveying of Covered Source and Products, and the Making of Products. By exercising any right granted under this Licence, You irrevocably accept these terms and conditions.\n\n      2.2 This Licence is granted by the Licensor directly to You, and shall apply worldwide and without limitation in time.\n\n      2.3 You shall not attempt to restrict by contract or otherwise the rights granted under this Licence to other Licensees.\n\n      2.4 This Licence is not intended to restrict fair use, fair dealing, or any other similar right.\n\n   3 Copying, modifying and Conveying Covered Source\n\n      3.1 You may copy and Convey verbatim copies of Covered Source, in any medium, provided You retain all Notices.\n\n      3.2 You may modify Covered Source, other than Notices, provided that You irrevocably undertake to make that modified Covered Source available from a Source Location should You Convey a Product in circumstances where the recipient does not otherwise receive a copy of the modified Covered Source. In each case subsection 3.3 shall apply.\n\n      You may only delete Notices if they are no longer applicable to the corresponding Covered Source as modified by You and You may add additional Notices applicable to Your modifications.\n\n      3.3 You may Convey modified Covered Source (with the effect that You shall also become a Licensor) provided that You:\n\n         a) retain Notices as required in subsection 3.2;\n\n         b) add a Notice to the modified Covered Source stating that You have modified it, with the date and brief description of how You have modified it;\n\n         c) add a Source Location Notice for the modified Covered Source if You Convey in circumstances where the recipient does not otherwise receive a copy of the modified Covered Source; and\n\n         d) license the modified Covered Source under the terms and conditions of this Licence (or, as set out in subsection 8.3, a later version, if permitted by the licence of the original Covered Source). Such modified Covered Source must be licensed as a whole, but excluding Available Components contained in it or External Material to which it is interfaced, which remain licensed under their own applicable licences.\n\n   4 Making and Conveying Products\n\n      4.1 You may Make Products, and/or Convey them, provided that You either provide each recipient with a copy of the Complete Source or ensure that each recipient is notified of the Source Location of the Complete Source. That Complete Source includes Covered Source and You must accordingly satisfy Your obligations set out in subsection 3.3. If specified in a Notice, the Product must visibly and securely display the Source Location on it or its packaging or documentation in the manner specified in that Notice.\n\n      4.2 Where You Convey a Product which incorporates External Material, the Complete Source for that Product which You are required to provide under subsection 4.1 need not include any Source for the External Material.\n\n      4.3 You may license Products under terms of Your choice, provided that such terms do not restrict or attempt to restrict any recipients' rights under this Licence to the Covered Source.\n\n   5 Research and Development\n\n   You may Convey Covered Source, modified Covered Source or Products to a legal entity carrying out development, testing or quality assurance work on Your behalf provided that the work is performed on terms which prevent the entity from both using the Source or Products for its own internal purposes and Conveying the Source or Products or any modifications to them to any person other than You. Any modifications made by the entity shall be deemed to be made by You pursuant to subsection 3.2.\n\n   6 DISCLAIMER AND LIABILITY\n\n      6.1 DISCLAIMER OF WARRANTY -- The Covered Source and any Products are provided 'as is' and any express or implied warranties, including, but not limited to, implied warranties of merchantability, of satisfactory quality, non-infringement of third party rights, and fitness for a particular purpose or use are disclaimed in respect of any Source or Product to the maximum extent permitted by law. The Licensor makes no representation that any Source or Product does not or will not infringe any patent, copyright, trade secret or other proprietary right. The entire risk as to the use, quality, and performance of any Source or Product shall be with You and not the Licensor. This disclaimer of warranty is an essential part of this Licence and a condition for the grant of any rights granted under this Licence.\n\n      6.2 EXCLUSION AND LIMITATION OF LIABILITY -- The Licensor shall, to the maximum extent permitted by law, have no liability for direct, indirect, special, incidental, consequential, exemplary, punitive or other damages of any character including, without limitation, procurement of substitute goods or services, loss of use, data or profits, or business interruption, however caused and on any theory of contract, warranty, tort (including negligence), product liability or otherwise, arising in any way in relation to the Covered Source, modified Covered Source and/or the Making or Conveyance of a Product, even if advised of the possibility of such damages, and You shall hold the Licensor(s) free and harmless from any liability, costs, damages, fees and expenses, including claims by third parties, in relation to such use.\n\n   7 Patents\n\n      7.1 Subject to the terms and conditions of this Licence, each Licensor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in subsections 7.2 and 8.4) patent license to Make, have Made, use, offer to sell, sell, import, and otherwise transfer the Covered Source and Products, where such licence applies only to those patent claims licensable by such Licensor that are necessarily infringed by exercising rights under the Covered Source as Conveyed by that Licensor.\n\n      7.2 If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Covered Source or a Product constitutes direct or contributory patent infringement, or You seek any declaration that a patent licensed to You under this Licence is invalid or unenforceable then any rights granted to You under this Licence shall terminate as of the date such process is initiated.\n\n   8 General\n\n      8.1 If any provisions of this Licence are or subsequently become invalid or unenforceable for any reason, the remaining provisions shall remain effective.\n\n      8.2 You shall not use any of the name (including acronyms and abbreviations), image, or logo by which the Licensor or CERN is known, except where needed to comply with section 3, or where the use is otherwise allowed by law. Any such permitted use shall be factual and shall not be made so as to suggest any kind of endorsement or implication of involvement by the Licensor or its personnel.\n\n      8.3 CERN may publish updated versions and variants of this Licence which it considers to be in the spirit of this version, but may differ in detail to address new problems or concerns. New versions will be published with a unique version number and a variant identifier specifying the variant. If the Licensor has specified that a given variant applies to the Covered Source without specifying a version, You may treat that Covered Source as being released under any version of the CERN-OHL with that variant. If no variant is specified, the Covered Source shall be treated as being released under CERN-OHL-S. The Licensor may also specify that the Covered Source is subject to a specific version of the CERN-OHL or any later version in which case You may apply this or any later version of CERN-OHL with the same variant identifier published by CERN.\n\n      You may treat Covered Source licensed under CERN-OHL-W as licensed under CERN-OHL-S if and only if all Available Components referenced in the Covered Source comply with the corresponding definition of Available Component for CERN-OHL-S.\n\n      8.4 This Licence shall terminate with immediate effect if You fail to comply with any of its terms and conditions.\n\n      8.5 However, if You cease all breaches of this Licence, then Your Licence from any Licensor is reinstated unless such Licensor has terminated this Licence by giving You, while You remain in breach, a notice specifying the breach and requiring You to cure it within 30 days, and You have failed to come into compliance in all material respects by the end of the 30 day period. Should You repeat the breach after receipt of a cure notice and subsequent reinstatement, this Licence will terminate immediately and permanently. Section 6 shall continue to apply after any termination.\n\n      8.6 This Licence shall not be enforceable except by a Licensor acting as such, and third party beneficiary rights are specifically excluded."],"licenseIds":["CERN-OHL-W-2.0"],"keywords":["version 2 weakly","2 weakly reciprocal","weakly reciprocal preamble","reciprocal licences this","licences this licence","ohl w is","w is copyright","ohl w 1","w 1 2","or the cern","ohl w or","w or c","ohl w provided","w provided that","w as appropriate","as appropriate 1","appropriate 1 3","licensees i with","i with sufficient","1 8 external","8 external material","external material means","material means anything","means anything including","anything including source","including source which","source which a","a is only","is only combined","only combined with","combined with covered","with covered source","source in such","way that it","that it interfaces","it interfaces with","interfaces with the","covered source using","source using a","using a documented","a documented interface","documented interface which","interface which is","source and b","and b is","b is not","derivative of or","of or contains","or contains covered","contains covered source","it is it","is it is","is solely to","necessary to facilitate","to facilitate such","facilitate such interfacing","such interfacing 1","interfacing 1 9","1 9 complete","9 complete source","product 1 10","1 10 source","10 source location","copy 1 11","1 11 notice","11 notice means","source 1 12","1 12 licensee","12 licensee or","licence 1 13","1 13 licensor","13 licensor means","time 1 14","1 14 convey","14 convey means","in it or","it or external","or external material","external material to","it is interfaced","is interfaced which","interfaced which remain","conveying products 4","complete source includes","source includes covered","includes covered source","that notice 4","notice 4 2","4 2 where","2 where you","where you convey","a product which","product which incorporates","which incorporates external","incorporates external material","external material the","material the complete","complete source for","source for that","that product which","to provide under","provide under subsection","under subsection 4","subsection 4 1","4 1 need","1 need not","include any source","any source for","for the external","the external material","external material 4","material 4 3","4 3 you","may license products","license products under","products under terms","that such terms","such terms do","restrict or attempt","or attempt to","to restrict any","restrict any recipients","any recipients rights","covered source 5","source 5 research","by cern you","cern you may","may treat covered","treat covered source","covered source licensed","source licensed under","w as licensed","ohl s if","s if and","only if all","if all available","all available components","available components referenced","components referenced in","referenced in the","covered source comply","source comply with","with the corresponding","the corresponding definition","corresponding definition of","definition of available","of available component","available component for","component for cern","for cern ohl","ohl s 8","s 8 4","licence version 2 weakly","version 2 weakly reciprocal","2 weakly reciprocal preamble","weakly reciprocal preamble cern","two reciprocal licences this","reciprocal licences this licence","licences this licence cern","licence cern ohl w","cern ohl w is","ohl w is copyright","w is copyright cern","this cern ohl w","cern ohl w 1","ohl w 1 2","w 1 2 compatible","ohl s or the","s or the cern","or the cern ohl","cern ohl w or","ohl w or c","w or c any","cern ohl w provided","ohl w provided that","w provided that on","ohl w as appropriate","w as appropriate 1","as appropriate 1 3","appropriate 1 3 source","prospective licensees i with","licensees i with sufficient","i with sufficient rights","product 1 8 external","1 8 external material","8 external material means","external material means anything","material means anything including","means anything including source","anything including source which","including source which a","source which a is","which a is only","a is only combined","is only combined with","only combined with covered","combined with covered source","with covered source in","covered source in such","source in such a"]},{"licenseTexts":["\n\n   1. This LICENSE AGREEMENT is between the Corporation for National Research Initiatives, having an office at 1895 Preston White Drive, Reston, VA 20191 (\"CNRI\"), and the Individual or Organization (\"Licensee\") accessing and using JPython version 1.1.x in source or binary form and its associated documentation as provided herein (\"Software\").\n\n   \n\n   2. Subject to the terms and conditions of this License Agreement, CNRI hereby grants Licensee a non-exclusive, non-transferable, royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivative works, distribute, and otherwise use the Software alone or in any derivative version, provided, however, that CNRI's License Agreement and CNRI's notice of copyright, i.e., \"Copyright (c) 1996-1999 Corporation for National Research Initiatives; All Rights Reserved\" are both retained in the Software, alone or in any derivative version prepared by Licensee.\n\n   Alternatively, in lieu of CNRI's License Agreement, Licensee may substitute the following text (omitting the quotes), provided, however, that such text is displayed prominently in the Software alone or in any derivative version prepared by Licensee: \"JPython (Version 1.1.x) is made available subject to the terms and conditions in CNRI's License Agreement. This Agreement may be located on the Internet using the following unique, persistent identifier (known as a handle): 1895.22/1006. The License may also be obtained from a proxy server on the Web using the following URL: http://hdl.handle.net/1895.22/1006.\"\n\n   3. In the event Licensee prepares a derivative work that is based on or incorporates the Software or any part thereof, and wants to make the derivative work available to the public as provided herein, then Licensee hereby agrees to indicate in any such work, in a prominently visible way, the nature of the modifications made to CNRI's Software.\n\n   4. Licensee may not use CNRI trademarks or trade name, including JPython or CNRI, in a trademark sense to endorse or promote products or services of Licensee, or any third party. Licensee may use the mark JPython in connection with Licensee's derivative versions that are based on or incorporate the Software, but only in the form \"JPython-based ___________________,\" or equivalent.\n\n   5. CNRI is making the Software available to Licensee on an \"AS IS\" basis. CNRI MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, CNRI MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.\n\n   6. CNRI SHALL NOT BE LIABLE TO LICENSEE OR OTHER USERS OF THE SOFTWARE FOR ANY INCIDENTAL, SPECIAL OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF. SOME STATES DO NOT ALLOW THE LIMITATION OR EXCLUSION OF LIABILITY SO THE ABOVE DISCLAIMER MAY NOT APPLY TO LICENSEE.\n\n   7. This License Agreement may be terminated by CNRI (i) immediately upon written notice from CNRI of any material breach by the Licensee, if the nature of the breach is such that it cannot be promptly remedied; or (ii) sixty (60) days following notice from CNRI to Licensee of a material remediable breach, if Licensee has not remedied such breach within that sixty-day period.\n\n   8. This License Agreement shall be governed by and interpreted in all respects by the law of the State of Virginia, excluding conflict of law provisions. Nothing in this Agreement shall be deemed to create any relationship of agency, partnership, or joint venture between CNRI and Licensee.\n\n   9. By clicking on the \"ACCEPT\" button where indicated, or by installing, copying or otherwise using the Software, Licensee agrees to be bound by the terms and conditions of this License Agreement."],"licenseIds":["CNRI-Jython"],"keywords":["accessing and using","and using jpython","using jpython version","1 x in","x in source","documentation as provided","provided herein software","herein software 2","1996 1999 corporation","1999 corporation for","reserved are both","are both retained","both retained in","by licensee alternatively","licensee alternatively in","alternatively in lieu","the quotes provided","quotes provided however","that such text","such text is","text is displayed","is displayed prominently","displayed prominently in","by licensee jpython","licensee jpython version","1 x is","x is made","22 1006 the","1006 the license","on the web","the web using","web using the","22 1006 3","1006 3 in","or incorporates the","incorporates the software","such work in","in a prominently","a prominently visible","prominently visible way","visible way the","way the nature","made to cnri","to cnri s","cnri s software","s software 4","software 4 licensee","4 licensee may","not use cnri","trade name including","name including jpython","including jpython or","jpython or cnri","or cnri in","cnri in a","third party licensee","party licensee may","use the mark","the mark jpython","mark jpython in","jpython in connection","connection with licensee","with licensee s","licensee s derivative","s derivative versions","derivative versions that","versions that are","that are based","on or incorporate","or incorporate the","incorporate the software","software but only","but only in","the form jpython","form jpython based","jpython based or","based or equivalent","or equivalent 5","equivalent 5 cnri","5 cnri is","party rights 6","rights 6 cnri","6 cnri shall","or other users","thereof some states","some states do","states do not","the limitation or","limitation or exclusion","or exclusion of","of liability so","liability so the","above disclaimer may","to licensee 7","licensee 7 this","license agreement may","may be terminated","be terminated by","terminated by cnri","by cnri i","cnri i immediately","i immediately upon","immediately upon written","from cnri of","cnri of any","of any material","the licensee if","licensee if the","if the nature","the breach is","breach is such","is such that","that it cannot","it cannot be","cannot be promptly","be promptly remedied","promptly remedied or","remedied or ii","or ii sixty","ii sixty 60","60 days following","days following notice","following notice from","from cnri to","cnri to licensee","to licensee of","of a material","a material remediable","material remediable breach","remediable breach if","breach if licensee","has not remedied","not remedied such","remedied such breach","breach within that","within that sixty","that sixty day","sixty day period","day period 8","period 8 this","8 this license","and licensee 9","licensee 9 by","9 by clicking","or by installing","by installing copying","licensee accessing and using","accessing and using jpython","and using jpython version","using jpython version 1","1 1 x in","1 x in source","x in source or","associated documentation as provided","documentation as provided herein","as provided herein software","provided herein software 2","herein software 2 subject","transferable royalty free world","e copyright c 1996","c 1996 1999 corporation","1996 1999 corporation for","1999 corporation for national","rights reserved are both","reserved are both retained","are both retained in","both retained in the","prepared by licensee alternatively","by licensee alternatively in","licensee alternatively in lieu","alternatively in lieu of","omitting the quotes provided","the quotes provided however","quotes provided however that","however that such text","that such text is","such text is displayed","text is displayed prominently","is displayed prominently in","displayed prominently in the","prominently in the software","prepared by licensee jpython","by licensee jpython version","licensee jpython version 1","1 1 x is","1 x is made","x is made available","handle 1895 22 1006","1895 22 1006 the","22 1006 the license","1006 the license may","server on the web","on the web using","the web using the","web using the following","net 1895 22 1006","1895 22 1006 3","22 1006 3 in","1006 3 in the","on or incorporates the"]},{"licenseTexts":["CNRI OPEN SOURCE GPL-COMPATIBLE LICENSE AGREEMENT\n\nIMPORTANT: PLEASE READ THE FOLLOWING AGREEMENT CAREFULLY.\n\nBY CLICKING ON \"ACCEPT\" WHERE INDICATED BELOW, OR BY COPYING, INSTALLING OR OTHERWISE USING PYTHON 1.6.1 SOFTWARE, YOU ARE DEEMED TO HAVE AGREED TO THE TERMS AND CONDITIONS OF THIS LICENSE AGREEMENT.\n\n   1. This LICENSE AGREEMENT is between the Corporation for National Research Initiatives, having an office at 1895 Preston White Drive, Reston, VA 20191 (\"CNRI\"), and the Individual or Organization (\"Licensee\") accessing and otherwise using Python 1.6.1 software in source or binary form and its associated documentation.\n\n   2. Subject to the terms and conditions of this License Agreement, CNRI hereby grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivative works, distribute, and otherwise use Python 1.6.1 alone or in any derivative version, provided, however, that CNRI's License Agreement and CNRI's notice of copyright, i.e., \"Copyright © 1995-2001 Corporation for National Research Initiatives; All Rights Reserved\" are retained in Python 1.6.1 alone or in any derivative version prepared by Licensee. Alternately, in lieu of CNRI's License Agreement, Licensee may substitute the following text (omitting the quotes): \"Python 1.6.1 is made available subject to the terms and conditions in CNRI's License Agreement. This Agreement together with Python 1.6.1 may be located on the Internet using the following unique, persistent identifier (known as a handle): 1895.22/1013. This Agreement may also be obtained from a proxy server on the Internet using the following URL: http://hdl.handle.net/1895.22/1013\".\n\n   3. In the event Licensee prepares a derivative work that is based on or incorporates Python 1.6.1 or any part thereof, and wants to make the derivative work available to others as provided herein, then Licensee hereby agrees to include in any such work a brief summary of the changes made to Python 1.6.1.\n\n   4. CNRI is making Python 1.6.1 available to Licensee on an \"AS IS\" basis. CNRI MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, CNRI MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 1.6.1 WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.\n\n   5. CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON 1.6.1 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1, OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.\n\n   6. This License Agreement will automatically terminate upon a material breach of its terms and conditions.\n\n   7. This License Agreement shall be governed by the federal intellectual property law of the United States, including without limitation the federal copyright law, and, to the extent such U.S. federal law does not apply, by the law of the Commonwealth of Virginia, excluding Virginia's conflict of law provisions. Notwithstanding the foregoing, with regard to derivative works based on Python 1.6.1 that incorporate non-separable material that was previously distributed under the GNU General Public License (GPL), the law of the Commonwealth of Virginia shall govern this License Agreement only as to issues arising under or with respect to Paragraphs 4, 5, and 7 of this License Agreement. Nothing in this License Agreement shall be deemed to create any relationship of agency, partnership, or joint venture between CNRI and Licensee. This License Agreement does not grant permission to use CNRI trademarks or trade name in a trademark sense to endorse or promote products or services of Licensee, or any third party.\n\n   8. By clicking on the \"ACCEPT\" button where indicated, or by copying, installing or otherwise using Python 1.6.1, Licensee agrees to be bound by the terms and conditions of this License Agreement. ACCEPT"],"licenseIds":["CNRI-Python-GPL-Compatible"],"keywords":["open source gpl","source gpl compatible","gpl compatible license","compatible license agreement","e copyright 1995","copyright 1995 2001","1995 2001 corporation","2001 corporation for","6 1 is","this agreement together","agreement together with","together with python","with python 1","6 1 may","1 may be","22 1013 this","1013 this agreement","22 1013 3","1013 3 in","6 1 4","1 4 cnri","6 1 available","1 available to","6 1 will","1 will not","by the federal","the federal intellectual","federal intellectual property","property law of","united states including","states including without","limitation the federal","the federal copyright","federal copyright law","law and to","extent such u","such u s","s federal law","federal law does","law does not","not apply by","apply by the","virginia excluding virginia","excluding virginia s","virginia s conflict","law provisions notwithstanding","provisions notwithstanding the","the foregoing with","foregoing with regard","regard to derivative","based on python","on python 1","6 1 that","1 that incorporate","that incorporate non","incorporate non separable","non separable material","separable material that","material that was","that was previously","was previously distributed","previously distributed under","license gpl the","gpl the law","of virginia shall","virginia shall govern","shall govern this","govern this license","license agreement only","agreement only as","only as to","as to issues","to issues arising","issues arising under","under or with","respect to paragraphs","to paragraphs 4","paragraphs 4 5","4 5 and","5 and 7","7 of this","license agreement nothing","agreement nothing in","6 1 licensee","1 licensee agrees","cnri open source gpl","open source gpl compatible","source gpl compatible license","gpl compatible license agreement","compatible license agreement important","6 1 software you","6 1 software in","use python 1 6","i e copyright 1995","e copyright 1995 2001","copyright 1995 2001 corporation","1995 2001 corporation for","2001 corporation for national","in python 1 6","1 6 1 is","6 1 is made","agreement this agreement together","this agreement together with","agreement together with python","together with python 1","with python 1 6","1 6 1 may","6 1 may be","1 may be located","handle 1895 22 1013","1895 22 1013 this","22 1013 this agreement","1013 this agreement may","net 1895 22 1013","1895 22 1013 3","22 1013 3 in","1013 3 in the","incorporates python 1 6","1 or any part","to python 1 6","1 6 1 4","6 1 4 cnri","1 4 cnri is","making python 1 6","1 6 1 available","6 1 available to","1 available to licensee","1 6 1 will","6 1 will not","1 will not infringe","users of python 1","1 6 1 for","6 1 for any","1 for any incidental","1 or any derivative","governed by the federal","by the federal intellectual","the federal intellectual property","federal intellectual property law","intellectual property law of","property law of the","law of the united","the united states including","united states including without","states including without limitation","without limitation the federal","limitation the federal copyright","the federal copyright law","federal copyright law and","copyright law and to","law and to the","the extent such u","extent such u s","such u s federal","u s federal law","s federal law does","federal law does not","law does not apply","does not apply by","not apply by the","apply by the law","commonwealth of virginia excluding","of virginia excluding virginia","virginia excluding virginia s","excluding virginia s conflict","virginia s conflict of","of law provisions notwithstanding","law provisions notwithstanding the","provisions notwithstanding the foregoing","notwithstanding the foregoing with","the foregoing with regard","foregoing with regard to","with regard to derivative","regard to derivative works","to derivative works based","works based on python","based on python 1","on python 1 6","1 6 1 that","6 1 that incorporate","1 that incorporate non","that incorporate non separable","incorporate non separable material","non separable material that","separable material that was","material that was previously","that was previously distributed","was previously distributed under","previously distributed under the","distributed under the gnu","public license gpl the","license gpl the law","gpl the law of","commonwealth of virginia shall","of virginia shall govern","virginia shall govern this","shall govern this license","govern this license agreement","this license agreement only","license agreement only as"]},{"licenseTexts":["CNRI OPEN SOURCE LICENSE AGREEMENT\n\nIMPORTANT: PLEASE READ THE FOLLOWING AGREEMENT CAREFULLY.\n\nBY CLICKING ON \"ACCEPT\" WHERE INDICATED BELOW, OR BY COPYING, INSTALLING OR OTHERWISE USING PYTHON 1.6, beta 1 SOFTWARE, YOU ARE DEEMED TO HAVE AGREED TO THE TERMS AND CONDITIONS OF THIS LICENSE AGREEMENT.\n\n   1. This LICENSE AGREEMENT is between the Corporation for National Research Initiatives, having an office at 1895 Preston White Drive, Reston, VA 20191 (\"CNRI\"), and the Individual or Organization (\"Licensee\") accessing and otherwise using Python 1.6, beta 1 software in source or binary form and its associated documentation, as released at the www.python.org Internet site on August 4, 2000 (\"Python 1.6b1\").\n\n   2. Subject to the terms and conditions of this License Agreement, CNRI hereby grants Licensee a non-exclusive, royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivative works, distribute, and otherwise use Python 1.6b1 alone or in any derivative version, provided, however, that CNRIs License Agreement is retained in Python 1.6b1, alone or in any derivative version prepared by Licensee.\n\n   Alternately, in lieu of CNRIs License Agreement, Licensee may substitute the following text (omitting the quotes): \"Python 1.6, beta 1, is made available subject to the terms and conditions in CNRIs License Agreement. This Agreement may be located on the Internet using the following unique, persistent identifier (known as a handle): 1895.22/1011. This Agreement may also be obtained from a proxy server on the Internet using the URL:http://hdl.handle.net/1895.22/1011\".\n\n   3. In the event Licensee prepares a derivative work that is based on or incorporates Python 1.6b1 or any part thereof, and wants to make the derivative work available to the public as provided herein, then Licensee hereby agrees to indicate in any such work the nature of the modifications made to Python 1.6b1.\n\n   4. CNRI is making Python 1.6b1 available to Licensee on an \"AS IS\" basis. CNRI MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, CNRI MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 1.6b1 WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.\n\n   5. CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE SOFTWARE FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF USING, MODIFYING OR DISTRIBUTING PYTHON 1.6b1, OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.\n\n   6. This License Agreement will automatically terminate upon a material breach of its terms and conditions.\n\n   7. This License Agreement shall be governed by and interpreted in all respects by the law of the State of Virginia, excluding conflict of law provisions. Nothing in this License Agreement shall be deemed to create any relationship of agency, partnership, or joint venture between CNRI and Licensee. This License Agreement does not grant permission to use CNRI trademarks or trade name in a trademark sense to endorse or promote products or services of Licensee, or any third party.\n\n   8. By clicking on the \"ACCEPT\" button where indicated, or by copying, installing or otherwise using Python 1.6b1, Licensee agrees to be bound by the terms and conditions of this License Agreement.\n\nACCEPT"],"licenseIds":["CNRI-Python"],"keywords":["source license agreement important","open source license agreement important","source license agreement important please"]},{"licenseTexts":["Common Public Attribution License Version 1.0 (CPAL)\n\n   1. \"Definitions\"\n\n      1.0.1 \"Commercial Use\" means distribution or otherwise making the Covered Code available to a third party.\n\n      1.1 \"Contributor\" means each entity that creates or contributes to the creation of Modifications.\n\n      1.2 \"Contributor Version\" means the combination of the Original Code, prior Modifications used by a Contributor, and the Modifications made by that particular Contributor.\n\n      1.3 \"Covered Code\" means the Original Code or Modifications or the combination of the Original Code and Modifications, in each case including portions thereof.\n\n      1.4 \"Electronic Distribution Mechanism\" means a mechanism generally accepted in the software development community for the electronic transfer of data.\n\n      1.5 \"Executable\" means Covered Code in any form other than Source Code.\n\n      1.6 \"Initial Developer\" means the individual or entity identified as the Initial Developer in the Source Code notice required by Exhibit A.\n\n      1.7 \"Larger Work\" means a work which combines Covered Code or portions thereof with code not governed by the terms of this License.\n\n      1.8 \"License\" means this document.\n\n      1.8.1 \"Licensable\" means having the right to grant, to the maximum extent possible, whether at the time of the initial grant or subsequently acquired, any and all of the rights conveyed herein.\n\n      1.9 \"Modifications\" means any addition to or deletion from the substance or structure of either the Original Code or any previous Modifications. When Covered Code is released as a series of files, a Modification is:\n\n         A. Any addition to or deletion from the contents of a file containing Original Code or previous Modifications.\n\n         B. Any new file that contains any part of the Original Code or previous Modifications.\n\n      1.10 \"Original Code\" means Source Code of computer software code which is described in the Source Code notice required by Exhibit A as Original Code, and which, at the time of its release under this License is not already Covered Code governed by this License.\n\n      1.10.1 \"Patent Claims\" means any patent claim(s), now owned or hereafter acquired, including without limitation, method, process, and apparatus claims, in any patent Licensable by grantor.\n\n      1.11 \"Source Code\" means the preferred form of the Covered Code for making modifications to it, including all modules it contains, plus any associated interface definition files, scripts used to control compilation and installation of an Executable, or source code differential comparisons against either the Original Code or another well known, available Covered Code of the Contributor's choice. The Source Code can be in a compressed or archival form, provided the appropriate decompression or de-archiving software is widely available for no charge.\n\n      1.12 \"You\" (or \"Your\") means an individual or a legal entity exercising rights under, and complying with all of the terms of, this License or a future version of this License issued under Section 6.1. For legal entities, \"You\" includes any entity which controls, is controlled by, or is under common control with You. For purposes of this definition, \"control\" means (a) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (b) ownership of more than fifty percent (50%) of the outstanding shares or beneficial ownership of such entity.\n\n   2. Source Code License.\n\n      2.1 The Initial Developer Grant.\n\n      The Initial Developer hereby grants You a world-wide, royalty-free, non-exclusive license, subject to third party intellectual property claims:\n\n         (a) under intellectual property rights (other than patent or trademark) Licensable by Initial Developer to use, reproduce, modify, display, perform, sublicense and distribute the Original Code (or portions thereof) with or without Modifications, and/or as part of a Larger Work; and\n\n         (b) under Patents Claims infringed by the making, using or selling of Original Code, to make, have made, use, practice, sell, and offer for sale, and/or otherwise dispose of the Original Code (or portions thereof).\n\n         (c) the licenses granted in this Section 2.1(a) and (b) are effective on the date Initial Developer first distributes Original Code under the terms of this License.\n\n         (d) Notwithstanding Section 2.1(b) above, no patent license is granted: 1) for code that You delete from the Original Code; 2) separate from the Original Code; or 3) for infringements caused by: i) the modification of the Original Code or ii) the combination of the Original Code with other software or devices.\n\n      2.2 Contributor Grant.\n\n      Subject to third party intellectual property claims, each Contributor hereby grants You a world-wide, royalty-free, non-exclusive license\n\n         (a) under intellectual property rights (other than patent or trademark) Licensable by Contributor, to use, reproduce, modify, display, perform, sublicense and distribute the Modifications created by such Contributor (or portions thereof) either on an unmodified basis, with other Modifications, as Covered Code and/or as part of a Larger Work; and\n\n         (b) under Patent Claims infringed by the making, using, or selling of Modifications made by that Contributor either alone and/or in combination with its Contributor Version (or portions of such combination), to make, use, sell, offer for sale, have made, and/or otherwise dispose of: 1) Modifications made by that Contributor (or portions thereof); and 2) the combination of Modifications made by that Contributor with its Contributor Version (or portions of such combination).\n\n         (c) the licenses granted in Sections 2.2(a) and 2.2(b) are effective on the date Contributor first makes Commercial Use of the Covered Code.\n\n         (d) Notwithstanding Section 2.2(b) above, no patent license is granted: 1) for any code that Contributor has deleted from the Contributor Version; 2) separate from the Contributor Version; 3) for infringements caused by: i) third party modifications of Contributor Version or ii) the combination of Modifications made by that Contributor with other software (except as part of the Contributor Version) or other devices; or 4) under Patent Claims infringed by Covered Code in the absence of Modifications made by that Contributor.\n\n   3. Distribution Obligations.\n\n      3.1 Application of License.\n\n      The Modifications which You create or to which You contribute are governed by the terms of this License, including without limitation Section 2.2. The Source Code version of Covered Code may be distributed only under the terms of this License or a future version of this License released under Section 6.1, and You must include a copy of this License with every copy of the Source Code You distribute. You may not offer or impose any terms on any Source Code version that alters or restricts the applicable version of this License or the recipients' rights hereunder. However, You may include an additional document offering the additional rights described in Section 3.5.\n\n      3.2 Availability of Source Code.\n\n      Any Modification which You create or to which You contribute must be made available in Source Code form under the terms of this License either on the same media as an Executable version or via an accepted Electronic Distribution Mechanism to anyone to whom you made an Executable version available; and if made available via Electronic Distribution Mechanism, must remain available for at least twelve (12) months after the date it initially became available, or at least six (6) months after a subsequent version of that particular Modification has been made available to such recipients. You are responsible for ensuring that the Source Code version remains available even if the Electronic Distribution Mechanism is maintained by a third party.\n\n      3.3 Description of Modifications.\n\n      You must cause all Covered Code to which You contribute to contain a file documenting the changes You made to create that Covered Code and the date of any change. You must include a prominent statement that the Modification is derived, directly or indirectly, from Original Code provided by the Initial Developer and including the name of the Initial Developer in (a) the Source Code, and (b) in any notice in an Executable version or related documentation in which You describe the origin or ownership of the Covered Code.\n\n      3.4 Intellectual Property Matters\n\n         (a) Third Party Claims. If Contributor has knowledge that a license under a third party's intellectual property rights is required to exercise the rights granted by such Contributor under Sections 2.1 or 2.2, Contributor must include a text file with the Source Code distribution titled \"LEGAL\" which describes the claim and the party making the claim in sufficient detail that a recipient will know whom to contact. If Contributor obtains such knowledge after the Modification is made available as described in Section 3.2, Contributor shall promptly modify the LEGAL file in all copies Contributor makes available thereafter and shall take other steps (such as notifying appropriate mailing lists or newsgroups) reasonably calculated to inform those who received the Covered Code that new knowledge has been obtained.\n\n         (b) Contributor APIs. If Contributor's Modifications include an application programming interface and Contributor has knowledge of patent licenses which are reasonably necessary to implement that API, Contributor must also include this information in the LEGAL file.\n\n         (c) Representations. Contributor represents that, except as disclosed pursuant to Section 3.4(a) above, Contributor believes that Contributor's Modifications are Contributor's original creation(s) and/or Contributor has sufficient rights to grant the rights conveyed by this License.\n\n      3.5 Required Notices.\n\n      You must duplicate the notice in Exhibit A in each file of the Source Code. If it is not possible to put such notice in a particular Source Code file due to its structure, then You must include such notice in a location (such as a relevant directory) where a user would be likely to look for such a notice. If You created one or more Modification(s) You may add your name as a Contributor to the notice described in Exhibit A. You must also duplicate this License in any documentation for the Source Code where You describe recipients' rights or ownership rights relating to Covered Code. You may choose to offer, and to charge a fee for, warranty, support, indemnity or liability obligations to one or more recipients of Covered Code. However, You may do so only on Your own behalf, and not on behalf of the Initial Developer or any Contributor. You must make it absolutely clear than any such warranty, support, indemnity or liability obligation is offered by You alone, and You hereby agree to indemnify the Initial Developer and every Contributor for any liability incurred by the Initial Developer or such Contributor as a result of warranty, support, indemnity or liability terms You offer.\n\n      3.6 Distribution of Executable Versions.\n\n      You may distribute Covered Code in Executable form only if the requirements of Section 3.1-3.5 have been met for that Covered Code, and if You include a notice stating that the Source Code version of the Covered Code is available under the terms of this License, including a description of how and where You have fulfilled the obligations of Section 3.2. The notice must be conspicuously included in any notice in an Executable version, related documentation or collateral in which You describe recipients' rights relating to the Covered Code. You may distribute the Executable version of Covered Code or ownership rights under a license of Your choice, which may contain terms different from this License, provided that You are in compliance with the terms of this License and that the license for the Executable version does not attempt to limit or alter the recipient's rights in the Source Code version from the rights set forth in this License. If You distribute the Executable version under a different license You must make it absolutely clear that any terms which differ from this License are offered by You alone, not by the Initial Developer, Original Developer or any Contributor. You hereby agree to indemnify the Initial Developer, Original Developer and every Contributor for any liability incurred by the Initial Developer, Original Developer or such Contributor as a result of any such terms You offer.\n\n      3.7 Larger Works.\n\n      You may create a Larger Work by combining Covered Code with other code not governed by the terms of this License and distribute the Larger Work as a single product. In such a case, You must make sure the requirements of this License are fulfilled for the Covered Code.\n\n   4. Inability to Comply Due to Statute or Regulation.\n\n   If it is impossible for You to comply with any of the terms of this License with respect to some or all of the Covered Code due to statute, judicial order, or regulation then You must: (a) comply with the terms of this License to the maximum extent possible; and (b) describe the limitations and the code they affect. Such description must be included in the LEGAL file described in Section 3.4 and must be included with all distributions of the Source Code. Except to the extent prohibited by statute or regulation, such description must be sufficiently detailed for a recipient of ordinary skill to be able to understand it.\n\n   5. Application of this License.\n\n   This License applies to code to which the Initial Developer has attached the notice in Exhibit A and to related Covered Code.\n\n   6. Versions of the License.\n\n      6.1 New Versions.\n\n      Socialtext, Inc. (\"Socialtext\") may publish revised and/or new versions of the License from time to time. Each version will be given a distinguishing version number.\n\n      6.2 Effect of New Versions.\n\n      Once Covered Code has been published under a particular version of the License, You may always continue to use it under the terms of that version. You may also choose to use such Covered Code under the terms of any subsequent version of the License published by Socialtext. No one other than Socialtext has the right to modify the terms applicable to Covered Code created under this License.\n\n      6.3 Derivative Works.\n\n      If You create or use a modified version of this License (which you may only do in order to apply it to code which is not already Covered Code governed by this License), You must (a) rename Your license so that the phrases \"Socialtext\", \"CPAL\" or any confusingly similar phrase do not appear in your license (except to note that your license differs from this License) and (b) otherwise make it clear that Your version of the license contains terms which differ from the CPAL. (Filling in the name of the Initial Developer, Original Developer, Original Code or Contributor in the notice described in Exhibit A shall not of themselves be deemed to be modifications of this License.)\n\n   7. DISCLAIMER OF WARRANTY.\n\n   COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN \"AS IS\" BASIS, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT THE INITIAL DEVELOPER, ORIGINAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER.\n\n   8. TERMINATION.\n\n      8.1 This License and the rights granted hereunder will terminate automatically if You fail to comply with terms herein and fail to cure such breach within 30 days of becoming aware of the breach. All sublicenses to the Covered Code which are properly granted shall survive any termination of this License. Provisions which, by their nature, must remain in effect beyond the termination of this License shall survive.\n\n      8.2 If You initiate litigation by asserting a patent infringement claim (excluding declatory judgment actions) against Initial Developer, Original Developer or a Contributor (the Initial Developer, Original Developer or Contributor against whom You file such action is referred to as \"Participant\") alleging that:\n\n         (a) such Participant's Contributor Version directly or indirectly infringes any patent, then any and all rights granted by such Participant to You under Sections 2.1 and/or 2.2 of this License shall, upon 60 days notice from Participant terminate prospectively, unless if within 60 days after receipt of notice You either: (i) agree in writing to pay Participant a mutually agreeable reasonable royalty for Your past and future use of Modifications made by such Participant, or (ii) withdraw Your litigation claim with respect to the Contributor Version against such Participant. If within 60 days of notice, a reasonable royalty and payment arrangement are not mutually agreed upon in writing by the parties or the litigation claim is not withdrawn, the rights granted by Participant to You under Sections 2.1 and/or 2.2 automatically terminate at the expiration of the 60 day notice period specified above.\n\n         (b) any software, hardware, or device, other than such Participant's Contributor Version, directly or indirectly infringes any patent, then any rights granted to You by such Participant under Sections 2.1(b) and 2.2(b) are revoked effective as of the date You first made, used, sold, distributed, or had made, Modifications made by that Participant.\n\n      8.3 If You assert a patent infringement claim against Participant alleging that such Participant's Contributor Version directly or indirectly infringes any patent where such claim is resolved (such as by license or settlement) prior to the initiation of patent infringement litigation, then the reasonable value of the licenses granted by such Participant under Sections 2.1 or 2.2 shall be taken into account in determining the amount or value of any payment or license.\n\n      8.4 In the event of termination under Sections 8.1 or 8.2 above, all end user license agreements (excluding distributors and resellers) which have been validly granted by You or any distributor hereunder prior to termination shall survive termination.\n\n   9. LIMITATION OF LIABILITY.\n\n   UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER TORT (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL YOU, THE INITIAL DEVELOPER, ORIGINAL DEVELOPER, ANY OTHER CONTRIBUTOR, OR ANY DISTRIBUTOR OF COVERED CODE, OR ANY SUPPLIER OF ANY OF SUCH PARTIES, BE LIABLE TO ANY PERSON FOR ANY INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, COMPUTER FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER COMMERCIAL DAMAGES OR LOSSES, EVEN IF SUCH PARTY SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF LIABILITY SHALL NOT APPLY TO LIABILITY FOR DEATH OR PERSONAL INJURY RESULTING FROM SUCH PARTY'S NEGLIGENCE TO THE EXTENT APPLICABLE LAW PROHIBITS SUCH LIMITATION. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OR LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THIS EXCLUSION AND LIMITATION MAY NOT APPLY TO YOU.\n\n   10. U.S. GOVERNMENT END USERS.\n\n   The Covered Code is a \"commercial item,\" as that term is defined in 48 C.F.R. 2.101 (Oct. 1995), consisting of \"commercial computer software\" and \"commercial computer software documentation,\" as such terms are used in 48 C.F.R. 12.212 (Sept. 1995). Consistent with 48 C.F.R. 12.212 and 48 C.F.R. 227.7202-1 through 227.7202-4 (June 1995), all U.S. Government End Users acquire Covered Code with only those rights set forth herein.\n\n   11. MISCELLANEOUS.\n\n   This License represents the complete agreement concerning subject matter hereof. If any provision of this License is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable. This License shall be governed by California law provisions (except to the extent applicable law, if any, provides otherwise), excluding its conflict-of-law provisions. With respect to disputes in which at least one party is a citizen of, or an entity chartered or registered to do business in the United States of America, any litigation relating to this License shall be subject to the jurisdiction of the Federal Courts of the Northern District of California, with venue lying in Santa Clara County, California, with the losing party responsible for costs, including without limitation, court costs and reasonable attorneys' fees and expenses. The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded. Any law or regulation which provides that the language of a contract shall be construed against the drafter shall not apply to this License.\n\n   12. RESPONSIBILITY FOR CLAIMS.\n\n   As between Initial Developer, Original Developer and the Contributors, each party is responsible for claims and damages arising, directly or indirectly, out of its utilization of rights under this License and You agree to work with Initial Developer, Original Developer and Contributors to distribute such responsibility on an equitable basis. Nothing herein is intended or shall be deemed to constitute any admission of liability.\n\n   13. MULTIPLE-LICENSED CODE.\n\n   Initial Developer may designate portions of the Covered Code as Multiple-Licensed. Multiple-Licensed means that the Initial Developer permits you to utilize portions of the Covered Code under Your choice of the CPAL or the alternative licenses, if any, specified by the Initial Developer in the file described in Exhibit A.\n\n   14. ADDITIONAL TERM: ATTRIBUTION\n\n      (a) As a modest attribution to the organizer of the development of the Original Code (\"Original Developer\"), in the hope that its promotional value may help justify the time, money and effort invested in writing the Original Code, the Original Developer may include in Exhibit B (\"Attribution Information\") a requirement that each time an Executable and Source Code or a Larger Work is launched or initially run (which includes initiating a session), a prominent display of the Original Developer's Attribution Information (as defined below) must occur on the graphic user interface employed by the end user to access such Covered Code (which may include display on a splash screen), if any. The size of the graphic image should be consistent with the size of the other elements of the Attribution Information. If the access by the end user to the Executable and Source Code does not create a graphic user interface for access to the Covered Code, this obligation shall not apply. If the Original Code displays such Attribution Information in a particular form (such as in the form of a splash screen, notice at login, an \"about\" display, or dedicated attribution area on user interface screens), continued use of such form for that Attribution Information is one way of meeting this requirement for notice.\n\n      (b) Attribution information may only include a copyright notice, a brief phrase, graphic image and a URL (\"Attribution Information\") and is subject to the Attribution Limits as defined below. For these purposes, prominent shall mean display for sufficient duration to give reasonable notice to the user of the identity of the Original Developer and that if You include Attribution Information or similar information for other parties, You must ensure that the Attribution Information for the Original Developer shall be no less prominent than such Attribution Information or similar information for the other party. For greater certainty, the Original Developer may choose to specify in Exhibit B below that the above attribution requirement only applies to an Executable and Source Code resulting from the Original Code or any Modification, but not a Larger Work. The intent is to provide for reasonably modest attribution, therefore the Original Developer cannot require that You display, at any time, more than the following information as Attribution Information: (a) a copyright notice including the name of the Original Developer; (b) a word or one phrase (not exceeding 10 words); (c) one graphic image provided by the Original Developer; and (d) a URL (collectively, the \"Attribution Limits\").\n\n      (c) If Exhibit B does not include any Attribution Information, then there are no requirements for You to display any Attribution Information of the Original Developer.\n\n      (d) You acknowledge that all trademarks, service marks and/or trade names contained within the Attribution Information distributed with the Covered Code are the exclusive property of their owners and may only be used with the permission of their owners, or under circumstances otherwise permitted by law or as expressly set out in this License.\n\n   15. ADDITIONAL TERM: NETWORK USE.\n\n   The term \"External Deployment\" means the use, distribution, or communication of the Original Code or Modifications in any way such that the Original Code or Modifications may be used by anyone other than You, whether those works are distributed or communicated to those persons or made available as an application intended for use over a network. As an express condition for the grants of license hereunder, You must treat any External Deployment by You of the Original Code or Modifications as a distribution under section 3.1 and make Source Code available under Section 3.2. EXHIBIT A. Common Public Attribution License Version 1.0.\n\n\"The contents of this file are subject to the Common Public Attribution License Version 1.0 (the \"License\"); you may not use this file except in compliance with the License. You may obtain a copy of the License at _____________ . The License is based on the Mozilla Public License Version 1.1 but Sections 14 and 15 have been added to cover use of software over a computer network and provide for limited attribution for the Original Developer. In addition, Exhibit A has been modified to be consistent with Exhibit B.\n\nSoftware distributed under the License is distributed on an \"AS IS\" basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the specific language governing rights and limitations under the License.\n\nThe Original Code is ______________________ .\n\nThe Original Developer is not the Initial Developer and is __________ . If left blank, the Original Developer is the Initial Developer.\n\nThe Initial Developer of the Original Code is ____________ . All portions of the code written by ___________ are Copyright (c) _____ . All Rights Reserved.\n\nContributor ______________________ .\n\nAlternatively, the contents of this file may be used under the terms of the _____ license (the [___] License), in which case the provisions of [______] License are applicable instead of those above.\n\nIf you wish to allow use of your version of this file only under the terms of the [____] License and not to allow others to use your version of this file under the CPAL, indicate your decision by deleting the provisions above and replace them with the notice and other provisions required by the [___] License. If you do not delete the provisions above, a recipient may use your version of this file under either the CPAL or the [___] License.\"\n\n[NOTE: The text of this Exhibit A may differ slightly from the text of the notices in the Source Code files of the Original Code. You should use the text of this Exhibit A rather than the text found in the Original Code Source Code for Your Modifications.]\n\nEXHIBIT B. Attribution Information\n\nAttribution Copyright Notice: _______________________\n\nAttribution Phrase (not exceeding 10 words): _______________________\n\nAttribution URL: _______________________\n\nGraphic Image as provided in the Covered Code, if any.\n\nDisplay of Attribution Information is [required/not required] in Larger Works which are defined in the CPAL as a work which combines Covered Code or portions thereof with code not governed by the terms of the CPAL."],"licenseIds":["CPAL-1.0"],"keywords":["1 0 cpal","0 cpal 1","cpal 1 definitions","new versions socialtext","versions socialtext inc","socialtext inc socialtext","inc socialtext may","socialtext may publish","published by socialtext","by socialtext no","socialtext no one","other than socialtext","than socialtext has","socialtext has the","the phrases socialtext","phrases socialtext cpal","socialtext cpal or","cpal or any","from the cpal","the cpal filling","cpal filling in","original developer original","original developer any","a 14 additional","14 additional term","additional term attribution","term attribution a","attribution a as","to the organizer","the organizer of","organizer of the","original code original","code original developer","writing the original","developer may include","include in exhibit","information a requirement","or a larger","work is launched","launched or initially","or initially run","initially run which","run which includes","which includes initiating","includes initiating a","initiating a session","a session a","session a prominent","original developer s","developer s attribution","attribution information as","defined below must","below must occur","must occur on","occur on the","on the graphic","the graphic user","user interface employed","interface employed by","employed by the","user to access","to access such","access such covered","code which may","which may include","may include display","include display on","display on a","on a splash","splash screen if","screen if any","any the size","of the graphic","the graphic image","graphic image should","image should be","should be consistent","with the size","the other elements","other elements of","if the access","the access by","access by the","to the executable","source code does","create a graphic","a graphic user","user interface for","interface for access","covered code this","code this obligation","this obligation shall","obligation shall not","original code displays","code displays such","displays such attribution","attribution information in","a particular form","particular form such","of a splash","splash screen notice","screen notice at","notice at login","at login an","login an about","an about display","about display or","display or dedicated","or dedicated attribution","dedicated attribution area","attribution area on","area on user","on user interface","user interface screens","interface screens continued","screens continued use","continued use of","of such form","such form for","form for that","for that attribution","that attribution information","information is one","is one way","one way of","way of meeting","of meeting this","meeting this requirement","this requirement for","requirement for notice","for notice b","notice b attribution","attribution information may","information may only","may only include","a brief phrase","brief phrase graphic","phrase graphic image","graphic image and","image and a","and a url","a url attribution","url attribution information","attribution information and","information and is","and is subject","attribution limits as","limits as defined","below for these","these purposes prominent","purposes prominent shall","prominent shall mean","shall mean display","mean display for","display for sufficient","for sufficient duration","sufficient duration to","duration to give","to give reasonable","give reasonable notice","reasonable notice to","of the identity","the identity of","identity of the","and that if","you include attribution","include attribution information","for other parties","other parties you","parties you must","that the attribution","attribution information for","original developer shall","developer shall be","be no less","no less prominent","less prominent than","prominent than such","than such attribution","other party for","party for greater","certainty the original","developer may choose","choose to specify","to specify in","specify in exhibit","exhibit b below","b below that","below that the","source code resulting","code resulting from","any modification but","modification but not","not a larger","larger work the","work the intent","therefore the original","original developer cannot","developer cannot require","cannot require that"]},{"licenseTexts":["Common Public License Version 1.0\n\nTHE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS COMMON PUBLIC LICENSE (\"AGREEMENT\"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT. 1.\n\nDEFINITIONS\n\n\"Contribution\" means:\n\n   a) in the case of the initial Contributor, the initial code and documentation distributed under this Agreement, and\n\n   b) in the case of each subsequent Contributor:\n\n      i) changes to the Program, and\n\n      ii) additions to the Program;\n\nwhere such changes and/or additions to the Program originate from and are distributed by that particular Contributor. A Contribution 'originates' from a Contributor if it was added to the Program by such Contributor itself or anyone acting on such Contributor's behalf. Contributions do not include additions to the Program which: (i) are separate modules of software distributed in conjunction with the Program under their own license agreement, and (ii) are not derivative works of the Program.\n\n\"Contributor\" means any person or entity that distributes the Program.\n\n\"Licensed Patents \" mean patent claims licensable by a Contributor which are necessarily infringed by the use or sale of its Contribution alone or when combined with the Program.\n\n\"Program\" means the Contributions distributed in accordance with this Agreement.\n\n\"Recipient\" means anyone who receives the Program under this Agreement, including all Contributors. 2.\n\nGRANT OF RIGHTS\n\n   a) Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide, royalty-free copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, distribute and sublicense the Contribution of such Contributor, if any, and such derivative works, in source code and object code form.\n\n   b) Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide, royalty-free patent license under Licensed Patents to make, use, sell, offer to sell, import and otherwise transfer the Contribution of such Contributor, if any, in source code and object code form. This patent license shall apply to the combination of the Contribution and the Program if, at the time the Contribution is added by the Contributor, such addition of the Contribution causes such combination to be covered by the Licensed Patents. The patent license shall not apply to any other combinations which include the Contribution. No hardware per se is licensed hereunder.\n\n   c) Recipient understands that although each Contributor grants the licenses to its Contributions set forth herein, no assurances are provided by any Contributor that the Program does not infringe the patent or other intellectual property rights of any other entity. Each Contributor disclaims any liability to Recipient for claims brought by any other entity based on infringement of intellectual property rights or otherwise. As a condition to exercising the rights and licenses granted hereunder, each Recipient hereby assumes sole responsibility to secure any other intellectual property rights needed, if any. For example, if a third party patent license is required to allow Recipient to distribute the Program, it is Recipient's responsibility to acquire that license before distributing the Program.\n\n   d) Each Contributor represents that to its knowledge it has sufficient copyright rights in its Contribution, if any, to grant the copyright license set forth in this Agreement. 3.\n\nREQUIREMENTS\n\nA Contributor may choose to distribute the Program in object code form under its own license agreement, provided that:\n\n   a) it complies with the terms and conditions of this Agreement; and\n\n   b) its license agreement:\n\n      i) effectively disclaims on behalf of all Contributors all warranties and conditions, express and implied, including warranties or conditions of title and non-infringement, and implied warranties or conditions of merchantability and fitness for a particular purpose;\n\n      ii) effectively excludes on behalf of all Contributors all liability for damages, including direct, indirect, special, incidental and consequential damages, such as lost profits;\n\n      iii) states that any provisions which differ from this Agreement are offered by that Contributor alone and not by any other party; and\n\n      iv) states that source code for the Program is available from such Contributor, and informs licensees how to obtain it in a reasonable manner on or through a medium customarily used for software exchange.\n\nWhen the Program is made available in source code form:\n\n   a) it must be made available under this Agreement; and\n\n   b) a copy of this Agreement must be included with each copy of the Program.\n\n   Contributors may not remove or alter any copyright notices contained within the Program.\n\n   Each Contributor must identify itself as the originator of its Contribution, if any, in a manner that reasonably allows subsequent Recipients to identify the originator of the Contribution. 4.\n\nCOMMERCIAL DISTRIBUTION\n\nCommercial distributors of software may accept certain responsibilities with respect to end users, business partners and the like. While this license is intended to facilitate the commercial use of the Program, the Contributor who includes the Program in a commercial product offering should do so in a manner which does not create potential liability for other Contributors. Therefore, if a Contributor includes the Program in a commercial product offering, such Contributor (\"Commercial Contributor\") hereby agrees to defend and indemnify every other Contributor (\"Indemnified Contributor\") against any losses, damages and costs (collectively \"Losses\") arising from claims, lawsuits and other legal actions brought by a third party against the Indemnified Contributor to the extent caused by the acts or omissions of such Commercial Contributor in connection with its distribution of the Program in a commercial product offering. The obligations in this section do not apply to any claims or Losses relating to any actual or alleged intellectual property infringement. In order to qualify, an Indemnified Contributor must: a) promptly notify the Commercial Contributor in writing of such claim, and b) allow the Commercial Contributor to control, and cooperate with the Commercial Contributor in, the defense and any related settlement negotiations. The Indemnified Contributor may participate in any such claim at its own expense.\n\nFor example, a Contributor might include the Program in a commercial product offering, Product X. That Contributor is then a Commercial Contributor. If that Commercial Contributor then makes performance claims, or offers warranties related to Product X, those performance claims and warranties are such Commercial Contributor's responsibility alone. Under this section, the Commercial Contributor would have to defend claims against the other Contributors related to those performance claims and warranties, and if a court requires any other Contributor to pay any damages as a result, the Commercial Contributor must pay those damages. 5.\n\nNO WARRANTY\n\nEXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED ON AN \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely responsible for determining the appropriateness of using and distributing the Program and assumes all risks associated with its exercise of rights under this Agreement, including but not limited to the risks and costs of program errors, compliance with applicable laws, damage to or loss of data, programs or equipment, and unavailability or interruption of operations. 6.\n\nDISCLAIMER OF LIABILITY\n\nEXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. 7.\n\nGENERAL\n\nIf any provision of this Agreement is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this Agreement, and without further action by the parties hereto, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.\n\nIf Recipient institutes patent litigation against a Contributor with respect to a patent applicable to software (including a cross-claim or counterclaim in a lawsuit), then any patent licenses granted by that Contributor to such Recipient under this Agreement shall terminate as of the date such litigation is filed. In addition, if Recipient institutes patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Program itself (excluding combinations of the Program with other software or hardware) infringes such Recipient's patent(s), then such Recipient's rights granted under Section 2(b) shall terminate as of the date such litigation is filed.\n\nAll Recipient's rights under this Agreement shall terminate if it fails to comply with any of the material terms or conditions of this Agreement and does not cure such failure in a reasonable period of time after becoming aware of such noncompliance. If all Recipient's rights under this Agreement terminate, Recipient agrees to cease use and distribution of the Program as soon as reasonably practicable. However, Recipient's obligations under this Agreement and any licenses granted by Recipient relating to the Program shall continue and survive.\n\nEveryone is permitted to copy and distribute copies of this Agreement, but in order to avoid inconsistency the Agreement is copyrighted and may only be modified in the following manner. The Agreement Steward reserves the right to publish new versions (including revisions) of this Agreement from time to time. No one other than the Agreement Steward has the right to modify this Agreement. IBM is the initial Agreement Steward. IBM may assign the responsibility to serve as the Agreement Steward to a suitable separate entity. Each new version of the Agreement will be given a distinguishing version number. The Program (including Contributions) may always be distributed subject to the version of the Agreement under which it was received. In addition, after a new version of the Agreement is published, Contributor may elect to distribute the Program (including its Contributions) under the new version. Except as expressly stated in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to the intellectual property of any Contributor under this Agreement, whether expressly, by implication, estoppel or otherwise. All rights in the Program not expressly granted under this Agreement are reserved.\n\nThis Agreement is governed by the laws of the State of New York and the intellectual property laws of the United States of America. No party to this Agreement will bring a legal action under this Agreement more than one year after the cause of action arose. Each party waives its rights to a jury trial in any resulting litigation."],"licenseIds":["CPL-1.0"],"keywords":["of this common","this common public","this agreement ibm","agreement ibm is","ibm is the","agreement steward ibm","steward ibm may","ibm may assign","terms of this common","of this common public","this common public license","common public license agreement","modify this agreement ibm","this agreement ibm is","agreement ibm is the","ibm is the initial","initial agreement steward ibm","agreement steward ibm may","steward ibm may assign","ibm may assign the","the terms of this common","terms of this common public","of this common public license","this common public license agreement","common public license agreement any","to modify this agreement ibm","modify this agreement ibm is","this agreement ibm is the","agreement ibm is the initial","ibm is the initial agreement","the initial agreement steward ibm","initial agreement steward ibm may","agreement steward ibm may assign","steward ibm may assign the","ibm may assign the responsibility"]},{"licenseTexts":["The Code Project Open License (CPOL) 1.02\n\nPreamble\n\nThis License governs Your use of the Work. This License is intended to allow developers to use the Source Code and Executable Files provided as part of the Work in any application in any form.\n\nThe main points subject to the terms of the License are:\n\n   - Source Code and Executable Files can be used in commercial applications;\n\n   - Source Code and Executable Files can be redistributed; and\n\n   - Source Code can be modified to create derivative works.\n\n   - No claim of suitability, guarantee, or any warranty whatsoever is provided. The software is provided \"as-is\".\n\n   - The Article accompanying the Work may not be distributed or republished without the Author's consent\n\nThis License is entered between You, the individual or other entity reading or otherwise making use of the Work licensed pursuant to this License and the individual or other entity which offers the Work under the terms of this License (\"Author\").\n\nLicense\n\nTHE WORK (AS DEFINED BELOW) IS PROVIDED UNDER THE TERMS OF THIS CODE PROJECT OPEN LICENSE (\"LICENSE\"). THE WORK IS PROTECTED BY COPYRIGHT AND/OR OTHER APPLICABLE LAW. ANY USE OF THE WORK OTHER THAN AS AUTHORIZED UNDER THIS LICENSE OR COPYRIGHT LAW IS PROHIBITED.\n\nBY EXERCISING ANY RIGHTS TO THE WORK PROVIDED HEREIN, YOU ACCEPT AND AGREE TO BE BOUND BY THE TERMS OF THIS LICENSE. THE AUTHOR GRANTS YOU THE RIGHTS CONTAINED HEREIN IN CONSIDERATION OF YOUR ACCEPTANCE OF SUCH TERMS AND CONDITIONS. IF YOU DO NOT AGREE TO ACCEPT AND BE BOUND BY THE TERMS OF THIS LICENSE, YOU CANNOT MAKE ANY USE OF THE WORK.\n\n   1. Definitions.\n\n      a. \"Articles\" means, collectively, all articles written by Author which describes how the Source Code and Executable Files for the Work may be used by a user.\n\n      b. \"Author\" means the individual or entity that offers the Work under the terms of this License.\n\n      c. \"Derivative Work\" means a work based upon the Work or upon the Work and other pre-existing works.\n\n      d. \"Executable Files\" refer to the executables, binary files, configuration and any required data files included in the Work.\n\n      e. \"Publisher\" means the provider of the website, magazine, CD-ROM, DVD or other medium from or by which the Work is obtained by You.\n\n      f. \"Source Code\" refers to the collection of source code and configuration files used to create the Executable Files.\n\n      g. \"Standard Version\" refers to such a Work if it has not been modified, or has been modified in accordance with the consent of the Author, such consent being in the full discretion of the Author.\n\n      h. \"Work\" refers to the collection of files distributed by the Publisher, including the Source Code, Executable Files, binaries, data files, documentation, whitepapers and the Articles.\n\n      i. \"You\" is you, an individual or entity wishing to use the Work and exercise your rights under this License.\n\n   2. Fair Use/Fair Use Rights. Nothing in this License is intended to reduce, limit, or restrict any rights arising from fair use, fair dealing, first sale or other limitations on the exclusive rights of the copyright owner under copyright law or other applicable laws.\n\n   3. License Grant. Subject to the terms and conditions of this License, the Author hereby grants You a worldwide, royalty-free, non-exclusive, perpetual (for the duration of the applicable copyright) license to exercise the rights in the Work as stated below:\n\n      a. You may use the standard version of the Source Code or Executable Files in Your own applications.\n\n      b. You may apply bug fixes, portability fixes and other modifications obtained from the Public Domain or from the Author. A Work modified in such a way shall still be considered the standard version and will be subject to this License.\n\n      c. You may otherwise modify Your copy of this Work (excluding the Articles) in any way to create a Derivative Work, provided that You insert a prominent notice in each changed file stating how, when and where You changed that file.\n\n      d. You may distribute the standard version of the Executable Files and Source Code or Derivative Work in aggregate with other (possibly commercial) programs as part of a larger (possibly commercial) software distribution.\n\n      e. The Articles discussing the Work published in any form by the author may not be distributed or republished without the Author's consent. The author retains copyright to any such Articles. You may use the Executable Files and Source Code pursuant to this License but you may not repost or republish or otherwise distribute or make available the Articles, without the prior written consent of the Author.\n\n   Any subroutines or modules supplied by You and linked into the Source Code or Executable Files of this Work shall not be considered part of this Work and will not be subject to the terms of this License.\n\n   4. Patent License. Subject to the terms and conditions of this License, each Author hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, import, and otherwise transfer the Work.\n\n   5. Restrictions. The license granted in Section 3 above is expressly made subject to and limited by the following restrictions:\n\n      a. You agree not to remove any of the original copyright, patent, trademark, and attribution notices and associated disclaimers that may appear in the Source Code or Executable Files.\n\n      b. You agree not to advertise or in any way imply that this Work is a product of Your own.\n\n      c. The name of the Author may not be used to endorse or promote products derived from the Work without the prior written consent of the Author.\n\n      d. You agree not to sell, lease, or rent any part of the Work. This does not restrict you from including the Work or any part of the Work inside a larger software distribution that itself is being sold. The Work by itself, though, cannot be sold, leased or rented.\n\n      e. You may distribute the Executable Files and Source Code only under the terms of this License, and You must include a copy of, or the Uniform Resource Identifier for, this License with every copy of the Executable Files or Source Code You distribute and ensure that anyone receiving such Executable Files and Source Code agrees that the terms of this License apply to such Executable Files and/or Source Code. You may not offer or impose any terms on the Work that alter or restrict the terms of this License or the recipients' exercise of the rights granted hereunder. You may not sublicense the Work. You must keep intact all notices that refer to this License and to the disclaimer of warranties. You may not distribute the Executable Files or Source Code with any technological measures that control access or use of the Work in a manner inconsistent with the terms of this License.\n\n      f. You agree not to use the Work for illegal, immoral or improper purposes, or on pages containing illegal, immoral or improper material. The Work is subject to applicable export laws. You agree to comply with all such laws and regulations that may apply to the Work after Your receipt of the Work.\n\n   6. Representations, Warranties and Disclaimer. THIS WORK IS PROVIDED \"AS IS\", \"WHERE IS\" AND \"AS AVAILABLE\", WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES OR CONDITIONS OR GUARANTEES. YOU, THE USER, ASSUME ALL RISK IN ITS USE, INCLUDING COPYRIGHT INFRINGEMENT, PATENT INFRINGEMENT, SUITABILITY, ETC. AUTHOR EXPRESSLY DISCLAIMS ALL EXPRESS, IMPLIED OR STATUTORY WARRANTIES OR CONDITIONS, INCLUDING WITHOUT LIMITATION, WARRANTIES OR CONDITIONS OF MERCHANTABILITY, MERCHANTABLE QUALITY OR FITNESS FOR A PARTICULAR PURPOSE, OR ANY WARRANTY OF TITLE OR NON-INFRINGEMENT, OR THAT THE WORK (OR ANY PORTION THEREOF) IS CORRECT, USEFUL, BUG-FREE OR FREE OF VIRUSES. YOU MUST PASS THIS DISCLAIMER ON WHENEVER YOU DISTRIBUTE THE WORK OR DERIVATIVE WORKS.\n\n   7. Indemnity. You agree to defend, indemnify and hold harmless the Author and the Publisher from and against any claims, suits, losses, damages, liabilities, costs, and expenses (including reasonable legal or attorneys' fees) resulting from or relating to any use of the Work by You.\n\n   8. Limitation on Liability. EXCEPT TO THE EXTENT REQUIRED BY APPLICABLE LAW, IN NO EVENT WILL THE AUTHOR OR THE PUBLISHER BE LIABLE TO YOU ON ANY LEGAL THEORY FOR ANY SPECIAL, INCIDENTAL, CONSEQUENTIAL, PUNITIVE OR EXEMPLARY DAMAGES ARISING OUT OF THIS LICENSE OR THE USE OF THE WORK OR OTHERWISE, EVEN IF THE AUTHOR OR THE PUBLISHER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\n   9. Termination.\n\n      a. This License and the rights granted hereunder will terminate automatically upon any breach by You of any term of this License. Individuals or entities who have received Derivative Works from You under this License, however, will not have their licenses terminated provided such individuals or entities remain in full compliance with those licenses. Sections 1, 2, 6, 7, 8, 9, 10 and 11 will survive any termination of this License.\n\n      b. If You bring a copyright, trademark, patent or any other infringement claim against any contributor over infringements You claim are made by the Work, your License from such contributor to the Work ends automatically.\n\n      c. Subject to the above terms and conditions, this License is perpetual (for the duration of the applicable copyright in the Work). Notwithstanding the above, the Author reserves the right to release the Work under different license terms or to stop distributing the Work at any time; provided, however that any such election will not serve to withdraw this License (or any other license that has been, or is required to be, granted under the terms of this License), and this License will continue in full force and effect unless terminated as stated above.\n\n   10. Publisher. The parties hereby confirm that the Publisher shall not, under any circumstances, be responsible for and shall not have any liability in respect of the subject matter of this License. The Publisher makes no warranty whatsoever in connection with the Work and shall not be liable to You or any party on any legal theory for any damages whatsoever, including without limitation any general, special, incidental or consequential damages arising in connection to this license. The Publisher reserves the right to cease making the Work available to You at any time without notice\n\n   11. Miscellaneous\n\n      a. This License shall be governed by the laws of the location of the head office of the Author or if the Author is an individual, the laws of location of the principal place of residence of the Author.\n\n      b. If any provision of this License is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this License, and without further action by the parties to this License, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.\n\n      c. No term or provision of this License shall be deemed waived and no breach consented to unless such waiver or consent shall be in writing and signed by the party to be charged with such waiver or consent.\n\n      d. This License constitutes the entire agreement between the parties with respect to the Work licensed herein. There are no understandings, agreements or representations with respect to the Work not specified herein. The Author shall not be bound by any additional provisions that may appear in any communication from You. This License may not be modified without the mutual written agreement of the Author and You."],"licenseIds":["CPOL-1.02"],"keywords":["the code project","open license cpol","license cpol 1","cpol 1 02","1 02 preamble","02 preamble this","license governs your","governs your use","to allow developers","allow developers to","developers to use","executable files provided","files provided as","provided as part","in any application","any application in","application in any","any form the","form the main","the main points","main points subject","points subject to","license are source","are source code","used in commercial","in commercial applications","commercial applications source","can be redistributed","be redistributed and","redistributed and source","modified to create","derivative works no","works no claim","no claim of","claim of suitability","of suitability guarantee","suitability guarantee or","guarantee or any","warranty whatsoever is","whatsoever is provided","is provided the","provided the software","is the article","the article accompanying","article accompanying the","accompanying the work","work may not","s consent this","license is entered","is entered between","entered between you","between you the","you the individual","other entity reading","entity reading or","reading or otherwise","otherwise making use","making use of","work licensed pursuant","other entity which","entity which offers","which offers the","this license author","license author license","author license the","this code project","open license license","license license the","work provided herein","provided herein you","herein you accept","the author grants","author grants you","rights contained herein","contained herein in","herein in consideration","agree to accept","to accept and","accept and be","and be bound","license you cannot","you cannot make","cannot make any","the work 1","work 1 definitions","definitions a articles","a articles means","articles means collectively","means collectively all","collectively all articles","all articles written","articles written by","written by author","by author which","author which describes","which describes how","describes how the","how the source","executable files for","by a user","a user b","user b author","b author means","c derivative work","existing works d","works d executable","d executable files","executable files refer","files refer to","to the executables","the executables binary","executables binary files","binary files configuration","files configuration and","configuration and any","and any required","any required data","required data files","data files included","work e publisher","e publisher means","publisher means the","means the provider","the provider of","provider of the","of the website","the website magazine","website magazine cd","magazine cd rom","cd rom dvd","rom dvd or","dvd or other","or other medium","other medium from","medium from or","from or by","or by which","work is obtained","is obtained by","obtained by you","by you f","you f source","f source code","source code refers","collection of source","code and configuration","configuration files used","files used to","create the executable","executable files g","files g standard","g standard version","a work if","work if it","the author such","author such consent","such consent being","consent being in","being in the","in the full","the full discretion","full discretion of","the author h","author h work","h work refers","work refers to","by the publisher","the publisher including","publisher including the","source code executable","code executable files","executable files binaries","files binaries data","binaries data files","data files documentation","files documentation whitepapers","documentation whitepapers and","whitepapers and the","and the articles","the articles i","articles i you","i you is","is you an","or entity wishing","entity wishing to","wishing to use","work and exercise","and exercise your","exercise your rights","license 2 fair","use fair use","fair dealing first","dealing first sale","the author hereby","below a you","executable files in","files in your","your own applications","own applications b","applications b you"]},{"licenseTexts":["CUA Office Public License Version 1.0\n\n   1. Definitions.\n\n      1.0.1. \"Commercial Use\" means distribution or otherwise making the Covered Code available to a third party.\n\n      1.1. \"Contributor\" means each entity that creates or contributes to the creation of Modifications.\n\n      1.2. \"Contributor Version\" means the combination of the Original Code, prior Modifications used by a Contributor, and the Modifications made by that particular Contributor.\n\n      1.3. \"Covered Code\" means the Original Code or Modifications or the combination of the Original Code and Modifications, in each case including portions thereof.\n\n      1.4. \"Electronic Distribution Mechanism\" means a mechanism generally accepted in the software development community for the electronic transfer of data.\n\n      1.5. \"Executable\" means Covered Code in any form other than Source Code.\n\n      1.6. \"Initial Developer\" means the individual or entity identified as the Initial Developer in the Source Code notice required by Exhibit A.\n\n      1.7. \"Larger Work\" means a work which combines Covered Code or portions thereof with code not governed by the terms of this License.\n\n      1.8. \"License\" means this document.\n\n      1.8.1. \"Licensable\" means having the right to grant, to the maximum extent possible, whether at the time of the initial grant or subsequently acquired, any and all of the rights conveyed herein.\n\n      1.9. \"Modifications\" means any addition to or deletion from the substance or structure of either the Original Code or any previous Modifications. When Covered Code is released as a series of files, a Modification is:\n\n         A. Any addition to or deletion from the contents of a file containing Original Code or previous Modifications.\n\n         B. Any new file that contains any part of the Original Code or previous Modifications.\n\n      1.10. \"Original Code\" means Source Code of computer software code which is described in the Source Code notice required by Exhibit A as Original Code, and which, at the time of its release under this License is not already Covered Code governed by this License.\n\n      1.10.1. \"Patent Claims\" means any patent claim(s), now owned or hereafter acquired, including without limitation, method, process, and apparatus claims, in any patent Licensable by grantor.\n\n      1.11. \"Source Code\" means the preferred form of the Covered Code for making modifications to it, including all modules it contains, plus any associated interface definition files, scripts used to control compilation and installation of an Executable, or source code differential comparisons against either the Original Code or another well known, available Covered Code of the Contributor's choice. The Source Code can be in a compressed or archival form, provided the appropriate decompression or de-archiving software is widely available for no charge.\n\n      1.12. \"You\" (or \"Your\") means an individual or a legal entity exercising rights under, and complying with all of the terms of, this License or a future version of this License issued under Section 6.1. For legal entities, \"You\" includes any entity which controls, is controlled by, or is under common control with You. For purposes of this definition, \"control\" means (a) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (b) ownership of more than fifty percent (50%) of the outstanding shares or beneficial ownership of such entity.\n\n   2. Source Code License.\n\n      2.1. The Initial Developer Grant. The Initial Developer hereby grants You a world-wide, royalty-free, non-exclusive license, subject to third party intellectual property claims:\n\n         (a) under intellectual property rights (other than patent or trademark) Licensable by Initial Developer to use, reproduce, modify, display, perform, sublicense and distribute the Original Code (or portions thereof) with or without Modifications, and/or as part of a Larger Work; and\n\n         (b) under Patents Claims infringed by the making, using or selling of Original Code, to make, have made, use, practice, sell, and offer for sale, and/or otherwise dispose of the Original Code (or portions thereof).\n\n         (c) the licenses granted in this Section 2.1(a) and (b) are effective on the date Initial Developer first distributes Original Code under the terms of this License.\n\n         (d) Notwithstanding Section 2.1(b) above, no patent license is granted: 1) for code that You delete from the Original Code; 2) separate from the Original Code; or 3) for infringements caused by: i) the modification of the Original Code or ii) the combination of the Original Code with other software or devices.\n\n      2.2. Contributor Grant. Subject to third party intellectual property claims, each Contributor hereby grants You a world-wide, royalty-free, non-exclusive license\n\n         (a) under intellectual property rights (other than patent or trademark) Licensable by Contributor, to use, reproduce, modify, display, perform, sublicense and distribute the Modifications created by such Contributor (or portions thereof) either on an unmodified basis, with other Modifications, as Covered Code and/or as part of a Larger Work; and\n\n         (b) under Patent Claims infringed by the making, using, or selling of Modifications made by that Contributor either alone and/or in combination with its Contributor Version (or portions of such combination), to make, use, sell, offer for sale, have made, and/or otherwise dispose of: 1) Modifications made by that Contributor (or portions thereof); and 2) the combination of Modifications made by that Contributor with its Contributor Version (or portions of such combination).\n\n         (c) the licenses granted in Sections 2.2(a) and 2.2(b) are effective on the date Contributor first makes Commercial Use of the Covered Code.\n\n         (d) Notwithstanding Section 2.2(b) above, no patent license is granted: 1) for any code that Contributor has deleted from the Contributor Version; 2) separate from the Contributor Version; 3) for infringements caused by: i) third party modifications of Contributor Version or ii) the combination of Modifications made by that Contributor with other software (except as part of the Contributor Version) or other devices; or 4) under Patent Claims infringed by Covered Code in the absence of Modifications made by that Contributor.\n\n   3. Distribution Obligations.\n\n      3.1. Application of License. The Modifications which You create or to which You contribute are governed by the terms of this License, including without limitation Section 2.2. The Source Code version of Covered Code may be distributed only under the terms of this License or a future version of this License released under Section 6.1, and You must include a copy of this License with every copy of the Source Code You distribute. You may not offer or impose any terms on any Source Code version that alters or restricts the applicable version of this License or the recipients' rights hereunder. However, You may include an additional document offering the additional rights described in Section 3.5.\n\n      3.2. Availability of Source Code. Any Modification which You create or to which You contribute must be made available in Source Code form under the terms of this License either on the same media as an Executable version or via an accepted Electronic Distribution Mechanism to anyone to whom you made an Executable version available; and if made available via Electronic Distribution Mechanism, must remain available for at least twelve (12) months after the date it initially became available, or at least six (6) months after a subsequent version of that particular Modification has been made available to such recipients. You are responsible for ensuring that the Source Code version remains available even if the Electronic Distribution Mechanism is maintained by a third party.\n\n      3.3. Description of Modifications. You must cause all Covered Code to which You contribute to contain a file documenting the changes You made to create that Covered Code and the date of any change. You must include a prominent statement that the Modification is derived, directly or indirectly, from Original Code provided by the Initial Developer and including the name of the Initial Developer in (a) the Source Code, and (b) in any notice in an Executable version or related documentation in which You describe the origin or ownership of the Covered Code.\n\n      3.4. Intellectual Property Matters\n\n         (a) Third Party Claims. If Contributor has knowledge that a license under a third party's intellectual property rights is required to exercise the rights granted by such Contributor under Sections 2.1 or 2.2, Contributor must include a text file with the Source Code distribution titled \"LEGAL\" which describes the claim and the party making the claim in sufficient detail that a recipient will know whom to contact. If Contributor obtains such knowledge after the Modification is made available as described in Section 3.2, Contributor shall promptly modify the LEGAL file in all copies Contributor makes available thereafter and shall take other steps (such as notifying appropriate mailing lists or newsgroups) reasonably calculated to inform those who received the Covered Code that new knowledge has been obtained.\n\n         (b) Contributor APIs. If Contributor's Modifications include an application programming interface and Contributor has knowledge of patent licenses which are reasonably necessary to implement that API, Contributor must also include this information in the LEGAL file.\n\n         (c) Representations. Contributor represents that, except as disclosed pursuant to Section 3.4(a) above, Contributor believes that Contributor's Modifications are Contributor's original creation(s) and/or Contributor has sufficient rights to grant the rights conveyed by this License.\n\n      3.5. Required Notices. You must duplicate the notice in Exhibit A in each file of the Source Code. If it is not possible to put such notice in a particular Source Code file due to its structure, then You must include such notice in a location (such as a relevant directory) where a user would be likely to look for such a notice. If You created one or more Modification(s) You may add your name as a Contributor to the notice described in Exhibit A. You must also duplicate this License in any documentation for the Source Code where You describe recipients' rights or ownership rights relating to Covered Code. You may choose to offer, and to charge a fee for, warranty, support, indemnity or liability obligations to one or more recipients of Covered Code. However, You may do so only on Your own behalf, and not on behalf of the Initial Developer or any Contributor. You must make it absolutely clear than any such warranty, support, indemnity or liability obligation is offered by You alone, and You hereby agree to indemnify the Initial Developer and every Contributor for any liability incurred by the Initial Developer or such Contributor as a result of warranty, support, indemnity or liability terms You offer.\n\n      3.6. Distribution of Executable Versions. You may distribute Covered Code in Executable form only if the requirements of Section 3.1-3.5 have been met for that Covered Code, and if You include a notice stating that the Source Code version of the Covered Code is available under the terms of this License, including a description of how and where You have fulfilled the obligations of Section 3.2. The notice must be conspicuously included in any notice in an Executable version, related documentation or collateral in which You describe recipients' rights relating to the Covered Code. You may distribute the Executable version of Covered Code or ownership rights under a license of Your choice, which may contain terms different from this License, provided that You are in compliance with the terms of this License and that the license for the Executable version does not attempt to limit or alter the recipient's rights in the Source Code version from the rights set forth in this License. If You distribute the Executable version under a different license You must make it absolutely clear that any terms which differ from this License are offered by You alone, not by the Initial Developer or any Contributor. You hereby agree to indemnify the Initial Developer and every Contributor for any liability incurred by the Initial Developer or such Contributor as a result of any such terms You offer.\n\n      3.7. Larger Works. You may create a Larger Work by combining Covered Code with other code not governed by the terms of this License and distribute the Larger Work as a single product. In such a case, You must make sure the requirements of this License are fulfilled for the Covered Code.\n\n   4. Inability to Comply Due to Statute or Regulation.\n\n   If it is impossible for You to comply with any of the terms of this License with respect to some or all of the Covered Code due to statute, judicial order, or regulation then You must: (a) comply with the terms of this License to the maximum extent possible; and (b) describe the limitations and the code they affect. Such description must be included in the LEGAL file described in Section 3.4 and must be included with all distributions of the Source Code. Except to the extent prohibited by statute or regulation, such description must be sufficiently detailed for a recipient of ordinary skill to be able to understand it.\n\n   5. Application of this License.\n\n   This License applies to code to which the Initial Developer has attached the notice in Exhibit A and to related Covered Code.\n\n   6. Versions of the License.\n\n      6.1. New Versions. CUA Office Project may publish revised and/or new versions of the License from time to time. Each version will be given a distinguishing version number.\n\n      6.2. Effect of New Versions. Once Covered Code has been published under a particular version of the License, You may always continue to use it under the terms of that version. You may also choose to use such Covered Code under the terms of any subsequent version of the License published by CUA Office Project. No one other than CUA Office Project has the right to modify the terms applicable to Covered Code created under this License.\n\n      6.3. Derivative Works. If You create or use a modified version of this License (which you may only do in order to apply it to code which is not already Covered Code governed by this License), You must (a) rename Your license so that the phrases \"CUA Office\", \"CUA\", \"CUAPL\", or any confusingly similar phrase do not appear in your license (except to note that your license differs from this License) and (b) otherwise make it clear that Your version of the license contains terms which differ from the CUA Office Public License. (Filling in the name of the Initial Developer, Original Code or Contributor in the notice described in Exhibit A shall not of themselves be deemed to be modifications of this License.)\n\n   7. DISCLAIMER OF WARRANTY.\n\n   COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN \"AS IS\" BASIS, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER.\n\n   8. TERMINATION.\n\n      8.1. This License and the rights granted hereunder will terminate automatically if You fail to comply with terms herein and fail to cure such breach within 30 days of becoming aware of the breach. All sublicenses to the Covered Code which are properly granted shall survive any termination of this License. Provisions which, by their nature, must remain in effect beyond the termination of this License shall survive.\n\n      8.2. If You initiate litigation by asserting a patent infringement claim (excluding declatory judgment actions) against Initial Developer or a Contributor (the Initial Developer or Contributor against whom You file such action is referred to as \"Participant\") alleging that:\n\n         (a) such Participant's Contributor Version directly or indirectly infringes any patent, then any and all rights granted by such Participant to You under Sections 2.1 and/or 2.2 of this License shall, upon 60 days notice from Participant terminate prospectively, unless if within 60 days after receipt of notice You either: (i) agree in writing to pay Participant a mutually agreeable reasonable royalty for Your past and future use of Modifications made by such Participant, or (ii) withdraw Your litigation claim with respect to the Contributor Version against such Participant. If within 60 days of notice, a reasonable royalty and payment arrangement are not mutually agreed upon in writing by the parties or the litigation claim is not withdrawn, the rights granted by Participant to You under Sections 2.1 and/or 2.2 automatically terminate at the expiration of the 60 day notice period specified above.\n\n         (b) any software, hardware, or device, other than such Participant's Contributor Version, directly or indirectly infringes any patent, then any rights granted to You by such Participant under Sections 2.1(b) and 2.2(b) are revoked effective as of the date You first made, used, sold, distributed, or had made, Modifications made by that Participant.\n\n      8.3. If You assert a patent infringement claim against Participant alleging that such Participant's Contributor Version directly or indirectly infringes any patent where such claim is resolved (such as by license or settlement) prior to the initiation of patent infringement litigation, then the reasonable value of the licenses granted by such Participant under Sections 2.1 or 2.2 shall be taken into account in determining the amount or value of any payment or license.\n\n      8.4. In the event of termination under Sections 8.1 or 8.2 above, all end user license agreements (excluding distributors and resellers) which have been validly granted by You or any distributor hereunder prior to termination shall survive termination.\n\n   9. LIMITATION OF LIABILITY.\n\n   UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER TORT (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL YOU, THE INITIAL DEVELOPER, ANY OTHER CONTRIBUTOR, OR ANY DISTRIBUTOR OF COVERED CODE, OR ANY SUPPLIER OF ANY OF SUCH PARTIES, BE LIABLE TO ANY PERSON FOR ANY INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, COMPUTER FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER COMMERCIAL DAMAGES OR LOSSES, EVEN IF SUCH PARTY SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF LIABILITY SHALL NOT APPLY TO LIABILITY FOR DEATH OR PERSONAL INJURY RESULTING FROM SUCH PARTY'S NEGLIGENCE TO THE EXTENT APPLICABLE LAW PROHIBITS SUCH LIMITATION. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OR LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THIS EXCLUSION AND LIMITATION MAY NOT APPLY TO YOU.\n\n   10. U.S. GOVERNMENT END USERS.\n\n   The Covered Code is a \"commercial item,\" as that term is defined in 48 C.F.R. 2.101 (Oct. 1995), consisting of \"commercial computer software\" and \"commercial computer software documentation,\" as such terms are used in 48 C.F.R. 12.212 (Sept. 1995). Consistent with 48 C.F.R. 12.212 and 48 C.F.R. 227.7202-1 through 227.7202-4 (June 1995), all U.S. Government End Users acquire Covered Code with only those rights set forth herein.\n\n   11. MISCELLANEOUS.\n\n   This License represents the complete agreement concerning subject matter hereof. If any provision of this License is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable. This License shall be governed by California law provisions (except to the extent applicable law, if any, provides otherwise), excluding its conflict-of-law provisions. With respect to disputes in which at least one party is a citizen of, or an entity chartered or registered to do business in the United States of America, any litigation relating to this License shall be subject to the jurisdiction of the Federal Courts of the Northern District of California, with venue lying in Santa Clara County, California, with the losing party responsible for costs, including without limitation, court costs and reasonable attorneys' fees and expenses. The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded. Any law or regulation which provides that the language of a contract shall be construed against the drafter shall not apply to this License.\n\n   12. RESPONSIBILITY FOR CLAIMS.\n\n   As between Initial Developer and the Contributors, each party is responsible for claims and damages arising, directly or indirectly, out of its utilization of rights under this License and You agree to work with Initial Developer and Contributors to distribute such responsibility on an equitable basis. Nothing herein is intended or shall be deemed to constitute any admission of liability.\n\n   13. MULTIPLE-LICENSED CODE.\n\n   Initial Developer may designate portions of the Covered Code as \"Multiple-Licensed\". \"Multiple-Licensed\" means that the Initial Developer permits you to utilize portions of the Covered Code under Your choice of the NPL or the alternative licenses, if any, specified by the Initial Developer in the file described in Exhibit A. EXHIBIT A - CUA Office Public License.\n\n\"The contents of this file are subject to the CUA Office Public License Version 1.0 (the \"License\"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://cuaoffice.sourceforge.net/\n\nSoftware distributed under the License is distributed on an \"AS IS\" basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the specific language governing rights and limitations under the License.\n\nThe Original Code is ______________________________________ .\n\nThe Initial Developer of the Original Code is ________________________ . Portions created by ______________________ are Copyright (C) ______ _______________________ . All Rights Reserved.\n\nContributor(s): ______________________________________ .\n\nAlternatively, the contents of this file may be used under the terms of the _____ license (the \" [___] License\"), in which case the provisions of [______] License are applicable instead of those above. If you wish to allow use of your version of this file only under the terms of the [____] License and not to allow others to use your version of this file under the CUAPL, indicate your decision by deleting the provisions above and replace them with the notice and other provisions required by the [___] License. If you do not delete the provisions above, a recipient may use your version of this file under either the CUAPL or the [___] License.\"\n\n[NOTE: The text of this Exhibit A may differ slightly from the text of the notices in the Source Code files of the Original Code. You should use the text of this Exhibit A rather than the text found in the Original Code Source Code for Your Modifications.]"],"licenseIds":["CUA-OPL-1.0"],"keywords":["new versions cua","versions cua office","office project may","project may publish","published by cua","by cua office","office project no","project no one","other than cua","than cua office","office project has","project has the","the phrases cua","phrases cua office","cua office cua","office cua cuapl","cua cuapl or","cuapl or any","from the cua","exhibit a cua","a cua office","to the cua","at http cuaoffice","http cuaoffice sourceforge","cuaoffice sourceforge net","sourceforge net software","net software distributed","under the cuapl","the cuapl indicate","cuapl indicate your","either the cuapl","the cuapl or","cuapl or the","1 new versions cua","new versions cua office","versions cua office project","cua office project may","office project may publish","project may publish revised","license published by cua","published by cua office","by cua office project","cua office project no","office project no one","project no one other","one other than cua","other than cua office","than cua office project","cua office project has","office project has the","project has the right","that the phrases cua","the phrases cua office","phrases cua office cua","cua office cua cuapl","office cua cuapl or","cua cuapl or any","cuapl or any confusingly","differ from the cua","from the cua office","office public license filling","a exhibit a cua","exhibit a cua office","a cua office public","office public license the","subject to the cua","to the cua office","license at http cuaoffice","at http cuaoffice sourceforge","http cuaoffice sourceforge net","cuaoffice sourceforge net software","sourceforge net software distributed","net software distributed under","file under the cuapl","under the cuapl indicate","the cuapl indicate your","cuapl indicate your decision","under either the cuapl","either the cuapl or","the cuapl or the","cuapl or the license","6 1 new versions cua","1 new versions cua office","new versions cua office project","versions cua office project may","cua office project may publish","office project may publish revised","project may publish revised and","the license published by cua","license published by cua office","published by cua office project","by cua office project no","cua office project no one","office project no one other","project no one other than","no one other than cua","one other than cua office","other than cua office project","than cua office project has","cua office project has the","office project has the right","project has the right to","so that the phrases cua","that the phrases cua office","the phrases cua office cua","phrases cua office cua cuapl","cua office cua cuapl or","office cua cuapl or any","cua cuapl or any confusingly","cuapl or any confusingly similar","which differ from the cua","differ from the cua office","from the cua office public","cua office public license filling","office public license filling in","exhibit a exhibit a cua","a exhibit a cua office","exhibit a cua office public","a cua office public license","cua office public license the","office public license the contents","are subject to the cua","subject to the cua office","to the cua office public","the license at http cuaoffice","license at http cuaoffice sourceforge","at http cuaoffice sourceforge net","http cuaoffice sourceforge net software","cuaoffice sourceforge net software distributed","sourceforge net software distributed under","net software distributed under the","this file under the cuapl","file under the cuapl indicate","under the cuapl indicate your","the cuapl indicate your decision","cuapl indicate your decision by","file under either the cuapl","under either the cuapl or","either the cuapl or the","the cuapl or the license","cuapl or the license note"]},{"licenseTexts":["Caldera International, Inc. hereby grants a fee free license that includes the rights use, modify and distribute this named source code, including creating derived binary products created from the source code. The source code for which Caldera International, Inc. grants rights are limited to the following UNIX Operating Systems that operate on the 16-Bit PDP-11 CPU and early versions of the 32-Bit UNIX Operating System, with specific exclusion of UNIX System III and UNIX System V and successor operating systems:\n\n32-bit 32V UNIX\n\n16 bit UNIX Versions 1, 2, 3, 4, 5, 6, 7\n\nCaldera International, Inc. makes no guarantees or commitments that any source code is available from Caldera International, Inc.\n\nThe following copyright notice applies to the source code files for which this license is granted.\n\nCopyright(C) Caldera International Inc. 2001-2002. All rights reserved.\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\nRedistributions of source code and documentation must retain the above copyright notice, this list of conditions and the following disclaimer.\n\nRedistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\nAll advertising materials mentioning features or use of this software must display the following acknowledgement:\n\n   \n\n   This product includes software developed or owned by Caldera International, Inc.\n\nNeither the name of Caldera International, Inc. nor the names of other contributors may be used to endorse or promote products derived from this software without specific prior written permission.\n\nUSE OF THE SOFTWARE PROVIDED FOR UNDER THIS LICENSE BY CALDERA INTERNATIONAL, INC. AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL CALDERA INTERNATIONAL, INC. BE LIABLE FOR ANY DIRECT, INDIRECT INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."],"licenseIds":["Caldera"],"keywords":["international inc hereby","inc hereby grants","hereby grants a","grants a fee","a fee free","fee free license","free license that","license that includes","includes the rights","the rights use","rights use modify","distribute this named","this named source","named source code","code including creating","including creating derived","creating derived binary","derived binary products","binary products created","products created from","code for which","for which caldera","which caldera international","international inc grants","inc grants rights","grants rights are","rights are limited","the following unix","following unix operating","unix operating systems","operating systems that","systems that operate","that operate on","operate on the","on the 16","the 16 bit","16 bit pdp","bit pdp 11","pdp 11 cpu","11 cpu and","cpu and early","and early versions","early versions of","of the 32","the 32 bit","32 bit unix","bit unix operating","unix operating system","operating system with","system with specific","with specific exclusion","specific exclusion of","exclusion of unix","of unix system","unix system iii","system iii and","iii and unix","and unix system","unix system v","system v and","v and successor","and successor operating","successor operating systems","operating systems 32","systems 32 bit","32 bit 32v","bit 32v unix","32v unix 16","unix 16 bit","16 bit unix","bit unix versions","unix versions 1","6 7 caldera","7 caldera international","international inc makes","no guarantees or","guarantees or commitments","or commitments that","commitments that any","available from caldera","from caldera international","international inc the","inc the following","copyright notice applies","notice applies to","code files for","files for which","for which this","is granted copyright","granted copyright c","copyright c caldera","c caldera international","international inc 2001","inc 2001 2002","2001 2002 all","and documentation must","documentation must retain","the distribution all","distribution all advertising","software developed or","developed or owned","owned by caldera","international inc neither","inc neither the","name of caldera","of caldera international","international inc nor","names of other","other contributors may","written permission use","permission use of","software provided for","license by caldera","international inc and","event shall caldera","shall caldera international","international inc be","caldera international inc hereby","international inc hereby grants","inc hereby grants a","hereby grants a fee","grants a fee free","a fee free license","fee free license that","free license that includes","license that includes the","that includes the rights","includes the rights use","the rights use modify","rights use modify and","and distribute this named","distribute this named source","this named source code","named source code including","source code including creating","code including creating derived","including creating derived binary","creating derived binary products","derived binary products created","binary products created from","products created from the","created from the source","source code for which","code for which caldera","for which caldera international","which caldera international inc","caldera international inc grants","international inc grants rights","inc grants rights are","grants rights are limited","rights are limited to","are limited to the","to the following unix","the following unix operating","following unix operating systems","unix operating systems that","operating systems that operate","systems that operate on","that operate on the","operate on the 16","on the 16 bit","the 16 bit pdp","16 bit pdp 11","bit pdp 11 cpu","pdp 11 cpu and","11 cpu and early","cpu and early versions","and early versions of","early versions of the","versions of the 32","of the 32 bit","the 32 bit unix","32 bit unix operating","bit unix operating system","unix operating system with","operating system with specific","system with specific exclusion","with specific exclusion of","specific exclusion of unix","exclusion of unix system","of unix system iii","unix system iii and","system iii and unix","iii and unix system","and unix system v","unix system v and","system v and successor","v and successor operating","and successor operating systems","successor operating systems 32","operating systems 32 bit","systems 32 bit 32v","32 bit 32v unix","bit 32v unix 16","32v unix 16 bit","unix 16 bit unix","16 bit unix versions","bit unix versions 1","unix versions 1 2","versions 1 2 3"]},{"licenseTexts":["The Clarified Artistic License\n\nPreamble\n\nThe intent of this document is to state the conditions under which a Package may be copied, such that the Copyright Holder maintains some semblance of artistic control over the development of the package, while giving the users of the package the right to use and distribute the Package in a more-or-less customary fashion, plus the right to make reasonable modifications.\n\nDefinitions:\n\n\"Package\" refers to the collection of files distributed by the Copyright Holder, and derivatives of that collection of files created through textual modification.\n\n\"Standard Version\" refers to such a Package if it has not been modified, or has been modified in accordance with the wishes of the Copyright Holder as specified below.\n\n\"Copyright Holder\" is whoever is named in the copyright or copyrights for the package.\n\n\"You\" is you, if you're thinking about copying or distributing this Package.\n\n\"Distribution fee\" is a fee you charge for providing a copy of this Package to another party.\n\n\"Freely Available\" means that no fee is charged for the right to use the item, though there may be fees involved in handling the item. It also means that recipients of the item may redistribute it under the same conditions they received it.\n\n   1. You may make and give away verbatim copies of the source form of the Standard Version of this Package without restriction, provided that you duplicate all of the original copyright notices and associated disclaimers.\n\n   2. You may apply bug fixes, portability fixes and other modifications derived from the Public Domain, or those made Freely Available, or from the Copyright Holder. A Package modified in such a way shall still be considered the Standard Version.\n\n   3. You may otherwise modify your copy of this Package in any way, provided that you insert a prominent notice in each changed file stating how and when you changed that file, and provided that you do at least ONE of the following:\n\n      a) place your modifications in the Public Domain or otherwise make them Freely Available, such as by posting said modifications to Usenet or an equivalent medium, or placing the modifications on a major network archive site allowing unrestricted access to them, or by allowing the Copyright Holder to include your modifications in the Standard Version of the Package.\n\n      b) use the modified Package only within your corporation or organization.\n\n      c) rename any non-standard executables so the names do not conflict with standard executables, which must also be provided, and provide a separate manual page for each non-standard executable that clearly documents how it differs from the Standard Version.\n\n      d) make other distribution arrangements with the Copyright Holder.\n\n      e) permit and encourge anyone who receives a copy of the modified Package permission to make your modifications Freely Available in some specific way.\n\n   4. You may distribute the programs of this Package in object code or executable form, provided that you do at least ONE of the following:\n\n      a) distribute a Standard Version of the executables and library files, together with instructions (in the manual page or equivalent) on where to get the Standard Version.\n\n      b) accompany the distribution with the machine-readable source of the Package with your modifications.\n\n      c) give non-standard executables non-standard names, and clearly document the differences in manual pages (or equivalent), together with instructions on where to get the Standard Version.\n\n      d) make other distribution arrangements with the Copyright Holder.\n\n      e) offer the machine-readable source of the Package, with your modifications, by mail order.\n\n   5. You may charge a distribution fee for any distribution of this Package. If you offer support for this Package, you may charge any fee you choose for that support. You may not charge a license fee for the right to use this Package itself. You may distribute this Package in aggregate with other (possibly commercial and possibly nonfree) programs as part of a larger (possibly commercial and possibly nonfree) software distribution, and charge license fees for other parts of that software distribution, provided that you do not advertise this Package as a product of your own. If the Package includes an interpreter, You may embed this Package's interpreter within an executable of yours (by linking); this shall be construed as a mere form of aggregation, provided that the complete Standard Version of the interpreter is so embedded.\n\n   6. The scripts and library files supplied as input to or produced as output from the programs of this Package do not automatically fall under the copyright of this Package, but belong to whoever generated them, and may be sold commercially, and may be aggregated with this Package. If such scripts or library files are aggregated with this Package via the so-called \"undump\" or \"unexec\" methods of producing a binary executable image, then distribution of such an image shall neither be construed as a distribution of this Package nor shall it fall under the restrictions of Paragraphs 3 and 4, provided that you do not represent such an executable image as a Standard Version of this Package.\n\n   7. C subroutines (or comparably compiled subroutines in other languages) supplied by you and linked into this Package in order to emulate subroutines and variables of the language defined by this Package shall not be considered part of this Package, but are the equivalent of input as in Paragraph 6, provided these subroutines do not change the language in any way that would cause it to fail the regression tests for the language.\n\n   8. Aggregation of the Standard Version of the Package with a commercial distribution is always permitted provided that the use of this Package is embedded; that is, when no overt attempt is made to make this Package's interfaces visible to the end user of the commercial distribution. Such use shall not be construed as a distribution of this Package.\n\n   9. The name of the Copyright Holder may not be used to endorse or promote products derived from this software without specific prior written permission.\n\n   10. THIS PACKAGE IS PROVIDED \"AS IS\" AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. The End"],"licenseIds":["ClArtistic"],"keywords":["the clarified artistic","clarified artistic license","this package distribution","package distribution fee","distribution fee is","fee is a","is a fee","fee you charge","charge for providing","another party freely","party freely available","use the item","the item though","item though there","domain or those","or those made","those made freely","freely available or","available or from","a major network","major network archive","network archive site","archive site allowing","site allowing unrestricted","allowing unrestricted access","unrestricted access to","access to them","to them or","them or by","holder e permit","e permit and","permit and encourge","and encourge anyone","encourge anyone who","modified package permission","package permission to","make your modifications","your modifications freely","modifications freely available","available in some","in some specific","some specific way","specific way 4","way 4 you","holder e offer","e offer the","offer the machine","modifications by mail","by mail order","mail order 5","order 5 you","if you offer","you offer support","offer support for","choose for that","for that support","that support you","support you may","charge a license","license fee for","use this package","package itself you","possibly nonfree programs","nonfree programs as","possibly nonfree software","nonfree software distribution","software distribution and","distribution and charge","and charge license","charge license fees","license fees for","for other parts","parts of that","that software distribution","your own if","own if the","includes an interpreter","an interpreter you","interpreter you may","aggregation of the","the clarified artistic license","clarified artistic license preamble","distributing this package distribution","this package distribution fee","package distribution fee is","distribution fee is a","fee is a fee","is a fee you","a fee you charge","fee you charge for","you charge for providing","charge for providing a","for providing a copy","to another party freely","another party freely available","party freely available means","charged for the right","to use the item","use the item though","the item though there","item though there may","public domain or those","domain or those made","or those made freely","those made freely available","made freely available or","freely available or from","available or from the","on a major network","a major network archive","major network archive site","network archive site allowing","archive site allowing unrestricted","site allowing unrestricted access","allowing unrestricted access to","unrestricted access to them","access to them or","to them or by","them or by allowing","copyright holder e permit","holder e permit and","e permit and encourge","permit and encourge anyone","and encourge anyone who","encourge anyone who receives","of the modified package","the modified package permission","modified package permission to","package permission to make","permission to make your","to make your modifications","make your modifications freely","your modifications freely available","modifications freely available in","freely available in some","available in some specific","in some specific way","some specific way 4","specific way 4 you","way 4 you may","copyright holder e offer","holder e offer the","e offer the machine","offer the machine readable","with your modifications by","your modifications by mail","modifications by mail order","by mail order 5","mail order 5 you","order 5 you may","distribution fee for any","of this package if","this package if you","package if you offer","if you offer support","you offer support for","offer support for this","for this package you","you choose for that","choose for that support","for that support you","that support you may","support you may not","not charge a license","charge a license fee","a license fee for","license fee for the","fee for the right","right to use this","to use this package","use this package itself","this package itself you","package itself you may","itself you may distribute","other possibly commercial and","and possibly nonfree programs","possibly nonfree programs as","nonfree programs as part","larger possibly commercial and","and possibly nonfree software","possibly nonfree software distribution","nonfree software distribution and","software distribution and charge","distribution and charge license","and charge license fees","charge license fees for","license fees for other","fees for other parts","for other parts of","other parts of that","parts of that software","of that software distribution","that software distribution provided","of your own if","your own if the","own if the package","package includes an interpreter","includes an interpreter you","an interpreter you may","interpreter you may embed"]},{"licenseTexts":["Condor Public License\n\nVersion 1.1, October 30, 2003 Copyright © 1990-2006 Condor Team, Computer Sciences Department, University of Wisconsin-Madison, Madison, WI. All Rights Reserved. For more information contact: Condor Team, Attention: Professor Miron Livny, Dept of Computer Sciences, 1210 W. Dayton St., Madison, WI 53706-1685, (608) 262-0856 or miron@cs.wisc.edu.\n\nThis software referred to as the Condor® Version 6.x software (\"Software\") was developed by the Condor Project, Condor Team, Computer Sciences Department, University of Wisconsin-Madison, under the authority of the Board of Regents of the University of Wisconsin System and includes voluntary contributions made to the Condor Project (\"Copyright Holders and Contributors and the University\"). For more information on the Condor Project, please see http://www.condorproject.org/.\n\nInstallation, use, reproduction, display, modification and redistribution of this Software, with or without modification, in source and binary forms, are permitted. Any exercise of rights under this license including sublicenses by you is subject to the following conditions:\n\n   1. Redistributions of this Software, with or without modification, must reproduce this Condor Public License in: (1) the Software, and (2) any user documentation or other similar material which is provided with the Software.\n\n   \n\n   2. Any user documentation included with a redistribution must include the following notice:\n\n   \"This product includes software from the Condor® Project (http://www.condorproject.org/)\"\n\n   Alternatively, if that is where third-party acknowledgments normally appear, this acknowledgment must be reproduced in the Software itself.\n\n   3. Any academic report, publication, or other academic disclosure of results obtained with this Software will acknowledge this Software's use by an appropriate citation.\n\n   4. The name Condor® is a registered trademark of the University of Wisconsin-Madison. The trademark may not be used to endorse or promote software, or products derived therefrom, and, other than as required by section 2 and 3 above, it may not be affixed to modified redistributions of this Software without the prior written approval, obtainable via email to condor-admin@cs.wisc.edu.\n\n   5. To the extent that patent claims licensable by the University of Wisconsin-Madison are necessarily infringed by the use or sale of the Software, you are granted a non-exclusive, worldwide, royalty- free perpetual license under such patent claims, with the rights for you to make, use, sell, offer to sell, import and otherwise transfer the Software in source code and object code form and derivative works. This patent license shall apply to the combination of the Software with other software if, at the time the Software is added by you, such addition of the Software causes such combination to be covered by such patent claims. This patent license shall not apply to any other combinations which include the Software. No hardware per se is licensed hereunder.If you or any subsequent sub-licensee (a ``Recipient\") institutes patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Software infringes such Recipient's patent(s), then such Recipient's rights granted (directly or indirectly) under the patent license above shall terminate as of the date such litigation is filed. All sublicenses to the Software which have been properly granted prior to termination shall survive any termination of said patent license, if not otherwise terminated pursuant to this section.\n\n   6. DISCLAIMER\n\n   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS AND THE UNIVERSITY \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, OF SATISFACTORY QUALITY, AND FITNESS FOR A PARTICULAR PURPOSE OR USE ARE DISCLAIMED. THE COPYRIGHT HOLDERS AND CONTRIBUTORS AND THE UNIVERSITY MAKE NO REPRESENTATION THAT THE SOFTWARE, MODIFICATIONS, ENHANCEMENTS OR DERIVATIVE WORKS THEREOF, WILL NOT INFRINGE ANY PATENT, COPYRIGHT, TRADEMARK, TRADE SECRET OR OTHER PROPRIETARY RIGHT.\n\n   7. LIMITATION OF LIABILITY\n\n   THE COPYRIGHT HOLDERS AND CONTRIBUTORS AND ANY OTHER OFFICER, AGENT, OR EMPLOYEE OF THE UNIVERSITY SHALL HAVE NO LIABILITY TO LICENSEE OR OTHER PERSONS FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, CONSEQUENTIAL, EXEMPLARY, OR PUNITIVE DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT LIMITATION, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, LOSS OF USE, DATA OR PROFITS, OR BUSINESS INTERRUPTION, HOWEVER CAUSED AND ON ANY THEORY OF CONTRACT, WARRANTY, TORT (INCLUDING NEGLIGENCE), PRODUCT LIABILITY OR OTHERWISE, ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\n   8. Certain uses and transfers of the Software or documentation, and/or items or software incorporating the Condor Software or documentation, may require a license under U.S. Export Control laws. Licensee represents and warrants that all uses and transfers of the Condor Software or documentation and/or any items or software incorporating Condor shall be in compliance with U.S. Export Control laws, and Licensee further understands that failure to comply with such export control laws may result in criminal liability to Licensee under U.S. laws.\n\n   9. The Condor Team may publish revised and/or new versions of this Condor Public License (``this License\") from time to time. Each version will be given a distinguishing version number. Once Software has been published under a particular version of this License, you may always continue to use it under the terms of that version. You may also choose to use such Software under the terms of any subsequent version of this License published by the Condor Team. No one other than the Condor Team has the right to modify the terms of this License. For more information:\n\nCondor Team\n\nAttention: Professor Miron Livny\n\n7367 Computer Sciences\n\n1210 W. Dayton St.\n\nMadison, WI 53706-1685\n\nmiron@cs.wisc.edu\n\nhttp://pages.cs.wisc.edu/~miron/miron.html"],"licenseIds":["Condor-1.1"],"keywords":["1 1 october","1 october 30","october 30 2003","30 2003 copyright","2003 copyright 1990","copyright 1990 2006","1990 2006 condor","2006 condor team","wisconsin madison madison","madison madison wi","madison wi all","wi all rights","reserved for more","more information contact","information contact condor","contact condor team","miron livny dept","livny dept of","dept of computer","of computer sciences","53706 1685 608","1685 608 262","608 262 0856","262 0856 or","0856 or miron","or miron cs","wisc edu this","this software referred","software referred to","as the condor","the condor version","condor version 6","version 6 x","6 x software","x software software","software software was","software was developed","condor project condor","project condor team","wisconsin madison under","madison under the","under the authority","the authority of","authority of the","of the board","the board of","board of regents","of regents of","of wisconsin system","wisconsin system and","system and includes","and includes voluntary","to the condor","condor project copyright","project copyright holders","the university for","university for more","on the condor","condor project please","condorproject org installation","license including sublicenses","including sublicenses by","sublicenses by you","you is subject","must reproduce this","reproduce this condor","license in 1","in 1 the","1 the software","and 2 any","user documentation or","documentation or other","other similar material","similar material which","material which is","software 2 any","includes software from","from the condor","condor project http","condorproject org alternatively","itself 3 any","3 any academic","any academic report","academic report publication","report publication or","publication or other","or other academic","other academic disclosure","academic disclosure of","disclosure of results","of results obtained","results obtained with","obtained with this","this software will","software will acknowledge","will acknowledge this","acknowledge this software","this software s","s use by","use by an","by an appropriate","an appropriate citation","appropriate citation 4","citation 4 the","the name condor","name condor is","condor is a","wisconsin madison the","madison the trademark","the trademark may","trademark may not","derived therefrom and","therefrom and other","and other than","than as required","by section 2","section 2 and","3 above it","above it may","not be affixed","be affixed to","affixed to modified","to modified redistributions","written approval obtainable","approval obtainable via","obtainable via email","email to condor","to condor admin","condor admin cs","admin cs wisc","wisc edu 5","edu 5 to","5 to the","extent that patent","that patent claims","wisconsin madison are","madison are necessarily","sale of the","are granted a","granted a non","perpetual license under","license under such","under such patent","patent claims with","claims with the","the rights for","rights for you","transfer the software","form and derivative","works this patent","other software if","time the software","software is added","by you such","you such addition","the software causes","software causes such","covered by such","by such patent","patent claims this","claims this patent","include the software","software no hardware","hereunder if you","any subsequent sub","subsequent sub licensee","sub licensee a","licensee a recipient","a recipient institutes","software infringes such","or indirectly under","indirectly under the","under the patent","patent license above","license above shall","above shall terminate","filed all sublicenses","termination of said","of said patent","said patent license","patent license if","license if not","if not otherwise","not otherwise terminated","otherwise terminated pursuant","terminated pursuant to","6 disclaimer this","the university as","university as is","disclaimed the copyright","the university make","patent copyright trademark","copyright trademark trade","trademark trade secret","proprietary right 7","right 7 limitation","liability the copyright","contributors and any","any other officer","other officer agent"]},{"licenseTexts":["Copyright (C) 1995-2009 Gerd Neugebauer\n\ncwpuzzle.dtx is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY. No author or distributor accepts responsibility to anyone for the consequences of using it or for whether it serves any particular purpose or works at all, unless he says so in writing.\n\n.\n\nEveryone is granted permission to copy, modify and redistribute cwpuzzle.dtx, provided this copyright notice is preserved and any modifications are indicated."],"licenseIds":["Crossword"],"keywords":["c 1995 2009","1995 2009 gerd","2009 gerd neugebauer","gerd neugebauer cwpuzzle","neugebauer cwpuzzle dtx","cwpuzzle dtx is","dtx is distributed","any warranty no","warranty no author","using it or","it or for","unless he says","he says so","and redistribute cwpuzzle","redistribute cwpuzzle dtx","cwpuzzle dtx provided","dtx provided this","provided this copyright","is preserved and","preserved and any","any modifications are","modifications are indicated","copyright c 1995 2009","c 1995 2009 gerd","1995 2009 gerd neugebauer","2009 gerd neugebauer cwpuzzle","gerd neugebauer cwpuzzle dtx","neugebauer cwpuzzle dtx is","cwpuzzle dtx is distributed","dtx is distributed in","without any warranty no","any warranty no author","warranty no author or","consequences of using it","of using it or","using it or for","it or for whether","all unless he says","unless he says so","he says so in","modify and redistribute cwpuzzle","and redistribute cwpuzzle dtx","redistribute cwpuzzle dtx provided","cwpuzzle dtx provided this","dtx provided this copyright","provided this copyright notice","copyright notice is preserved","notice is preserved and","is preserved and any","preserved and any modifications","and any modifications are","any modifications are indicated","copyright c 1995 2009 gerd","c 1995 2009 gerd neugebauer","1995 2009 gerd neugebauer cwpuzzle","2009 gerd neugebauer cwpuzzle dtx","gerd neugebauer cwpuzzle dtx is","neugebauer cwpuzzle dtx is distributed","cwpuzzle dtx is distributed in","dtx is distributed in the","but without any warranty no","without any warranty no author","any warranty no author or","warranty no author or distributor","the consequences of using it","consequences of using it or","of using it or for","using it or for whether","it or for whether it","at all unless he says","all unless he says so","unless he says so in","he says so in writing","copy modify and redistribute cwpuzzle","modify and redistribute cwpuzzle dtx","and redistribute cwpuzzle dtx provided","redistribute cwpuzzle dtx provided this","cwpuzzle dtx provided this copyright","dtx provided this copyright notice","provided this copyright notice is","this copyright notice is preserved","copyright notice is preserved and","notice is preserved and any","is preserved and any modifications","preserved and any modifications are","and any modifications are indicated"]},{"licenseTexts":["Crystal Stacker is freeware. This means you can pass copies around freely provided you include this document in it's original form in your distribution. Please see the \"Contacting Us\" section of this document if you need to contact us for any reason.\n\nDisclaimer\n\nNewCreature Design makes no guarantees regarding the Crystal Stacker software. We are not responsible for damages caused by it, though the software is not known to cause any problems. If you have trouble with the software, see the \"Contacting Us\" section of this document.\n\nThe source code is provided as-is and you may do with it whatsoever you please provided that you include this file in its unmodified form with any new distribution. NewCreature Design makes no gaurantees regarding the usability of the source but are willing to help with any problems you might run into. Please see the \"Contacting Us\" section of this document if you need to get in touch with us about any issues you have regarding the source."],"licenseIds":["CrystalStacker"],"keywords":["crystal stacker is","stacker is freeware","is freeware this","freeware this means","this means you","means you can","you can pass","can pass copies","pass copies around","copies around freely","around freely provided","freely provided you","provided you include","document in it","in it s","it s original","s original form","original form in","form in your","in your distribution","your distribution please","distribution please see","need to contact","to contact us","contact us for","us for any","any reason disclaimer","reason disclaimer newcreature","disclaimer newcreature design","no guarantees regarding","guarantees regarding the","regarding the crystal","the crystal stacker","crystal stacker software","stacker software we","we are not","for damages caused","caused by it","by it though","it though the","though the software","is not known","not known to","known to cause","to cause any","cause any problems","any problems if","problems if you","you have trouble","have trouble with","trouble with the","the software see","software see the","document the source","may do with","do with it","with it whatsoever","it whatsoever you","whatsoever you please","you please provided","please provided that","include this file","in its unmodified","its unmodified form","unmodified form with","form with any","with any new","any new distribution","new distribution newcreature","distribution newcreature design","makes no gaurantees","no gaurantees regarding","gaurantees regarding the","regarding the usability","the usability of","usability of the","the source but","source but are","but are willing","willing to help","to help with","help with any","with any problems","any problems you","problems you might","you might run","might run into","run into please","into please see","need to get","to get in","get in touch","in touch with","touch with us","with us about","us about any","about any issues","any issues you","issues you have","you have regarding","have regarding the","regarding the source","crystal stacker is freeware","stacker is freeware this","is freeware this means","freeware this means you","this means you can","means you can pass","you can pass copies","can pass copies around","pass copies around freely","copies around freely provided","around freely provided you","freely provided you include","provided you include this","you include this document","this document in it","document in it s","in it s original","it s original form","s original form in","original form in your","form in your distribution","in your distribution please","your distribution please see","distribution please see the","you need to contact","need to contact us","to contact us for","contact us for any","us for any reason","for any reason disclaimer","any reason disclaimer newcreature","reason disclaimer newcreature design","disclaimer newcreature design makes","design makes no guarantees","makes no guarantees regarding","no guarantees regarding the","guarantees regarding the crystal","regarding the crystal stacker","the crystal stacker software","crystal stacker software we","stacker software we are","software we are not","we are not responsible","not responsible for damages","responsible for damages caused","for damages caused by","damages caused by it","caused by it though","by it though the","it though the software","though the software is","software is not known","is not known to","not known to cause","known to cause any","to cause any problems","cause any problems if","any problems if you","problems if you have","if you have trouble","you have trouble with","have trouble with the","trouble with the software","with the software see","the software see the","software see the contacting","this document the source","document the source code","is and you may","and you may do","you may do with","may do with it","do with it whatsoever","with it whatsoever you","it whatsoever you please","whatsoever you please provided","you please provided that","please provided that you","that you include this","you include this file","include this file in","this file in its","file in its unmodified","in its unmodified form","its unmodified form with","unmodified form with any","form with any new","with any new distribution","any new distribution newcreature","new distribution newcreature design","distribution newcreature design makes","design makes no gaurantees","makes no gaurantees regarding","no gaurantees regarding the","gaurantees regarding the usability","regarding the usability of","the usability of the","usability of the source"]},{"licenseTexts":["Cube game engine source code, 20 dec 2003 release. Copyright (C) 2001-2003 Wouter van Oortmerssen.\n\nThis software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software.\n\nPermission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions:\n\n   1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.\n\n   2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.\n\n   3. This notice may not be removed or altered from any source distribution.\n\nadditional clause specific to Cube:\n\n   4. Source versions may not be \"relicensed\" under a different license without my explicitly written permission."],"licenseIds":["Cube"],"keywords":["cube game engine","game engine source","engine source code","source code 20","code 20 dec","20 dec 2003","dec 2003 release","2003 release copyright","release copyright c","2001 2003 wouter","2003 wouter van","wouter van oortmerssen","van oortmerssen this","oortmerssen this software","source distribution additional","distribution additional clause","additional clause specific","clause specific to","specific to cube","to cube 4","cube 4 source","4 source versions","source versions may","versions may not","not be relicensed","be relicensed under","relicensed under a","different license without","license without my","without my explicitly","my explicitly written","explicitly written permission","cube game engine source","game engine source code","engine source code 20","source code 20 dec","code 20 dec 2003","20 dec 2003 release","dec 2003 release copyright","2003 release copyright c","release copyright c 2001","c 2001 2003 wouter","2001 2003 wouter van","2003 wouter van oortmerssen","wouter van oortmerssen this","van oortmerssen this software","oortmerssen this software is","any source distribution additional","source distribution additional clause","distribution additional clause specific","additional clause specific to","clause specific to cube","specific to cube 4","to cube 4 source","cube 4 source versions","4 source versions may","source versions may not","versions may not be","may not be relicensed","not be relicensed under","be relicensed under a","relicensed under a different","a different license without","different license without my","license without my explicitly","without my explicitly written","my explicitly written permission","cube game engine source code","game engine source code 20","engine source code 20 dec","source code 20 dec 2003","code 20 dec 2003 release","20 dec 2003 release copyright","dec 2003 release copyright c","2003 release copyright c 2001","release copyright c 2001 2003","copyright c 2001 2003 wouter","c 2001 2003 wouter van","2001 2003 wouter van oortmerssen","2003 wouter van oortmerssen this","wouter van oortmerssen this software","van oortmerssen this software is","oortmerssen this software is provided","from any source distribution additional","any source distribution additional clause","source distribution additional clause specific","distribution additional clause specific to","additional clause specific to cube","clause specific to cube 4","specific to cube 4 source","to cube 4 source versions","cube 4 source versions may","4 source versions may not","source versions may not be","versions may not be relicensed","may not be relicensed under","not be relicensed under a","be relicensed under a different","relicensed under a different license","under a different license without","a different license without my","different license without my explicitly","license without my explicitly written","without my explicitly written permission"]},{"licenseTexts":["Deutsche Freie Software Lizenz\n\n(c) Ministerium für Wissenschaft und Forschung Nordrhein-Westfalen 2004 Erstellt von Axel Metzger und Till Jaeger, Institut für Rechtsfragen der Freien und Open Source Software - ( http://www.ifross.de ) .\n\nPräambel\n\nSoftware ist mehr als ein Wirtschaftsgut. Sie ist die technische Grundlage der Informationsgesellschaft. Die Frage der Teilhabe der Allgemeinheit ist deswegen von besonderer Bedeutung. Herkömmlich lizenzierte Programme werden nur im Object Code vertrieben, der Nutzer darf das Programm weder verändern noch weitergeben. Das Lizenzmodell der Freien Software (synonym \"Open Source Software\") gewährt Ihnen dagegen umfassende Freiheiten im Umgang mit dem Programm. Die Deutsche Freie Software Lizenz folgt diesem Lizenzmodell. Sie gewährt Ihnen das Recht, das Programm in umfassender Weise zu nutzen. Es ist Ihnen gestattet, das Programm nach Ihren Vorstellungen zu verändern, in veränderter oder unveränderter Form zu vervielfältigen, zu verbreiten und öffentlich zugänglich zu machen. Diese Rechte werden unentgeltlich eingeräumt.\n\nDie Deutsche Freie Software Lizenz verbindet die Rechtseinräumung allerdings mit Pflichten, die dem Zweck dienen, das freie Zirkulieren des Programms und aller veröffentlichten Fortentwicklungen zu sichern. Wenn Sie das Programm verbreiten oder öffentlich zugänglich machen, dann müssen Sie jedem, der das Programm von Ihnen erhält, eine Kopie dieser Lizenz mitliefern und den Zugriff auf den Source Code ermöglichen. Eine weitere Pflicht betrifft Fortentwicklungen des Programms. Änderungen am Programm, die Sie öffentlich verbreiten oder zugänglich machen, müssen nach den Bestimmungen dieser Lizenz frei gegeben werden.\n\nDie Deutsche Freie Software Lizenz nimmt auf die besonderen Anforderungen des deutschen und europäischen Rechts Rücksicht. Sie ist zweisprachig gestaltet und damit auch auf den internationalen Vertrieb ausgerichtet.\n\n   \n\n   § 0 Definitionen\n\n      \n\n      Dokumentation: Die Beschreibung des Aufbaus und/oder der Struktur der Programmierung und/oder der Funktionalitäten des Programms, unabhängig davon, ob sie im Source Code oder gesondert vorgenommen wird.\n\n      \n\n      Lizenz: Die zwischen dem Lizenzgeber und Ihnen geschlossene Vereinbarung mit dem Inhalt der \"Deutschen Freien Software Lizenz\" bzw. das Angebot hierzu.\n\n      \n\n      Lizenznehmer: Jede natürliche oder juristische Person, die die Lizenz angenommen hat.\n\n      \n\n      Programm: Jedes Computerprogramm, das von den Rechtsinhabern nach den Bestimmungen dieser Lizenz verbreitet oder öffentlich zugänglich gemacht worden ist.\n\n      \n\n      Object Code: Die maschinenlesbare, übersetzte Form des Programms.\n\n      \n\n      Öffentlich: Nicht nur an einen bestimmten Personenkreis gerichtet, der persönlich oder durch die Zugehörigkeit zu einer juristischen Person oder einem öffentlichen Träger miteinander verbunden ist.\n\n      \n\n      Öffentlich zugänglich machen: Die öffentliche Weitergabe des Programms in unkörperlicher Form, insbesondere das Bereithalten zum Download in Datennetzen.\n\n      \n\n      Rechtsinhaber: Der bzw. die Urheber oder sonstigen Inhaber der ausschließlichen Nutzungsrechte an dem Programm.\n\n      \n\n      Source Code: Die für Menschen lesbare, in Programmiersprache dargestellte Form des Programms.\n\n      \n\n      Verändern: Jede Erweiterung, Kürzung und Bearbeitung des Programms, insbesondere Weiterentwicklungen.\n\n      \n\n      Verbreiten: Die öffentliche Weitergabe körperlicher Vervielfältigungsstücke, insbesondere auf Datenträgern oder in Verbindung mit Hardware.\n\n      \n\n      Vollständiger Source Code: Der Source Code in der für die Erstellung bzw. die Bearbeitung benutzten Form zusammen mit den zur Übersetzung und Installation erforderlichen Konfigurationsdateien und Software-Werkzeugen, sofern diese in der benötigten Form nicht allgemein gebräuchlich (z.B. Standard-Kompiler) oder für jedermann lizenzgebührenfrei im Internet abrufbar sind.\n\n   \n\n   § 1 Rechte\n\n      (1) Sie dürfen das Programm in unveränderter Form vervielfältigen, verbreiten und öffentlich zugänglich machen.\n\n      (2) Sie dürfen das Programm verändern und entsprechend veränderte Versionen vervielfältigen, verbreiten und öffentlich zugänglich machen. Gestattet ist auch die Kombination des Programms oder Teilen hiervon mit anderen Programmen.\n\n      (3) Sie erhalten die Rechte unentgeltlich.\n\n   \n\n   § 2 Pflichten beim Vertrieb\n\n      (1) Wenn Sie das Programm verbreiten oder öffentlich zugänglich machen, sei es in unveränderter oder veränderter Form, sei es in einer Kombination mit anderen Programmen oder in Verbindung mit Hardware, dann müssen sie mitliefern:\n\n      1. alle Vermerke im Source Code und/oder Object Code, die auf diese Lizenz hinweisen;\n\n      2. alle Vermerke im Source Code und/oder Object Code, die über die Urheber des Programms Auskunft geben;\n\n      3. einen für den Empfänger deutlich wahrnehmbaren Hinweis auf diese Lizenz und die Internetadresse \u003c http://www.d-fsl.de \u003e ;\n\n      4. den vollständigen Text dieser Lizenz in deutlich wahrnehmbarer Weise.\n\n      (2) Wenn bei der Installation des Programms und/oder beim Programmstart Lizenz- und/oder Vertragsbedingungen angezeigt werden, dann müssen\n\n      1. diese Lizenz,\n\n      2. ein Hinweis auf diese Lizenz und\n\n      3. ein Hinweis auf den oder die Rechtsinhaber an den ersten unter dieser Lizenz nutzbaren Programmbestandteilen\n\n      ebenfalls angezeigt werden.\n\n      (3) Sie dürfen die Nutzung des Programms nicht von Pflichten oder Bedingungen abhängig machen, die nicht in dieser Lizenz vorgesehen sind.\n\n      (4) Sofern Sie mit dem Programm eine Dokumentation erhalten haben, muss diese Dokumentation entsprechend mitgeliefert werden, es sei denn, die freie Mitlieferung der Dokumentation ist Ihnen aufgrund der Lizenz für die Dokumentation nicht gestattet.\n\n   \n\n   § 3 Weitere Pflichten beim Vertrieb veränderter Versionen\n\n      (1) Veränderte Versionen des Programms dürfen Sie nur unter den Bedingungen dieser Lizenz verbreiten oder öffentlich zugänglich machen, so dass Dritte das veränderte Programm insgesamt unter dieser Lizenz nutzen können.\n\n      (2) Wird das Programm oder ein Teil hiervon mit einem anderen Programm kombiniert, gilt auch die Kombination insgesamt als eine veränderte Version des Programms, es sei denn, das andere Programm ist formal und inhaltlich eigenständig. Ein anderes Programm ist dann als eigenständig anzusehen, wenn es die folgenden Voraussetzungen alle erfüllt:\n\n         1. Der Source Code der kombinierten Programme muss jeweils in eigenen Dateien vorhanden sein, die keine Bestandteile des anderen Teils enthalten, die über die zur Programmkombination üblichen und erforderlichen Informationen über den anderen Teil hinausgehen, wobei der Source Code des anderen Programms nicht mitgeliefert werden muss.\n\n         2. Der mit dem Programm kombinierte Teil muss auch dann sinnvoll nutzbar sein, wenn er nicht mit dem Programm kombiniert wird, und zwar entweder alleine oder mit sonstigen Programmen. Was als \"sinnvoll nutzbar\" anzusehen ist, richtet sich nach der Auffassung der betroffenen Fachkreise. Zu den betroffenen Fachkreisen gehören alle Personen, die das Programm oder Programme mit vergleichbarer Funktionalität entwickeln, benutzen, verbreiten oder öffentlich zugänglich machen.\n\n      (3) Wenn Sie das Programm oder einen Teil hiervon - verändert oder unverändert - zusammen mit einem anderen Programm verbreiten oder öffentlich zugänglich machen, das unter der GNU General Public License (GPL) lizenziert wird, darf das Programm auch unter den Bedingungen der GPL genutzt werden, sofern es mit dem anderen Programm ein \"derivative work\" im Sinne der GPL bildet. Dabei sollen die Hinweise auf diese Lizenz entfernt und durch einen Hinweis auf die GPL ersetzt werden. Ob bei der Zusammenstellung ein \"derivate work\" im Sinne der GPL entsteht, beurteilt sich nach Ziffer 2 b) der GPL. Diese Bestimmung lautet: \"You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License.\" Die GPL kann abgerufen werden unter http://www.fsf.org/licenses/gpl.\n\n      (4) Wenn Sie das Programm in einer veränderten Form verbreiten oder öffentlich zugänglich machen, müssen Sie im Source Code einen Hinweis mit den Änderungen aufnehmen und mit dem Datum der Änderung versehen. Der Hinweis muss erkennen lassen, welche Änderungen vorgenommen wurden und bestehende Vermerke, die über die Urheber des Programms Auskunft geben, übernehmen. Dies gilt unabhängig davon, ob Sie einen eigenen Urhebervermerk hinzufügen. Anstelle eines Hinweises im Source Code können Sie auch ein Versionskontrollsystem verwenden oder weiterführen, sofern dieses mitverbreitet wird oder öffentlich zugänglich ist.\n\n      (5) Sie dürfen von Dritten für die Einräumung eines einfachen Nutzungsrechts an veränderten Versionen des Programms kein Entgelt verlangen.\n\n      (6) Wenn Sie an der veränderten Version des Programms ein anderes Schutzrecht als ein Urheberrecht erwerben, insbesondere ein Patent oder Gebrauchsmuster, lizenzieren Sie dieses Schutzrecht für veränderte und unveränderte Versionen des Programms in dem Umfang, der erforderlich ist, um die Rechte aus dieser Lizenz wahrnehmen zu können.\n\n   \n\n   § 4 Weitere Pflichten beim Vertrieb im Object Code\n\n      (1) Wenn Sie das Programm nur im Object Code verbreiten, dann müssen Sie zusätzlich zu den in § 2 und § 3 geregelten Pflichten entweder\n\n         1. den vollständigen Source Code im Internet öffentlich zugänglich machen und bei der Verbreitung des Object Codes deutlich auf die vollständige Internetadresse hinweisen, unter der der Source Code abgerufen werden kann oder\n\n         2. den vollständigen Source Code auf einem hierfür üblichen Datenträger unter Beachtung der §§ 2 und 3 mitverbreiten.\n\n      (2) Wenn Sie das Programm im Object Code öffentlich zugänglich machen, dann müssen Sie zusätzlich zu den in § 2 und § 3 geregelten Pflichten den vollständigen Source Code im Internet öffentlich zugänglich machen und dabei deutlich auf die vollständige Internetadresse hinweisen.\n\n      (3) Sofern Sie mit dem Programm eine Dokumentation erhalten haben, muss diese Dokumentation entsprechend der Absätze 1 und 2 mitgeliefert werden, es sei denn, die freie Mitlieferung der Dokumentation ist Ihnen aufgrund der Lizenz für die Dokumentation nicht gestattet.\n\n   \n\n   § 5 Vertragsschluss\n\n      (1) Mit dieser Lizenz wird Ihnen und jeder anderen Person ein Angebot auf Abschluss eines Vertrages über die Nutzung des Programms unter den Bedingungen der Deutschen Freien Softwarelizenz unterbreitet.\n\n      (2) Sie dürfen das Programm nach den jeweils anwendbaren gesetzlichen Vorschriften bestimmungsgemäß benutzen, ohne dass es der Annahme dieser Lizenz bedarf. Dieses Recht umfasst in der Europäischen Union und in den meisten anderen Rechtsordnungen insbesondere die folgenden Befugnisse:\n\n         1. das Programm ablaufen zu lassen sowie die Erstellung von hierfür erforderlichen Vervielfältigungen im Haupt- und Arbeitsspeicher;\n\n         2. das Erstellen einer Sicherungskopie;\n\n         3. die Fehlerberichtigung;\n\n         4. die Weitergabe einer rechtmäßig erworbenen körperlichen Kopie des Programms.\n\n      (3) Sie erklären Ihre Zustimmung zum Abschluss dieser Lizenz, indem Sie das Programm verbreiten, öffentlich zugänglich machen, verändern oder in einer Weise vervielfältigen, die über die bestimmungsgemäße Nutzung im Sinne von Absatz 2 hinausgeht. Ab diesem Zeitpunkt ist diese Lizenz als rechtlich verbindlicher Vertrag zwischen den Rechtsinhabern und Ihnen geschlossen, ohne dass es eines Zugangs der Annahmeerklärung bei den Rechtsinhabern bedarf.\n\n      (4) Sie und jeder andere Lizenznehmer erhalten die Rechte aus dieser Lizenz direkt von den Rechtsinhabern. Eine Unterlizenzierung oder Übertragung der Rechte ist nicht gestattet.\n\n   \n\n   § 6 Beendigung der Rechte bei Zuwiderhandlung\n\n      (1) Jede Verletzung Ihrer Verpflichtungen aus dieser Lizenz führt zu einer automatischen Beendigung Ihrer Rechte aus dieser Lizenz.\n\n      (2) Die Rechte Dritter, die das Programm oder Rechte an dem Programm von Ihnen erhalten haben, bleiben hiervon unberührt.\n\n   \n\n   § 7 Haftung und Gewährleistung\n\n      (1) Für entgegenstehende Rechte Dritter haften die Rechtsinhaber nur, sofern sie Kenntnis von diesen Rechten hatten, ohne Sie zu informieren.\n\n      (2) Die Haftung für Fehler und sonstige Mängel des Programms richtet sich nach den außerhalb dieser Lizenz getroffenen Vereinbarungen zwischen Ihnen und den Rechtsinhabern oder, wenn eine solche Vereinbarung nicht existiert, nach den gesetzlichen Regelungen.\n\n   \n\n   § 8 Verträge mit Dritten\n\n      (1) Diese Lizenz regelt nur die Beziehung zwischen Ihnen und den Rechtsinhabern. Sie ist nicht Bestandteil der Verträge zwischen Ihnen und Dritten.\n\n      (2) Die Lizenz beschränkt Sie nicht in der Freiheit, mit Dritten, die von Ihnen Kopien des Programms erhalten oder Leistungen in Anspruch nehmen, die im Zusammenhang mit dem Programm stehen, Verträge beliebigen Inhalts zu schließen, sofern Sie dabei Ihren Verpflichtungen aus dieser Lizenz nachkommen und die Rechte der Dritten aus dieser Lizenz nicht beeinträchtigt werden. Insbesondere dürfen Sie für die Überlassung des Programms oder sonstige Leistungen ein Entgelt verlangen.\n\n      (3) Diese Lizenz verpflichtet Sie nicht, das Programm an Dritte weiterzugeben. Es steht Ihnen frei zu entscheiden, wem Sie das Programm zugänglich machen. Sie dürfen aber die weitere Nutzung durch Dritte nicht durch den Einsatz technischer Schutzmaßnahmen, insbesondere durch den Einsatz von Kopierschutzvorrichtungen jeglicher Art, verhindern oder erschweren. Eine passwortgeschützte Zugangsbeschränkung oder die Nutzung in einem Intranet wird nicht als technische Schutzmaßnahme angesehen.\n\n   \n\n   § 9 Text der Lizenz\n\n      (1) Diese Lizenz ist in deutscher und englischer Sprache abgefasst. Beide Fassungen sind gleich verbindlich. Es wird unterstellt, dass die in der Lizenz verwandten Begriffe in beiden Fassungen dieselbe Bedeutung haben. Ergeben sich dennoch Unterschiede, so ist die Bedeutung maßgeblich, welche die Fassungen unter Berücksichtigung des Ziels und Zwecks der Lizenz am besten miteinander in Einklang bringt.\n\n      (2) Der Lizenzrat der Deutschen Freien Software Lizenz kann mit verbindlicher Wirkung neue Versionen der Lizenz in Kraft setzen, soweit dies erforderlich und zumutbar ist. Neue Versionen der Lizenz werden auf der Internetseite http://www.d-fsl.de mit einer eindeutigen Versionsnummer veröffentlicht. Die neue Version der Lizenz erlangt für Sie verbindliche Wirkung, wenn Sie von deren Veröffentlichung Kenntnis genommen haben. Gesetzliche Rechtsbehelfe gegen die Änderung der Lizenz werden durch die vorstehenden Bestimmungen nicht beschränkt.\n\n      (3) Sie dürfen diese Lizenz in unveränderter Form vervielfältigen, verbreiten und öffentlich zugänglich machen.\n\n   \n\n   § 10 Anwendbares Recht\n\n   Auf diese Lizenz findet deutsches Recht Anwendung.\n\n   Anhang: Wie unterstellen Sie ein Programm der Deutschen Freien Software Lizenz?\n\n   Um jedermann den Abschluss dieser Lizenz zu ermöglichen, wird empfohlen, das Programm mit folgendem Hinweis auf die Lizenz zu versehen:\n\n   \"Copyright (C) 20[jj] [Name des Rechtsinhabers].\n\n   Dieses Programm kann durch jedermann gemäß den Bestimmungen der Deutschen Freien Software Lizenz genutzt werden.\n\n   Die Lizenz kann unter http://www.d-fsl.de abgerufen werden.\""],"licenseIds":["D-FSL-1.0"],"keywords":["software lizenz c","lizenz c ministerium","c ministerium f","ministerium f r","f r wissenschaft","r wissenschaft und","wissenschaft und forschung","und forschung nordrhein","forschung nordrhein westfalen","nordrhein westfalen 2004","westfalen 2004 erstellt","2004 erstellt von","erstellt von axel","von axel metzger","axel metzger und","metzger und till","und till jaeger","till jaeger institut","jaeger institut f","institut f r","f r rechtsfragen","r rechtsfragen der","rechtsfragen der freien","der freien und","freien und open","und open source","source software http","software http www","http www ifross","www ifross de","ifross de pr","de pr ambel","pr ambel software","ambel software ist","software ist mehr","ist mehr als","mehr als ein","als ein wirtschaftsgut","ein wirtschaftsgut sie","wirtschaftsgut sie ist","sie ist die","ist die technische","die technische grundlage","technische grundlage der","grundlage der informationsgesellschaft","der informationsgesellschaft die","informationsgesellschaft die frage","die frage der","frage der teilhabe","der teilhabe der","teilhabe der allgemeinheit","der allgemeinheit ist","allgemeinheit ist deswegen","ist deswegen von","deswegen von besonderer","von besonderer bedeutung","besonderer bedeutung herk","bedeutung herk mmlich","herk mmlich lizenzierte","mmlich lizenzierte programme","lizenzierte programme werden","programme werden nur","werden nur im","object code vertrieben","code vertrieben der","vertrieben der nutzer","der nutzer darf","nutzer darf das","das programm weder","programm weder ver","weder ver ndern","ver ndern noch","ndern noch weitergeben","noch weitergeben das","weitergeben das lizenzmodell","das lizenzmodell der","lizenzmodell der freien","der freien software","freien software synonym","software synonym open","synonym open source","source software gew","software gew hrt","hrt ihnen dagegen","ihnen dagegen umfassende","dagegen umfassende freiheiten","umfassende freiheiten im","freiheiten im umgang","im umgang mit","umgang mit dem","dem programm die","programm die deutsche","software lizenz folgt","lizenz folgt diesem","folgt diesem lizenzmodell","diesem lizenzmodell sie","lizenzmodell sie gew","sie gew hrt","hrt ihnen das","ihnen das recht","das recht das","recht das programm","programm in umfassender","in umfassender weise","umfassender weise zu","weise zu nutzen","zu nutzen es","nutzen es ist","es ist ihnen","ist ihnen gestattet","ihnen gestattet das","gestattet das programm","programm nach ihren","nach ihren vorstellungen","ihren vorstellungen zu","vorstellungen zu ver","zu ver ndern","ver ndern in","ndern in ver","in ver nderter","ver nderter oder","nderter oder unver","oder unver nderter","nderter form zu","form zu vervielf","zu vervielf ltigen","vervielf ltigen zu","ltigen zu verbreiten","zu verbreiten und","zug nglich zu","nglich zu machen","zu machen diese","machen diese rechte","diese rechte werden","rechte werden unentgeltlich","werden unentgeltlich einger","unentgeltlich einger umt","einger umt die","umt die deutsche","software lizenz verbindet","lizenz verbindet die","verbindet die rechtseinr","die rechtseinr umung","rechtseinr umung allerdings","umung allerdings mit","allerdings mit pflichten","mit pflichten die","pflichten die dem","die dem zweck","dem zweck dienen","zweck dienen das","dienen das freie","das freie zirkulieren","freie zirkulieren des","zirkulieren des programms","programms und aller","und aller ver","aller ver ffentlichten","ver ffentlichten fortentwicklungen","ffentlichten fortentwicklungen zu","fortentwicklungen zu sichern","zu sichern wenn","sichern wenn sie","ssen sie jedem","sie jedem der","jedem der das","der das programm","das programm von","von ihnen erh","ihnen erh lt","erh lt eine","lt eine kopie","eine kopie dieser","kopie dieser lizenz","dieser lizenz mitliefern","lizenz mitliefern und","mitliefern und den","und den zugriff","den zugriff auf","zugriff auf den","auf den source","den source code","source code erm","code erm glichen","erm glichen eine","glichen eine weitere","eine weitere pflicht","weitere pflicht betrifft","pflicht betrifft fortentwicklungen","betrifft fortentwicklungen des","fortentwicklungen des programms","des programms nderungen","programms nderungen am","nderungen am programm","am programm die","programm die sie","die sie ffentlich","sie ffentlich verbreiten","ffentlich verbreiten oder","verbreiten oder zug"]},{"licenseTexts":["Copyright and Licensing Information for ACE(TM), TAO(TM), CIAO(TM), DAnCE(TM), and CoSMIC(TM)\n\nACE(TM), TAO(TM), CIAO(TM), DAnCE\u003e(TM), and CoSMIC(TM) (henceforth referred to as \"DOC software\") are copyrighted by Douglas C. Schmidt and his research group at Washington University, University of California, Irvine, and Vanderbilt University, Copyright (c) 1993-2009, all rights reserved. Since DOC software is open-source, freely available software, you are free to use, modify, copy, and distribute--perpetually and irrevocably--the DOC software source code and object code produced from the source, as well as copy and distribute modified versions of this software. You must, however, include this copyright statement along with any code built using DOC software that you release. No copyright statement needs to be provided if you just ship binary executables of your software products.\n\nYou can use DOC software in commercial and/or binary software releases and are under no obligation to redistribute any of your source code that is built using DOC software. Note, however, that you may not misappropriate the DOC software code, such as copyrighting it yourself or claiming authorship of the DOC software code, in a way that will prevent DOC software from being distributed freely using an open-source development model. You needn't inform anyone that you're using DOC software in your software, though we encourage you to let us know so we can promote your project in the DOC software success stories.\n\nThe ACE, TAO, CIAO, DAnCE, and CoSMIC web sites are maintained by the DOC Group at the Institute for Software Integrated Systems (ISIS) and the Center for Distributed Object Computing of Washington University, St. Louis for the development of open-source software as part of the open-source software community. Submissions are provided by the submitter ``as is'' with no warranties whatsoever, including any warranty of merchantability, noninfringement of third party intellectual property, or fitness for any particular purpose. In no event shall the submitter be liable for any direct, indirect, special, exemplary, punitive, or consequential damages, including without limitation, lost profits, even if advised of the possibility of such damages. Likewise, DOC software is provided as is with no warranties of any kind, including the warranties of design, merchantability, and fitness for a particular purpose, noninfringement, or arising from a course of dealing, usage or trade practice. Washington University, UC Irvine, Vanderbilt University, their employees, and students shall have no liability with respect to the infringement of copyrights, trade secrets or any patents by DOC software or any part thereof. Moreover, in no event will Washington University, UC Irvine, or Vanderbilt University, their employees, or students be liable for any lost revenue or profits or other special, indirect and consequential damages.\n\nDOC software is provided with no support and without any obligation on the part of Washington University, UC Irvine, Vanderbilt University, their employees, or students to assist in its use, correction, modification, or enhancement. A number of companies around the world provide commercial support for DOC software, however. DOC software is Y2K-compliant, as long as the underlying OS platform is Y2K-compliant. Likewise, DOC software is compliant with the new US daylight savings rule passed by Congress as \"The Energy Policy Act of 2005,\" which established new daylight savings times (DST) rules for the United States that expand DST as of March 2007. Since DOC software obtains time/date and calendaring information from operating systems users will not be affected by the new DST rules as long as they upgrade their operating systems accordingly.\n\nThe names ACE(TM), TAO(TM), CIAO(TM), DAnCE(TM), CoSMIC(TM), Washington University, UC Irvine, and Vanderbilt University, may not be used to endorse or promote products or services derived from this source without express written permission from Washington University, UC Irvine, or Vanderbilt University. This license grants no permission to call products or services derived from this source ACE(TM), TAO(TM), CIAO(TM), DAnCE(TM), or CoSMIC(TM), nor does it grant permission for the name Washington University, UC Irvine, or Vanderbilt University to appear in their names.\n\nIf you have any suggestions, additions, comments, or questions, please let me know.\n\nDouglas C. Schmidt"],"licenseIds":["DOC"],"keywords":["copyright and licensing","and licensing information","information for ace","for ace tm","cosmic tm ace","tm ace tm","cosmic tm henceforth","tm henceforth referred","henceforth referred to","to as doc","as doc software","doc software are","software are copyrighted","copyrighted by douglas","by douglas c","c schmidt and","schmidt and his","and his research","his research group","research group at","group at washington","at washington university","washington university university","university university of","of california irvine","california irvine and","vanderbilt university copyright","university copyright c","c 1993 2009","1993 2009 all","2009 all rights","rights reserved since","reserved since doc","software is open","is open source","open source freely","source freely available","freely available software","available software you","free to use","use modify copy","modify copy and","and distribute perpetually","distribute perpetually and","perpetually and irrevocably","and irrevocably the","irrevocably the doc","doc software source","object code produced","code produced from","produced from the","the source as","source as well","well as copy","as copy and","you must however","must however include","however include this","this copyright statement","copyright statement along","statement along with","any code built","code built using","doc software that","you release no","release no copyright","no copyright statement","copyright statement needs","statement needs to","needs to be","be provided if","provided if you","if you just","you just ship","just ship binary","ship binary executables","binary executables of","executables of your","your software products","software products you","products you can","can use doc","use doc software","commercial and or","or binary software","binary software releases","software releases and","releases and are","and are under","obligation to redistribute","redistribute any of","of your source","your source code","that is built","is built using","doc software note","software note however","however that you","may not misappropriate","not misappropriate the","misappropriate the doc","software code such","code such as","such as copyrighting","as copyrighting it","copyrighting it yourself","it yourself or","yourself or claiming","or claiming authorship","claiming authorship of","of the doc","way that will","that will prevent","will prevent doc","prevent doc software","doc software from","software from being","being distributed freely","distributed freely using","freely using an","using an open","source development model","development model you","model you needn","you needn t","needn t inform","t inform anyone","inform anyone that","anyone that you","that you re","you re using","re using doc","in your software","your software though","software though we","though we encourage","we encourage you","you to let","to let us","we can promote","can promote your","promote your project","your project in","project in the","in the doc","doc software success","software success stories","success stories the","stories the ace","the ace tao","ace tao ciao","tao ciao dance","ciao dance and","dance and cosmic","and cosmic web","cosmic web sites","web sites are","sites are maintained","are maintained by","by the doc","the doc group","doc group at","group at the","at the institute","the institute for","institute for software","for software integrated","software integrated systems","integrated systems isis","systems isis and","isis and the","and the center","the center for","center for distributed","for distributed object","distributed object computing","object computing of","computing of washington","washington university st","university st louis","st louis for","louis for the","for the development","development of open","of open source","source software as","source software community","software community submissions","community submissions are","submissions are provided","by the submitter","the submitter as","submitter as is","warranties whatsoever including","whatsoever including any","including any warranty","merchantability noninfringement of","intellectual property or","property or fitness","shall the submitter"]},{"licenseTexts":["COPYRIGHT NOTIFICATION (C) COPYRIGHT 2004 UNIVERSITY OF CHICAGO\n\nThis program discloses material protectable under copyright laws of the United States. Permission to copy and modify this software and its documentation is hereby granted, provided that this notice is retained thereon and on all copies or modifications. The University of Chicago makes no representations as to the suitability and operability of this software for any purpose. It is provided \"as is\"; without express or implied warranty. Permission is hereby granted to use, reproduce, prepare derivative works, and to redistribute to others, so long as this original copyright notice is retained. Any publication resulting from research that made use of this software should cite this document.\n\nThis software was authored by:\n\nSteven J. Benson Mathematics and Computer Science Division Argonne National Laboratory Argonne IL 60439\n\nYinyu Ye Department of Management Science and Engineering Stanford University Stanford, CA U.S.A\n\nAny questions or comments on the software may be directed to benson@mcs.anl.gov or yinyu-ye@stanford.edu\n\nArgonne National Laboratory with facilities in the states of Illinois and Idaho, is owned by The United States Government, and operated by the University of Chicago under provision of a contract with the Department of Energy.\n\nDISCLAIMER\n\nTHIS PROGRAM WAS PREPARED AS AN ACCOUNT OF WORK SPONSORED BY AN AGENCY OF THE UNITED STATES GOVERNMENT. NEITHER THE UNITED STATES GOVERNMENT NOR ANY AGENCY THEREOF, NOR THE UNIVERSITY OF CHICAGO, NOR ANY OF THEIR EMPLOYEES OR OFFICERS, MAKES ANY WARRANTY, EXPRESS OR IMPLIED, OR ASSUMES ANY LEGAL LIABILITY OR RESPONSIBILITY FOR THE ACCURACY, COMPLETENESS, OR USEFULNESS OF ANY INFORMATION, APPARATUS, PRODUCT, OR PROCESS DISCLOSED, OR REPRESENTS THAT ITS USE WOULD NOT INFRINGE PRIVATELY OWNED RIGHTS. REFERENCE HEREIN TO ANY SPECIFIC COMMERCIAL PRODUCT, PROCESS, OR SERVICE BY TRADE NAME, TRADEMARK, MANUFACTURER, OR OTHERWISE, DOES NOT NECESSARILY CONSTITUTE OR IMPLY ITS ENDORSEMENT, RECOMMENDATION, OR FAVORING BY THE UNITED STATES GOVERNMENT OR ANY AGENCY THEREOF. THE VIEW AND OPINIONS OF AUTHORS EXPRESSED HEREIN DO NOT NECESSARILY STATE OR REFLECT THOSE OF THE UNITED STATES GOVERNMENT OR ANY AGENCY THEREOF."],"licenseIds":["DSDP"],"keywords":["copyright notification c","notification c copyright","c copyright 2004","copyright 2004 university","2004 university of","of chicago this","chicago this program","this program discloses","program discloses material","discloses material protectable","material protectable under","under copyright laws","united states permission","states permission to","its documentation is","documentation is hereby","is retained thereon","retained thereon and","thereon and on","and on all","copies or modifications","or modifications the","modifications the university","of chicago makes","chicago makes no","no representations as","the suitability and","suitability and operability","and operability of","operability of this","implied warranty permission","warranty permission is","to others so","others so long","as this original","this original copyright","original copyright notice","is retained any","retained any publication","any publication resulting","publication resulting from","resulting from research","from research that","research that made","that made use","made use of","software should cite","should cite this","cite this document","document this software","authored by steven","by steven j","steven j benson","j benson mathematics","benson mathematics and","il 60439 yinyu","60439 yinyu ye","yinyu ye department","ye department of","department of management","of management science","management science and","science and engineering","and engineering stanford","engineering stanford university","stanford university stanford","university stanford ca","stanford ca u","ca u s","s a any","a any questions","any questions or","questions or comments","or comments on","comments on the","may be directed","directed to benson","to benson mcs","benson mcs anl","anl gov or","gov or yinyu","or yinyu ye","yinyu ye stanford","ye stanford edu","stanford edu argonne","edu argonne national","national laboratory with","laboratory with facilities","with facilities in","facilities in the","in the states","the states of","states of illinois","of illinois and","illinois and idaho","and idaho is","idaho is owned","states government and","government and operated","and operated by","operated by the","of chicago under","chicago under provision","under provision of","provision of a","a contract with","contract with the","with the department","department of energy","of energy disclaimer","energy disclaimer this","disclaimer this program","program was prepared","was prepared as","prepared as an","states government nor","government nor any","nor any agency","agency thereof nor","thereof nor the","employees or officers","or officers makes","officers makes any","owned rights reference","rights reference herein","reference herein to","herein to any","any specific commercial","specific commercial product","commercial product process","product process or","process or service","or service by","service by trade","by trade name","name trademark manufacturer","trademark manufacturer or","manufacturer or otherwise","or otherwise does","otherwise does not","does not necessarily","not necessarily constitute","necessarily constitute or","constitute or imply","or imply its","imply its endorsement","its endorsement recommendation","endorsement recommendation or","recommendation or favoring","or favoring by","favoring by the","agency thereof the","thereof the view","the view and","view and opinions","and opinions of","opinions of authors","of authors expressed","authors expressed herein","expressed herein do","herein do not","do not necessarily","not necessarily state","necessarily state or","state or reflect","or reflect those","reflect those of","copyright notification c copyright","notification c copyright 2004","c copyright 2004 university","copyright 2004 university of","2004 university of chicago","university of chicago this","of chicago this program","chicago this program discloses","this program discloses material","program discloses material protectable","discloses material protectable under","material protectable under copyright","protectable under copyright laws","under copyright laws of","the united states permission","united states permission to","states permission to copy","to copy and modify","and its documentation is","its documentation is hereby","documentation is hereby granted","this notice is retained","notice is retained thereon","is retained thereon and","retained thereon and on","thereon and on all","and on all copies","on all copies or","all copies or modifications","copies or modifications the","or modifications the university","modifications the university of","university of chicago makes"]},{"licenseTexts":["Copyright (C) 1995 by Donald Arseneau\n\nThis file may be freely transmitted and reproduced, but it may not be changed unless the name is changed also (except that you may freely change the paper-size option for \\documentclass).\n\nThis notice must be left intact."],"licenseIds":["Dotseqn"],"keywords":["c 1995 by","1995 by donald","by donald arseneau","donald arseneau this","arseneau this file","be freely transmitted","freely transmitted and","transmitted and reproduced","and reproduced but","reproduced but it","not be changed","be changed unless","changed unless the","unless the name","is changed also","changed also except","also except that","may freely change","freely change the","change the paper","the paper size","paper size option","size option for","option for documentclass","for documentclass this","documentclass this notice","this notice must","must be left","be left intact","copyright c 1995 by","c 1995 by donald","1995 by donald arseneau","by donald arseneau this","donald arseneau this file","arseneau this file may","may be freely transmitted","be freely transmitted and","freely transmitted and reproduced","transmitted and reproduced but","and reproduced but it","reproduced but it may","but it may not","may not be changed","not be changed unless","be changed unless the","changed unless the name","unless the name is","name is changed also","is changed also except","changed also except that","also except that you","you may freely change","may freely change the","freely change the paper","change the paper size","the paper size option","paper size option for","size option for documentclass","option for documentclass this","for documentclass this notice","documentclass this notice must","this notice must be","notice must be left","must be left intact","copyright c 1995 by donald","c 1995 by donald arseneau","1995 by donald arseneau this","by donald arseneau this file","donald arseneau this file may","arseneau this file may be","file may be freely transmitted","may be freely transmitted and","be freely transmitted and reproduced","freely transmitted and reproduced but","transmitted and reproduced but it","and reproduced but it may","reproduced but it may not","but it may not be","it may not be changed","may not be changed unless","not be changed unless the","be changed unless the name","changed unless the name is","unless the name is changed","the name is changed also","name is changed also except","is changed also except that","changed also except that you","also except that you may","except that you may freely","that you may freely change","you may freely change the","may freely change the paper","freely change the paper size","change the paper size option","the paper size option for","paper size option for documentclass","size option for documentclass this","option for documentclass this notice","for documentclass this notice must","documentclass this notice must be","this notice must be left","notice must be left intact"]},{"licenseTexts":["The Educational Community License\n\nThis Educational Community License (the \"License\") applies to any original work of authorship (the \"Original Work\") whose owner (the \"Licensor\") has placed the following notice immediately following the copyright notice for the Original Work:\n\nCopyright (c) \u003cyear\u003e \u003ccopyright holders\u003e\n\nLicensed under the Educational Community License version 1.0\n\nThis Original Work, including software, source code, documents, or other related items, is being provided by the copyright holder(s) subject to the terms of the Educational Community License. By obtaining, using and/or copying this Original Work, you agree that you have read, understand, and will comply with the following terms and conditions of the Educational Community License:\n\nPermission to use, copy, modify, merge, publish, distribute, and sublicense this Original Work and its documentation, with or without modification, for any purpose, and without fee or royalty to the copyright holder(s) is hereby granted, provided that you include the following on ALL copies of the Original Work or portions thereof, including modifications or derivatives, that you make:\n\nThe full text of the Educational Community License in a location viewable to users of the redistributed or derivative work.\n\nAny pre-existing intellectual property disclaimers, notices, or terms and conditions.\n\nNotice of any changes or modifications to the Original Work, including the date the changes were made.\n\nAny modifications of the Original Work must be distributed in such a manner as to avoid any confusion with the Original Work of the copyright holders.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nThe name and trademarks of copyright holder(s) may NOT be used in advertising or publicity pertaining to the Original or Derivative Works without specific, written prior permission. Title to copyright in the Original Work and any associated documentation will at all times remain with the copyright holders."],"licenseIds":["ECL-1.0"],"keywords":["community license this","license this educational","this educational community","community license the","original work copyright","work copyright c","copyright holders licensed","holders licensed under","0 this original","including software source","source code documents","code documents or","holder s subject","s subject to","community license by","copying this original","work you agree","have read understand","read understand and","understand and will","community license permission","license permission to","and sublicense this","sublicense this original","work and its","royalty to the","holder s is","s is hereby","including modifications or","or derivatives that","derivatives that you","make the full","community license in","and conditions notice","conditions notice of","date the changes","the changes were","were made any","made any modifications","such a manner","a manner as","manner as to","as to avoid","to avoid any","avoid any confusion","any confusion with","confusion with the","holders the software","holder s may","s may not","original or derivative","works without specific","remain with the","educational community license this","community license this educational","license this educational community","this educational community license","educational community license the","community license the license","the original work copyright","original work copyright c","work copyright c year","year copyright holders licensed","copyright holders licensed under","holders licensed under the","community license version 1","1 0 this original","0 this original work","this original work including","original work including software","work including software source","including software source code","software source code documents","source code documents or","code documents or other","copyright holder s subject","holder s subject to","s subject to the","terms of the educational","educational community license by","community license by obtaining","or copying this original","copying this original work","this original work you","original work you agree","work you agree that","you have read understand","have read understand and","read understand and will","understand and will comply","conditions of the educational","educational community license permission","community license permission to","license permission to use","publish distribute and sublicense","distribute and sublicense this","and sublicense this original","sublicense this original work","this original work and","original work and its","work and its documentation","or royalty to the","royalty to the copyright","copyright holder s is","holder s is hereby","s is hereby granted","original work or portions","thereof including modifications or","including modifications or derivatives","modifications or derivatives that","or derivatives that you","derivatives that you make","you make the full","make the full text","text of the educational","educational community license in","community license in a","license in a location","terms and conditions notice","and conditions notice of","conditions notice of any","original work including the","work including the date","including the date the","the date the changes","date the changes were","the changes were made","changes were made any","were made any modifications","made any modifications of","any modifications of the","work must be distributed","be distributed in such","in such a manner","such a manner as","a manner as to","manner as to avoid","as to avoid any","to avoid any confusion","avoid any confusion with","any confusion with the","confusion with the original","the original work of","original work of the","work of the copyright","the copyright holders the","copyright holders the software","holders the software is","the software the name","software the name and","trademarks of copyright holder","of copyright holder s","copyright holder s may","holder s may not","s may not be","pertaining to the original","to the original or","the original or derivative","original or derivative works","derivative works without specific","works without specific written","to copyright in the","work and any associated","times remain with the","remain with the copyright","the educational community license this","educational community license this educational","community license this educational community","license this educational community license","this educational community license the","educational community license the license","community license the license applies","for the original work copyright","the original work copyright c","original work copyright c year","work copyright c year copyright","c year copyright holders licensed","year copyright holders licensed under","copyright holders licensed under the","holders licensed under the educational","educational community license version 1","community license version 1 0","version 1 0 this original","1 0 this original work","0 this original work including","this original work including software","original work including software source","work including software source code","including software source code documents","software source code documents or","source code documents or other","code documents or other related","the copyright holder s subject","copyright holder s subject to","holder s subject to the","s subject to the terms","the terms of the educational","terms of the educational community","the educational community license by","educational community license by obtaining"]},{"licenseTexts":["Educational Community License\n\nVersion 2.0, April 2007 http://www.osedu.org/licenses/\n\nThe Educational Community License version 2.0 (\"ECL\") consists of the Apache 2.0 license, modified to change the scope of the patent grant in section 3 to be specific to the needs of the education communities using this license. The original Apache 2.0 license can be found at: http://www.apache.org/licenses/LICENSE-2.0\n\nTERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n   1. Definitions.\n\n      \n\n      \"License\" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.\n\n      \n\n      \"Licensor\" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.\n\n      \n\n      \"Legal Entity\" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, \"control\" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.\n\n      \n\n      \"You\" (or \"Your\") shall mean an individual or Legal Entity exercising permissions granted by this License.\n\n      \n\n      \"Source\" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.\n\n      \n\n      \"Object\" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.\n\n      \n\n      \"Work\" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).\n\n      \n\n      \"Derivative Works\" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.\n\n      \n\n      \"Contribution\" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, \"submitted\" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as \"Not a Contribution.\"\n\n      \n\n      \"Contributor\" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.\n\n   2. Grant of Copyright License.\n\n   Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.\n\n   3. Grant of Patent License.\n\n   Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. Any patent license granted hereby with respect to contributions by an individual employed by an institution or organization is limited to patent claims where the individual that is the author of the Work is also the inventor of the patent claims licensed, and where the organization or institution has the right to grant such license under applicable grant and research funding agreements. No other express or implied licenses are granted.\n\n   4. Redistribution.\n\n   You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:\n\n      a. You must give any other recipients of the Work or Derivative Works a copy of this License; and\n\n      b. You must cause any modified files to carry prominent notices stating that You changed the files; and\n\n      c. You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and\n\n      d. If the Work includes a \"NOTICE\" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.\n\n      You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.\n\n   5. Submission of Contributions.\n\n   Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.\n\n   6. Trademarks.\n\n   This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.\n\n   7. Disclaimer of Warranty.\n\n   Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.\n\n   8. Limitation of Liability.\n\n   In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.\n\n   9. Accepting Warranty or Additional Liability.\n\nWhile redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS\n\nAPPENDIX: How to apply the Educational Community License to your work\n\nTo apply the Educational Community License to your work, attach\n\nthe following boilerplate notice, with the fields enclosed by\n\nbrackets \"[]\" replaced with your own identifying information.\n\n(Don't include the brackets!) The text should be enclosed in the\n\nappropriate comment syntax for the file format. We also recommend\n\nthat a file or class name and description of purpose be included on\n\nthe same \"printed page\" as the copyright notice for easier\n\nidentification within third-party archives.\n\nCopyright [yyyy] [name of copyright owner] Licensed under the\n\nEducational Community License, Version 2.0 (the \"License\"); you may\n\nnot use this file except in compliance with the License. You may\n\nobtain a copy of the License at\n\nhttp://www.osedu.org/licenses/ECL-2.0\n\nUnless required by applicable law or agreed to in writing,\n\nsoftware distributed under the License is distributed on an \"AS IS\"\n\nBASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express\n\nor implied. See the License for the specific language governing\n\npermissions and limitations under the License."],"licenseIds":["ECL-2.0"],"keywords":["2 0 april","0 april 2007","april 2007 http","2007 http www","licenses the educational","2 0 ecl","0 ecl consists","ecl consists of","the apache 2","0 license modified","license modified to","modified to change","change the scope","the patent grant","patent grant in","grant in section","section 3 to","3 to be","specific to the","to the needs","the needs of","needs of the","of the education","the education communities","education communities using","communities using this","the original apache","original apache 2","0 license can","is filed any","filed any patent","license granted hereby","granted hereby with","hereby with respect","respect to contributions","to contributions by","contributions by an","an individual employed","individual employed by","employed by an","by an institution","an institution or","institution or organization","or organization is","organization is limited","to patent claims","patent claims where","claims where the","where the individual","the individual that","individual that is","work is also","is also the","also the inventor","the inventor of","inventor of the","patent claims licensed","claims licensed and","licensed and where","where the organization","the organization or","organization or institution","or institution has","institution has the","grant such license","such license under","license under applicable","under applicable grant","applicable grant and","grant and research","and research funding","research funding agreements","funding agreements no","agreements no other","no other express","implied licenses are","licenses are granted","are granted 4","granted 4 redistribution","org licenses ecl","licenses ecl 2","ecl 2 0","version 2 0 april","2 0 april 2007","0 april 2007 http","april 2007 http www","2007 http www osedu","osedu org licenses the","org licenses the educational","licenses the educational community","version 2 0 ecl","2 0 ecl consists","0 ecl consists of","ecl consists of the","consists of the apache","of the apache 2","the apache 2 0","2 0 license modified","0 license modified to","license modified to change","modified to change the","to change the scope","change the scope of","scope of the patent","of the patent grant","the patent grant in","patent grant in section","grant in section 3","in section 3 to","section 3 to be","3 to be specific","be specific to the","specific to the needs","to the needs of","the needs of the","needs of the education","of the education communities","the education communities using","education communities using this","communities using this license","using this license the","license the original apache","the original apache 2","original apache 2 0","2 0 license can","0 license can be","license can be found","2 0 terms and","litigation is filed any","is filed any patent","filed any patent license","patent license granted hereby","license granted hereby with","granted hereby with respect","hereby with respect to","with respect to contributions","respect to contributions by","to contributions by an","contributions by an individual","by an individual employed","an individual employed by","individual employed by an","employed by an institution","by an institution or","an institution or organization","institution or organization is","or organization is limited","organization is limited to","is limited to patent","limited to patent claims","to patent claims where","patent claims where the","claims where the individual","where the individual that","the individual that is","individual that is the","that is the author","the work is also","work is also the","is also the inventor","also the inventor of","the inventor of the","inventor of the patent","the patent claims licensed","patent claims licensed and","claims licensed and where","licensed and where the","and where the organization","where the organization or","the organization or institution","organization or institution has","or institution has the","institution has the right","right to grant such","to grant such license","grant such license under","such license under applicable","license under applicable grant","under applicable grant and","applicable grant and research","grant and research funding","and research funding agreements","research funding agreements no","funding agreements no other","agreements no other express","no other express or","other express or implied","or implied licenses are","implied licenses are granted","licenses are granted 4","are granted 4 redistribution","granted 4 redistribution you","at http www osedu","osedu org licenses ecl","org licenses ecl 2","licenses ecl 2 0","ecl 2 0 unless","license version 2 0 april","version 2 0 april 2007","2 0 april 2007 http"]},{"licenseTexts":["Eiffel Forum License, version 1\n\nPermission is hereby granted to use, copy, modify and/or distribute this package, provided that:\n\n   - copyright notices are retained unchanged\n\n   - any distribution of this package, whether modified or not, includes this file\n\nPermission is hereby also granted to distribute binary programs which depend on this package, provided that:\n\n   - if the binary program depends on a modified version of this package, you must publicly release the modified version of this package\n\nTHIS PACKAGE IS PROVIDED \"AS IS\" AND WITHOUT WARRANTY. ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS BE LIABLE TO ANY PARTY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES ARISING IN ANY WAY OUT OF THE USE OF THIS PACKAGE."],"licenseIds":["EFL-1.0"],"keywords":["version 1 permission","includes this file","this file permission","file permission is","package you must","you must publicly","must publicly release","forum license version 1","license version 1 permission","version 1 permission is","not includes this file","includes this file permission","this file permission is","file permission is hereby","on this package provided","package provided that if","that if the binary","this package you must","package you must publicly","you must publicly release","must publicly release the","eiffel forum license version 1","forum license version 1 permission","license version 1 permission is","version 1 permission is hereby","or not includes this file","not includes this file permission","includes this file permission is","this file permission is hereby","file permission is hereby also","depend on this package provided","on this package provided that","this package provided that if","package provided that if the","provided that if the binary","that if the binary program","of this package you must","this package you must publicly","package you must publicly release","you must publicly release the","must publicly release the modified"]},{"licenseTexts":["Eiffel Forum License, version 2\n\n   1. Permission is hereby granted to use, copy, modify and/or distribute this package, provided that:\n\n      - copyright notices are retained unchanged,\n\n      - any distribution of this package, whether modified or not, includes this license text.\n\n   2. Permission is hereby also granted to distribute binary programs which depend on this package. If the binary program depends on a modified version of this package, you are encouraged to publicly release the modified version of this package.\n\nTHIS PACKAGE IS PROVIDED \"AS IS\" AND WITHOUT WARRANTY. ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS BE LIABLE TO ANY PARTY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES ARISING IN ANY WAY OUT OF THE USE OF THIS PACKAGE."],"licenseIds":["EFL-2.0"],"keywords":["2 1 permission","includes this license","license text 2","text 2 permission","2 permission is","package you are","encouraged to publicly","to publicly release","forum license version 2","version 2 1 permission","2 1 permission is","not includes this license","includes this license text","this license text 2","license text 2 permission","text 2 permission is","2 permission is hereby","on this package if","this package if the","package if the binary","this package you are","package you are encouraged","are encouraged to publicly","encouraged to publicly release","to publicly release the","eiffel forum license version 2","forum license version 2 1","license version 2 1 permission","version 2 1 permission is","2 1 permission is hereby","or not includes this license","not includes this license text","includes this license text 2","this license text 2 permission","license text 2 permission is","text 2 permission is hereby","2 permission is hereby also","depend on this package if","on this package if the","this package if the binary","package if the binary program","of this package you are","this package you are encouraged","package you are encouraged to","you are encouraged to publicly","are encouraged to publicly release","encouraged to publicly release the","to publicly release the modified"]},{"licenseTexts":["Eclipse Public License - v 1.0\n\nTHE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC LICENSE (\"AGREEMENT\"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.\n\n   1. DEFINITIONS\n\n   \"Contribution\" means:\n\n      a) in the case of the initial Contributor, the initial code and documentation distributed under this Agreement, and\n\n      b) in the case of each subsequent Contributor:\n\n         i) changes to the Program, and\n\n         ii) additions to the Program;\n\n         where such changes and/or additions to the Program originate from and are distributed by that particular Contributor. A Contribution 'originates' from a Contributor if it was added to the Program by such Contributor itself or anyone acting on such Contributor's behalf. Contributions do not include additions to the Program which: (i) are separate modules of software distributed in conjunction with the Program under their own license agreement, and (ii) are not derivative works of the Program.\n\n   \"Contributor\" means any person or entity that distributes the Program.\n\n   \"Licensed Patents\" mean patent claims licensable by a Contributor which are necessarily infringed by the use or sale of its Contribution alone or when combined with the Program.\n\n   \"Program\" means the Contributions distributed in accordance with this Agreement.\n\n   \"Recipient\" means anyone who receives the Program under this Agreement, including all Contributors.\n\n   2. GRANT OF RIGHTS\n\n      a) Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide, royalty-free copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, distribute and sublicense the Contribution of such Contributor, if any, and such derivative works, in source code and object code form.\n\n      b) Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide, royalty-free patent license under Licensed Patents to make, use, sell, offer to sell, import and otherwise transfer the Contribution of such Contributor, if any, in source code and object code form. This patent license shall apply to the combination of the Contribution and the Program if, at the time the Contribution is added by the Contributor, such addition of the Contribution causes such combination to be covered by the Licensed Patents. The patent license shall not apply to any other combinations which include the Contribution. No hardware per se is licensed hereunder.\n\n      c) Recipient understands that although each Contributor grants the licenses to its Contributions set forth herein, no assurances are provided by any Contributor that the Program does not infringe the patent or other intellectual property rights of any other entity. Each Contributor disclaims any liability to Recipient for claims brought by any other entity based on infringement of intellectual property rights or otherwise. As a condition to exercising the rights and licenses granted hereunder, each Recipient hereby assumes sole responsibility to secure any other intellectual property rights needed, if any. For example, if a third party patent license is required to allow Recipient to distribute the Program, it is Recipient's responsibility to acquire that license before distributing the Program.\n\n      d) Each Contributor represents that to its knowledge it has sufficient copyright rights in its Contribution, if any, to grant the copyright license set forth in this Agreement.\n\n   3. REQUIREMENTS\n\n   A Contributor may choose to distribute the Program in object code form under its own license agreement, provided that:\n\n      a) it complies with the terms and conditions of this Agreement; and\n\n      b) its license agreement:\n\n         i) effectively disclaims on behalf of all Contributors all warranties and conditions, express and implied, including warranties or conditions of title and non-infringement, and implied warranties or conditions of merchantability and fitness for a particular purpose;\n\n         ii) effectively excludes on behalf of all Contributors all liability for damages, including direct, indirect, special, incidental and consequential damages, such as lost profits;\n\n         iii) states that any provisions which differ from this Agreement are offered by that Contributor alone and not by any other party; and\n\n         iv) states that source code for the Program is available from such Contributor, and informs licensees how to obtain it in a reasonable manner on or through a medium customarily used for software exchange.\n\n   When the Program is made available in source code form:\n\n      a) it must be made available under this Agreement; and\n\n      b) a copy of this Agreement must be included with each copy of the Program.\n\n      Contributors may not remove or alter any copyright notices contained within the Program.\n\n   Each Contributor must identify itself as the originator of its Contribution, if any, in a manner that reasonably allows subsequent Recipients to identify the originator of the Contribution.\n\n   4. COMMERCIAL DISTRIBUTION\n\n   Commercial distributors of software may accept certain responsibilities with respect to end users, business partners and the like. While this license is intended to facilitate the commercial use of the Program, the Contributor who includes the Program in a commercial product offering should do so in a manner which does not create potential liability for other Contributors. Therefore, if a Contributor includes the Program in a commercial product offering, such Contributor (\"Commercial Contributor\") hereby agrees to defend and indemnify every other Contributor (\"Indemnified Contributor\") against any losses, damages and costs (collectively \"Losses\") arising from claims, lawsuits and other legal actions brought by a third party against the Indemnified Contributor to the extent caused by the acts or omissions of such Commercial Contributor in connection with its distribution of the Program in a commercial product offering. The obligations in this section do not apply to any claims or Losses relating to any actual or alleged intellectual property infringement. In order to qualify, an Indemnified Contributor must: a) promptly notify the Commercial Contributor in writing of such claim, and b) allow the Commercial Contributor to control, and cooperate with the Commercial Contributor in, the defense and any related settlement negotiations. The Indemnified Contributor may participate in any such claim at its own expense.\n\n   For example, a Contributor might include the Program in a commercial product offering, Product X. That Contributor is then a Commercial Contributor. If that Commercial Contributor then makes performance claims, or offers warranties related to Product X, those performance claims and warranties are such Commercial Contributor's responsibility alone. Under this section, the Commercial Contributor would have to defend claims against the other Contributors related to those performance claims and warranties, and if a court requires any other Contributor to pay any damages as a result, the Commercial Contributor must pay those damages.\n\n   5. NO WARRANTY\n\n   EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED ON AN \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely responsible for determining the appropriateness of using and distributing the Program and assumes all risks associated with its exercise of rights under this Agreement, including but not limited to the risks and costs of program errors, compliance with applicable laws, damage to or loss of data, programs or equipment, and unavailability or interruption of operations.\n\n   6. DISCLAIMER OF LIABILITY\n\n   EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\n   7. GENERAL\n\n   If any provision of this Agreement is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this Agreement, and without further action by the parties hereto, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.\n\n   If Recipient institutes patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Program itself (excluding combinations of the Program with other software or hardware) infringes such Recipient's patent(s), then such Recipient's rights granted under Section 2(b) shall terminate as of the date such litigation is filed.\n\n   All Recipient's rights under this Agreement shall terminate if it fails to comply with any of the material terms or conditions of this Agreement and does not cure such failure in a reasonable period of time after becoming aware of such noncompliance. If all Recipient's rights under this Agreement terminate, Recipient agrees to cease use and distribution of the Program as soon as reasonably practicable. However, Recipient's obligations under this Agreement and any licenses granted by Recipient relating to the Program shall continue and survive.\n\n   Everyone is permitted to copy and distribute copies of this Agreement, but in order to avoid inconsistency the Agreement is copyrighted and may only be modified in the following manner. The Agreement Steward reserves the right to publish new versions (including revisions) of this Agreement from time to time. No one other than the Agreement Steward has the right to modify this Agreement. The Eclipse Foundation is the initial Agreement Steward. The Eclipse Foundation may assign the responsibility to serve as the Agreement Steward to a suitable separate entity. Each new version of the Agreement will be given a distinguishing version number. The Program (including Contributions) may always be distributed subject to the version of the Agreement under which it was received. In addition, after a new version of the Agreement is published, Contributor may elect to distribute the Program (including its Contributions) under the new version. Except as expressly stated in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to the intellectual property of any Contributor under this Agreement, whether expressly, by implication, estoppel or otherwise. All rights in the Program not expressly granted under this Agreement are reserved.\n\n   This Agreement is governed by the laws of the State of New York and the intellectual property laws of the United States of America. No party to this Agreement will bring a legal action under this Agreement more than one year after the cause of action arose. Each party waives its rights to a jury trial in any resulting litigation."],"licenseIds":["EPL-1.0"],"keywords":["v 1 0 the","license v 1 0 the","v 1 0 the accompanying"]},{"licenseTexts":["Eclipse Public License - v 2.0\n\nTHE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC LICENSE (\"AGREEMENT\"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.\n\n   1. DEFINITIONS\n\n   \"Contribution\" means:\n\n      a) in the case of the initial Contributor, the initial content Distributed under this Agreement, and\n\n      b) in the case of each subsequent Contributor:\n\n         i) changes to the Program, and\n\n         ii) additions to the Program;\n\n      where such changes and/or additions to the Program originate from and are Distributed by that particular Contributor. A Contribution \"originates\" from a Contributor if it was added to the Program by such Contributor itself or anyone acting on such Contributor's behalf. Contributions do not include changes or additions to the Program that are not Modified Works.\n\n   \"Contributor\" means any person or entity that Distributes the Program.\n\n   \"Licensed Patents\" mean patent claims licensable by a Contributor which are necessarily infringed by the use or sale of its Contribution alone or when combined with the Program.\n\n   \"Program\" means the Contributions Distributed in accordance with this Agreement.\n\n   \"Recipient\" means anyone who receives the Program under this Agreement or any Secondary License (as applicable), including Contributors.\n\n   \"Derivative Works\" shall mean any work, whether in Source Code or other form, that is based on (or derived from) the Program and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship.\n\n   \"Modified Works\" shall mean any work in Source Code or other form that results from an addition to, deletion from, or modification of the contents of the Program, including, for purposes of clarity any new file in Source Code form that contains any contents of the Program. Modified Works shall not include works that contain only declarations, interfaces, types, classes, structures, or files of the Program solely in each case in order to link to, bind by name, or subclass the Program or Modified Works thereof.\n\n   \"Distribute\" means the acts of a) distributing or b) making available in any manner that enables the transfer of a copy.\n\n   \"Source Code\" means the form of a Program preferred for making modifications, including but not limited to software source code, documentation source, and configuration files.\n\n   \"Secondary License\" means either the GNU General Public License, Version 2.0, or any later versions of that license, including any exceptions or additional permissions as identified by the initial Contributor.\n\n   2. GRANT OF RIGHTS\n\n      a) Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide, royalty-free copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, Distribute and sublicense the Contribution of such Contributor, if any, and such Derivative Works.\n\n      b) Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide, royalty-free patent license under Licensed Patents to make, use, sell, offer to sell, import and otherwise transfer the Contribution of such Contributor, if any, in Source Code or other form. This patent license shall apply to the combination of the Contribution and the Program if, at the time the Contribution is added by the Contributor, such addition of the Contribution causes such combination to be covered by the Licensed Patents. The patent license shall not apply to any other combinations which include the Contribution. No hardware per se is licensed hereunder.\n\n      c) Recipient understands that although each Contributor grants the licenses to its Contributions set forth herein, no assurances are provided by any Contributor that the Program does not infringe the patent or other intellectual property rights of any other entity. Each Contributor disclaims any liability to Recipient for claims brought by any other entity based on infringement of intellectual property rights or otherwise. As a condition to exercising the rights and licenses granted hereunder, each Recipient hereby assumes sole responsibility to secure any other intellectual property rights needed, if any. For example, if a third party patent license is required to allow Recipient to Distribute the Program, it is Recipient's responsibility to acquire that license before distributing the Program.\n\n      d) Each Contributor represents that to its knowledge it has sufficient copyright rights in its Contribution, if any, to grant the copyright license set forth in this Agreement.\n\n      e) Notwithstanding the terms of any Secondary License, no Contributor makes additional grants to any Recipient (other than those set forth in this Agreement) as a result of such Recipient's receipt of the Program under the terms of a Secondary License (if permitted under the terms of Section 3).\n\n   3. REQUIREMENTS\n\n      3.1 If a Contributor Distributes the Program in any form, then:\n\n         a) the Program must also be made available as Source Code, in accordance with section 3.2, and the Contributor must accompany the Program with a statement that the Source Code for the Program is available under this Agreement, and informs Recipients how to obtain it in a reasonable manner on or through a medium customarily used for software exchange; and\n\n         b) the Contributor may Distribute the Program under a license different than this Agreement, provided that such license:\n\n            i) effectively disclaims on behalf of all other Contributors all warranties and conditions, express and implied, including warranties or conditions of title and non-infringement, and implied warranties or conditions of merchantability and fitness for a particular purpose;\n\n            ii) effectively excludes on behalf of all other Contributors all liability for damages, including direct, indirect, special, incidental and consequential damages, such as lost profits;\n\n            iii) does not attempt to limit or alter the recipients' rights in the Source Code under section 3.2; and\n\n            iv) requires any subsequent distribution of the Program by any party to be under a license that satisfies the requirements of this section 3.\n\n      3.2 When the Program is Distributed as Source Code:\n\n         a) it must be made available under this Agreement, or if the Program (i) is combined with other material in a separate file or files made available under a Secondary License, and (ii) the initial Contributor attached to the Source Code the notice described in Exhibit A of this Agreement, then the Program may be made available under the terms of such Secondary Licenses, and\n\n         b) a copy of this Agreement must be included with each copy of the Program.\n\n      3.3 Contributors may not remove or alter any copyright, patent, trademark, attribution notices, disclaimers of warranty, or limitations of liability (\"notices\") contained within the Program from any copy of the Program which they Distribute, provided that Contributors may add their own appropriate notices.\n\n   4. COMMERCIAL DISTRIBUTION\n\n   Commercial distributors of software may accept certain responsibilities with respect to end users, business partners and the like. While this license is intended to facilitate the commercial use of the Program, the Contributor who includes the Program in a commercial product offering should do so in a manner which does not create potential liability for other Contributors. Therefore, if a Contributor includes the Program in a commercial product offering, such Contributor (\"Commercial Contributor\") hereby agrees to defend and indemnify every other Contributor (\"Indemnified Contributor\") against any losses, damages and costs (collectively \"Losses\") arising from claims, lawsuits and other legal actions brought by a third party against the Indemnified Contributor to the extent caused by the acts or omissions of such Commercial Contributor in connection with its distribution of the Program in a commercial product offering. The obligations in this section do not apply to any claims or Losses relating to any actual or alleged intellectual property infringement. In order to qualify, an Indemnified Contributor must: a) promptly notify the Commercial Contributor in writing of such claim, and b) allow the Commercial Contributor to control, and cooperate with the Commercial Contributor in, the defense and any related settlement negotiations. The Indemnified Contributor may participate in any such claim at its own expense.\n\n   For example, a Contributor might include the Program in a commercial product offering, Product X. That Contributor is then a Commercial Contributor. If that Commercial Contributor then makes performance claims, or offers warranties related to Product X, those performance claims and warranties are such Commercial Contributor's responsibility alone. Under this section, the Commercial Contributor would have to defend claims against the other Contributors related to those performance claims and warranties, and if a court requires any other Contributor to pay any damages as a result, the Commercial Contributor must pay those damages.\n\n   5. NO WARRANTY\n\n   EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely responsible for determining the appropriateness of using and distributing the Program and assumes all risks associated with its exercise of rights under this Agreement, including but not limited to the risks and costs of program errors, compliance with applicable laws, damage to or loss of data, programs or equipment, and unavailability or interruption of operations.\n\n   6. DISCLAIMER OF LIABILITY\n\n   EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\n   7. GENERAL\n\n   If any provision of this Agreement is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this Agreement, and without further action by the parties hereto, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.\n\n   If Recipient institutes patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Program itself (excluding combinations of the Program with other software or hardware) infringes such Recipient's patent(s), then such Recipient's rights granted under Section 2(b) shall terminate as of the date such litigation is filed.\n\n   All Recipient's rights under this Agreement shall terminate if it fails to comply with any of the material terms or conditions of this Agreement and does not cure such failure in a reasonable period of time after becoming aware of such noncompliance. If all Recipient's rights under this Agreement terminate, Recipient agrees to cease use and distribution of the Program as soon as reasonably practicable. However, Recipient's obligations under this Agreement and any licenses granted by Recipient relating to the Program shall continue and survive.\n\n   Everyone is permitted to copy and distribute copies of this Agreement, but in order to avoid inconsistency the Agreement is copyrighted and may only be modified in the following manner. The Agreement Steward reserves the right to publish new versions (including revisions) of this Agreement from time to time. No one other than the Agreement Steward has the right to modify this Agreement. The Eclipse Foundation is the initial Agreement Steward. The Eclipse Foundation may assign the responsibility to serve as the Agreement Steward to a suitable separate entity. Each new version of the Agreement will be given a distinguishing version number. The Program (including Contributions) may always be Distributed subject to the version of the Agreement under which it was received. In addition, after a new version of the Agreement is published, Contributor may elect to Distribute the Program (including its Contributions) under the new version.\n\n   Except as expressly stated in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to the intellectual property of any Contributor under this Agreement, whether expressly, by implication, estoppel or otherwise. All rights in the Program not expressly granted under this Agreement are reserved. Nothing in this Agreement is intended to be enforceable by any entity that is not a Contributor or Recipient. No third-party beneficiary rights are created under this Agreement.\n\n   Exhibit A - Form of Secondary Licenses Notice\n\n   \"This Source Code may also be made available under the following Secondary Licenses when the conditions for such availability set forth in the Eclipse Public License, v. 2.0 are satisfied: {name license(s), version(s), and exceptions or additional permissions here}.\"\n\n   Simply including a copy of this Agreement, including this Exhibit A is not sufficient to license the Source Code under Secondary Licenses.\n\n   If it is not possible or desirable to put the notice in a particular file, then You may include the notice in a location (such as a LICENSE file in a relevant directory) where a recipient would be likely to look for such a notice.\n\n   You may add additional accurate notices of copyright ownership."],"licenseIds":["EPL-2.0"],"keywords":["the initial content","initial content distributed","content distributed under","not include changes","include changes or","program that are","are not modified","not modified works","modified works contributor","works contributor means","or any secondary","secondary license as","license as applicable","as applicable including","applicable including contributors","including contributors derivative","contributors derivative works","program and for","of authorship modified","authorship modified works","any work in","program including for","purposes of clarity","of clarity any","clarity any new","contains any contents","any contents of","the program modified","program modified works","works that contain","that contain only","contain only declarations","only declarations interfaces","declarations interfaces types","interfaces types classes","types classes structures","classes structures or","structures or files","or files of","the program solely","program solely in","solely in each","each case in","case in order","order to link","to link to","link to bind","to bind by","name or subclass","or subclass the","subclass the program","or modified works","modified works thereof","works thereof distribute","thereof distribute means","distribute means the","means the acts","the acts of","acts of a","of a distributing","a distributing or","distributing or b","b making available","making available in","manner that enables","that enables the","enables the transfer","the transfer of","a copy source","copy source code","a program preferred","program preferred for","configuration files secondary","files secondary license","that license including","including any exceptions","any exceptions or","additional permissions as","permissions as identified","as identified by","identified by the","initial contributor 2","contributor 2 grant","works b subject","other form this","this agreement e","agreement e notwithstanding","e notwithstanding the","notwithstanding the terms","of any secondary","secondary license no","license no contributor","additional grants to","any recipient other","recipient other than","than those set","result of such","of such recipient","recipient s receipt","s receipt of","3 3 requirements","3 requirements 3","a contributor distributes","contributor distributes the","any form then","then a the","program must also","code in accordance","2 and the","contributor must accompany","accompany the program","agreement and informs","and informs recipients","informs recipients how","recipients how to","software exchange and","exchange and b","b the contributor","the contributor may","contributor may distribute","a license different","license different than","different than this","this agreement provided","such license i","license i effectively","profits iii does","iii does not","code under section","2 and iv","and iv requires","iv requires any","requires any subsequent","any subsequent distribution","subsequent distribution of","any party to","to be under","license that satisfies","that satisfies the","satisfies the requirements","distributed as source","code a it","agreement or if","the program i","program i is","i is combined","or files made","files made available","under a secondary","secondary license and","ii the initial","initial contributor attached","contributor attached to","code the notice","agreement then the","then the program","such secondary licenses","licenses and b","3 3 contributors","3 contributors may","patent trademark attribution","trademark attribution notices","attribution notices disclaimers","of liability notices","liability notices contained","program from any","from any copy","program which they","which they distribute","they distribute provided","distribute provided that","provided that contributors","that contributors may","contributors may add","their own appropriate","own appropriate notices","appropriate notices 4","notices 4 commercial","law the program","law neither recipient","agreement is intended","to be enforceable","be enforceable by","enforceable by any","by any entity","not a contributor","contributor or recipient","or recipient no","recipient no third","rights are created","are created under","this agreement exhibit","agreement exhibit a","exhibit a form","form of secondary","of secondary licenses","code may also","the following secondary","following secondary licenses","secondary licenses when"]},{"licenseTexts":["EU DataGrid Software License Copyright (c) 2001 EU DataGrid. All rights reserved.\n\nThis software includes voluntary contributions made to the EU DataGrid. For more information on the EU DataGrid, please see http://www.eu-datagrid.org/.\n\nInstallation, use, reproduction, display, modification and redistribution of this software, with or without modification, in source and binary forms, are permitted. Any exercise of rights under this license by you or your sub-licensees is subject to the following conditions:\n\n   1. Redistributions of this software, with or without modification, must reproduce the above copyright notice and the above license statement as well as this list of conditions, in the software, the user documentation and any other materials provided with the software.\n\n   2. The user documentation, if any, included with a redistribution, must include the following notice:\n\n   \"This product includes software developed by the EU DataGrid (http://www.eu-datagrid.org/).\"\n\n   Alternatively, if that is where third-party acknowledgments normally appear, this acknowledgment must be reproduced in the software itself.\n\n   3. The names \"EDG\", \"EDG Toolkit\", \"EU DataGrid\" and \"EU DataGrid Project\" may not be used to endorse or promote software, or products derived therefrom, except with prior written permission by hep-project-grid-edg-license@cern.ch.\n\n   4. You are under no obligation to provide anyone with any bug fixes, patches, upgrades or other modifications, enhancements or derivatives of the features, functionality or performance of this software that you may develop. However, if you publish or distribute your modifications, enhancements or derivative works without contemporaneously requiring users to enter into a separate written license agreement, then you are deemed to have granted participants in the EU DataGrid a worldwide, non-exclusive, royalty-free, perpetual license to install, use, reproduce, display, modify, redistribute and sub-license your modifications, enhancements or derivative works, whether in binary or source code form, under the license conditions stated in this list of conditions.\n\n   5. DISCLAIMER\n\n   THIS SOFTWARE IS PROVIDED BY THE EU DATAGRID AND CONTRIBUTORS \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, OF SATISFACTORY QUALITY, AND FITNESS FOR A PARTICULAR PURPOSE OR USE ARE DISCLAIMED. THE EU DATAGRID AND CONTRIBUTORS MAKE NO REPRESENTATION THAT THE SOFTWARE, MODIFICATIONS, ENHANCEMENTS OR DERIVATIVE WORKS THEREOF, WILL NOT INFRINGE ANY PATENT, COPYRIGHT, TRADE SECRET OR OTHER PROPRIETARY RIGHT.\n\n   6. LIMITATION OF LIABILITY\n\nTHE EU DATAGRID AND CONTRIBUTORS SHALL HAVE NO LIABILITY TO LICENSEE OR OTHER PERSONS FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, CONSEQUENTIAL, EXEMPLARY, OR PUNITIVE DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT LIMITATION, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, LOSS OF USE, DATA OR PROFITS, OR BUSINESS INTERRUPTION, HOWEVER CAUSED AND ON ANY THEORY OF CONTRACT, WARRANTY, TORT (INCLUDING NEGLIGENCE), PRODUCT LIABILITY OR OTHERWISE, ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES."],"licenseIds":["EUDatagrid"],"keywords":["eu datagrid software","datagrid software license","software license copyright","c 2001 eu","2001 eu datagrid","eu datagrid all","datagrid all rights","software includes voluntary","to the eu","eu datagrid for","datagrid for more","on the eu","eu datagrid please","datagrid please see","datagrid org installation","license by you","or your sub","your sub licensees","sub licensees is","licensees is subject","above license statement","license statement as","statement as well","well as this","as this list","software the user","user documentation and","any other materials","2 the user","user documentation if","if any included","any included with","eu datagrid http","datagrid http www","datagrid org alternatively","itself 3 the","the names edg","names edg edg","edg edg toolkit","edg toolkit eu","toolkit eu datagrid","datagrid and eu","and eu datagrid","eu datagrid project","datagrid project may","project may not","derived therefrom except","therefrom except with","except with prior","with prior written","written permission by","permission by hep","by hep project","hep project grid","project grid edg","grid edg license","edg license cern","license cern ch","cern ch 4","ch 4 you","to provide anyone","provide anyone with","anyone with any","with any bug","fixes patches upgrades","patches upgrades or","upgrades or other","other modifications enhancements","enhancements or derivatives","or derivatives of","derivatives of the","of the features","may develop however","develop however if","or distribute your","works without contemporaneously","without contemporaneously requiring","contemporaneously requiring users","requiring users to","users to enter","enter into a","into a separate","license agreement then","agreement then you","then you are","to have granted","have granted participants","granted participants in","participants in the","in the eu","eu datagrid a","datagrid a worldwide","install use reproduce","reproduce display modify","display modify redistribute","redistribute and sub","and sub license","derivative works whether","works whether in","whether in binary","in binary or","binary or source","license conditions stated","of conditions 5","conditions 5 disclaimer","5 disclaimer this","disclaimed the eu","and contributors make","contributors make no","proprietary right 6","right 6 limitation","6 limitation of","liability the eu","eu datagrid software license","datagrid software license copyright","software license copyright c","license copyright c 2001","copyright c 2001 eu","c 2001 eu datagrid","2001 eu datagrid all","eu datagrid all rights","datagrid all rights reserved","reserved this software includes","this software includes voluntary","software includes voluntary contributions","made to the eu","to the eu datagrid","the eu datagrid for","eu datagrid for more","datagrid for more information","information on the eu","on the eu datagrid","the eu datagrid please","eu datagrid please see","datagrid please see http","see http www eu","eu datagrid org installation","datagrid org installation use","this license by you","license by you or","you or your sub","or your sub licensees","your sub licensees is","sub licensees is subject","licensees is subject to","notice and the above","and the above license","the above license statement","above license statement as","license statement as well","statement as well as","as well as this","well as this list","as this list of","of conditions in the","conditions in the software","the software the user","software the user documentation","the user documentation and","user documentation and any","documentation and any other","and any other materials","any other materials provided","software 2 the user","2 the user documentation","the user documentation if","user documentation if any","documentation if any included","if any included with","any included with a","developed by the eu","the eu datagrid http","eu datagrid http www","datagrid http www eu","eu datagrid org alternatively","datagrid org alternatively if","software itself 3 the","itself 3 the names","3 the names edg","the names edg edg","names edg edg toolkit","edg edg toolkit eu","edg toolkit eu datagrid","toolkit eu datagrid and","eu datagrid and eu","datagrid and eu datagrid","and eu datagrid project","eu datagrid project may","datagrid project may not","project may not be","products derived therefrom except","derived therefrom except with","therefrom except with prior","except with prior written","with prior written permission","prior written permission by","written permission by hep","permission by hep project","by hep project grid","hep project grid edg"]},{"licenseTexts":["European Union Public Licence V.1.0 EUPL (c) the European Community 2007 This European Union Public Licence (the \"EUPL\") applies to the Work or Software (as defined below) which is provided under the terms of this Licence. Any use of the Work, other than as authorised under this Licence is prohibited (to the extent such use is covered by a right of the copyright holder of the Work).\n\nThe Original Work is provided under the terms of this Licence when the Licensor (as defined below) has placed the following notice immediately following the copyright notice for the Original Work:\n\nLicensed under the EUPL V.1.0\n\nor has expressed by any other mean his willingness to license under the EUPL.\n\n   1. Definitions\n\n   In this Licence, the following terms have the following meaning:\n\n      − The Licence: this Licence.\n\n      − The Original Work or the Software: the software distributed and/or communicated by the Licensor under this Licence, available as Source Code and also as Executable Code as the case may be.\n\n      − Derivative Works: the works or software that could be created by the Licensee, based upon the Original Work or modifications thereof. This Licence does not define the extent of modification or dependence on the Original Work required in order to classify a work as a Derivative Work; this extent is determined by copyright law applicable in the country mentioned in Article 15.\n\n      − The Work: the Original Work and/or its Derivative Works.\n\n      − The Source Code: the human-readable form of the Work which is the most convenient for people to study and modify.\n\n      − The Executable Code: any code which has generally been compiled and which is meant to be interpreted by a computer as a program.\n\n      − The Licensor: the natural or legal person that distributes and/or communicates the Work under the Licence.\n\n      − Contributor(s): any natural or legal person who modifies the Work under the Licence, or otherwise contributes to the creation of a Derivative Work.\n\n      − The Licensee or \"You\": any natural or legal person who makes any usage of the Software under the terms of the Licence. − Distribution and/or Communication: any act of selling, giving, lending, renting, distributing, communicating, transmitting, or otherwise making available, on-line or off-line, copies of the Work at the disposal of any other natural or legal person.\n\n   2. Scope of the rights granted by the Licence\n\n   The Licensor hereby grants You a world-wide, royalty-free, non-exclusive, sub-licensable licence to do the following, for the duration of copyright vested in the Original Work:\n\n      − use the Work in any circumstance and for all usage,\n\n      − reproduce the Work,\n\n      − modify the Original Work, and make Derivative Works based upon the Work,\n\n      − communicate to the public, including the right to make available or display the Work or copies thereof to the public and perform publicly, as the case may be, the Work,\n\n      − distribute the Work or copies thereof,\n\n      − lend and rent the Work or copies thereof,\n\n      − sub-license rights in the Work or copies thereof.\n\n   Those rights can be exercised on any media, supports and formats, whether now known or later invented, as far as the applicable law permits so.\n\n   In the countries where moral rights apply, the Licensor waives his right to exercise his moral right to the extent allowed by law in order to make effective the licence of the economic rights here above listed.\n\n   The Licensor grants to the Licensee royalty-free, non exclusive usage rights to any patents held by the Licensor, to the extent necessary to make use of the rights granted on the Work under this Licence.\n\n   3. Communication of the Source Code\n\n   The Licensor may provide the Work either in its Source Code form, or as Executable Code. If the Work is provided as Executable Code, the Licensor provides in addition a machinereadable copy of the Source Code of the Work along with each copy of the Work that the Licensor distributes or indicates, in a notice following the copyright notice attached to the Work, a repository where the Source Code is easily and freely accessible for as long as the Licensor continues to distribute and/or communicate the Work.\n\n   4. Limitations on copyright\n\n   Nothing in this Licence is intended to deprive the Licensee of the benefits from any exception or limitation to the exclusive rights of the rights owners in the Original Work or Software, of the exhaustion of those rights or of other applicable limitations thereto.\n\n   5. Obligations of the Licensee\n\n   The grant of the rights mentioned above is subject to some restrictions and obligations imposed on the Licensee. Those obligations are the following:\n\n   Attribution right: the Licensee shall keep intact all copyright, patent or trademarks notices and all notices that refer to the Licence and to the disclaimer of warranties. The Licensee must include a copy of such notices and a copy of the Licence with every copy of the Work he/she distributes and/or communicates. The Licensee must cause any Derivative Work to carry prominent notices stating that the Work has been modified and the date of modification.\n\n   Copyleft clause: If the Licensee distributes and/or communicates copies of the Original Works or Derivative Works based upon the Original Work, this Distribution and/or Communication will be done under the terms of this Licence. The Licensee (becoming Licensor) cannot offer or impose any additional terms or conditions on the Work or Derivative Work that alter or restrict the terms of the Licence.\n\n   Compatibility clause: If the Licensee Distributes and/or Communicates Derivative Works or copies thereof based upon both the Original Work and another work licensed under a Compatible Licence, this Distribution and/or Communication can be done under the terms of this Compatible Licence. For the sake of this clause, \"Compatible Licence\" refers to the licences listed in the appendix attached to this Licence. Should the Licensee's obligations under the Compatible Licence conflict with his/her obligations under this Licence, the obligations of the Compatible Licence shall prevail.\n\n   Provision of Source Code: When distributing and/or communicating copies of the Work, the Licensee will provide a machine-readable copy of the Source Code or indicate a repository where this Source will be easily and freely available for as long as the Licensee continues to distribute and/or communicate the Work.\n\n   Legal Protection: This Licence does not grant permission to use the trade names, trademarks, service marks, or names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the copyright notice.\n\n   6. Chain of Authorship\n\n   The original Licensor warrants that the copyright in the Original Work granted hereunder is owned by him/her or licensed to him/her and that he/she has the power and authority to grant the Licence.\n\n   Each Contributor warrants that the copyright in the modifications he/she brings to the Work are owned by him/her or licensed to him/her and that he/she has the power and authority to grant the Licence.\n\n   Each time You, as a Licensee, receive the Work, the original Licensor and subsequent Contributors grant You a licence to their contributions to the Work, under the terms of this Licence.\n\n   7. Disclaimer of Warranty\n\n   The Work is a work in progress, which is continuously improved by numerous contributors. It is not a finished work and may therefore contain defects or \"bugs\" inherent to this type of software development.\n\n   For the above reason, the Work is provided under the Licence on an \"as is\" basis and without warranties of any kind concerning the Work, including without limitation merchantability, fitness for a particular purpose, absence of defects or errors, accuracy, non-infringement of intellectual property rights other than copyright as stated in Article 6 of this Licence.\n\n   This disclaimer of warranty is an essential part of the Licence and a condition for the grant of any rights to the Work.\n\n   8. Disclaimer of Liability\n\n   Except in the cases of wilful misconduct or damages directly caused to natural persons, the Licensor will in no event be liable for any direct or indirect, material or moral, damages of any kind, arising out of the Licence or of the use of the Work, including without limitation, damages for loss of goodwill, work stoppage, computer failure or malfunction, loss of data or any commercial damage, even if the Licensor has been advised of the possibility of such damage. However, the Licensor will be liable under statutory product liability laws as far such laws apply to the Work.\n\n   9. Additional agreements\n\n   While distributing the Original Work or Derivative Works, You may choose to conclude an additional agreement to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or services consistent with this Licence. However, in accepting such obligations, You may act only on your own behalf and on your sole responsibility, not on behalf of the original Licensor or any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against such Contributor by the fact You have accepted any such warranty or additional liability.\n\n   10. Acceptance of the Licence\n\n   The provisions of this Licence can be accepted by clicking on an icon \"I agree\" placed under the bottom of a window displaying the text of this Licence or by affirming consent in any other similar way, in accordance with the rules of applicable law. Clicking on that icon indicates your clear and irrevocable acceptance of this Licence and all of its terms and conditions.\n\n   Similarly, you irrevocably accept this Licence and all of its terms and conditions by exercising any rights granted to You by Article 2 of this Licence, such as the use of the Work, the creation by You of a Derivative Work or the Distribution and/or Communication by You of the Work or copies thereof.\n\n   11. Information to the public\n\n   In case of any Distribution and/or Communication of the Work by means of electronic communication by You (for example, by offering to download the Work from a remote location) the distribution channel or media (for example, a website) must at least provide to the public the information requested by the applicable law regarding the identification and address of the Licensor, the Licence and the way it may be accessible, concluded, stored and reproduced by the Licensee.\n\n   12. Termination of the Licence\n\n   The Licence and the rights granted hereunder will terminate automatically upon any breach by the Licensee of the terms of the Licence.\n\n   Such a termination will not terminate the licences of any person who has received the Work from the Licensee under the Licence, provided such persons remain in full compliance with the Licence.\n\n   13. Miscellaneous\n\n   Without prejudice of Article 9 above, the Licence represents the complete agreement between the Parties as to the Work licensed hereunder.\n\n   If any provision of the Licence is invalid or unenforceable under applicable law, this will not affect the validity or enforceability of the Licence as a whole. Such provision will be construed and/or reformed so as necessary to make it valid and enforceable.\n\n   The European Commission may put into force translations and/or binding new versions of this Licence, so far this is required and reasonable. New versions of the Licence will be published with a unique version number. The new version of the Licence becomes binding for You as soon as You become aware of its publication.\n\n   14. Jurisdiction\n\n   Any litigation resulting from the interpretation of this License, arising between the European Commission, as a Licensor, and any Licensee, will be subject to the jurisdiction of the Court of Justice of the European Communities, as laid down in article 238 of the Treaty establishing the European Community.\n\n   Any litigation arising between Parties, other than the European Commission, and resulting from the interpretation of this License, will be subject to the exclusive jurisdiction of the competent court where the Licensor resides or conducts its primary business.\n\n   15. Applicable Law\n\n   This Licence shall be governed by the law of the European Union country where the Licensor resides or has his registered office.\n\n   This licence shall be governed by the Belgian law if:\n\n      − a litigation arises between the European Commission, as a Licensor, and any Licensee;\n\n      − the Licensor, other than the European Commission, has no residence or registered office inside a European Union country.\n\nAppendix\n\n\"Compatible Licences\" according to article 5 EUPL are:\n\n   − General Public License (GPL) v. 2\n\n   − Open Software License (OSL) v. 2.1, v. 3.0\n\n   − Common Public License v. 1.0\n\n   − Eclipse Public License v. 1.0\n\n   − Cecill v. 2.0"],"licenseIds":["EUPL-1.0"],"keywords":["1 0 eupl","0 eupl c","0 or has","work at the","non exclusive sub","exclusive sub licensable","sub licensable licence","licensable licence to","addition a machinereadable","a machinereadable copy","machinereadable copy of","time you as","you as a","as a licensee","a licensee receive","licensee receive the","regarding the identification","the identification and","identification and address","and address of","address of the","commission may put","may put into","put into force","into force translations","force translations and","translations and or","and or binding","or binding new","binding new versions","number the new","the licence becomes","licence becomes binding","becomes binding for","binding for you","for you as","you as soon","soon as you","as you become","become aware of","aware of its","of its publication","its publication 14","publication 14 jurisdiction","eupl are general","are general public","licence v 1 0","v 1 0 eupl","1 0 eupl c","0 eupl c the","eupl v 1 0","v 1 0 or","1 0 or has","0 or has expressed","the work at the","work at the disposal","free non exclusive sub","non exclusive sub licensable","exclusive sub licensable licence","sub licensable licence to","licensable licence to do","in addition a machinereadable","addition a machinereadable copy","a machinereadable copy of","machinereadable copy of the","each time you as","time you as a","you as a licensee","as a licensee receive","a licensee receive the","licensee receive the work","receive the work the","work the original licensor","law regarding the identification","regarding the identification and","the identification and address","identification and address of","and address of the","address of the licensor","european commission may put","commission may put into","may put into force","put into force translations","into force translations and","force translations and or","translations and or binding","and or binding new","or binding new versions","binding new versions of","reasonable new versions of","unique version number the","version number the new","number the new version","of the licence becomes","the licence becomes binding","licence becomes binding for","becomes binding for you","binding for you as","for you as soon","you as soon as","as soon as you","soon as you become","as you become aware","you become aware of","become aware of its","aware of its publication","of its publication 14","its publication 14 jurisdiction","publication 14 jurisdiction any","5 eupl are general","eupl are general public","are general public license","public licence v 1 0","licence v 1 0 eupl","v 1 0 eupl c","1 0 eupl c the","0 eupl c the european","the eupl v 1 0","eupl v 1 0 or","v 1 0 or has","1 0 or has expressed","0 or has expressed by","copies of the work at","of the work at the","the work at the disposal","work at the disposal of","royalty free non exclusive sub","free non exclusive sub licensable","non exclusive sub licensable licence","exclusive sub licensable licence to","sub licensable licence to do","licensable licence to do the","provides in addition a machinereadable","in addition a machinereadable copy","addition a machinereadable copy of","a machinereadable copy of the","machinereadable copy of the source","terms of this licence the","of this licence the licensee","this licence the licensee becoming","licence each time you as","each time you as a","time you as a licensee","you as a licensee receive","as a licensee receive the","a licensee receive the work","licensee receive the work the","receive the work the original","the work the original licensor","work the original licensor and","applicable law regarding the identification","law regarding the identification and","regarding the identification and address","the identification and address of","identification and address of the","and address of the licensor","address of the licensor the","of the licensor the licence","the european commission may put","european commission may put into","commission may put into force","may put into force translations","put into force translations and","into force translations and or","force translations and or binding","translations and or binding new","and or binding new versions","or binding new versions of","binding new versions of this","and reasonable new versions of","reasonable new versions of the","a unique version number the","unique version number the new","version number the new version","number the new version of","the new version of the","version of the licence becomes","of the licence becomes binding","the licence becomes binding for","licence becomes binding for you","becomes binding for you as","binding for you as soon","for you as soon as","you as soon as you","as soon as you become","soon as you become aware","as you become aware of","you become aware of its","become aware of its publication","aware of its publication 14","of its publication 14 jurisdiction","its publication 14 jurisdiction any","publication 14 jurisdiction any litigation","article 5 eupl are general","5 eupl are general public","eupl are general public license","are general public license gpl","license gpl v 2 open"]},{"licenseTexts":["European Union Public Licence V. 1.1 EUPL (c) the European Community 2007\n\nThis European Union Public Licence (the \"EUPL\") applies to the Work or Software (as defined below) which is provided under the terms of this Licence. Any use of the Work, other than as authorised under this Licence is prohibited (to the extent such use is covered by a right of the copyright holder of the Work).\n\nThe Original Work is provided under the terms of this Licence when the Licensor (as defined below) has placed the following notice immediately following the copyright notice for the Original Work:\n\n   \n\n   Licensed under the EUPL V.1.1\n\n   \n\n   or has expressed by any other mean his willingness to license under the EUPL.\n\n   1. Definitions\n\n   In this Licence, the following terms have the following meaning:\n\n      - The Licence: this Licence.\n\n      - The Original Work or the Software: the software distributed and/or communicated by the Licensor under this Licence, available as Source Code and also as Executable Code as the case may be.\n\n      - Derivative Works: the works or software that could be created by the Licensee, based upon the Original Work or modifications thereof. This Licence does not define the extent of modification or dependence on the Original Work required in order to classify a work as a Derivative Work; this extent is determined by copyright law applicable in the country mentioned in Article 15.\n\n      - The Work: the Original Work and/or its Derivative Works.\n\n      - The Source Code: the human-readable form of the Work which is the most convenient for people to study and modify.\n\n      - The Executable Code: any code which has generally been compiled and which is meant to be interpreted by a computer as a program.\n\n      - The Licensor: the natural or legal person that distributes and/or communicates the Work under the Licence.\n\n      - Contributor(s): any natural or legal person who modifies the Work under the Licence, or otherwise contributes to the creation of a Derivative Work.\n\n      - The Licensee or \"You\": any natural or legal person who makes any usage of the Software under the terms of the Licence.\n\n      - Distribution and/or Communication: any act of selling, giving, lending, renting, distributing, communicating, transmitting, or otherwise making available, on-line or off-line, copies of the Work or providing access to its essential functionalities at the disposal of any other natural or legal person.\n\n   2. Scope of the rights granted by the Licence\n\n   The Licensor hereby grants You a world-wide, royalty-free, non-exclusive, sublicensable licence to do the following, for the duration of copyright vested in the Original Work:\n\n      - use the Work in any circumstance and for all usage,\n\n      - reproduce the Work,\n\n      - modify the Original Work, and make Derivative Works based upon the Work,\n\n      - communicate to the public, including the right to make available or display the Work or copies thereof to the public and perform publicly, as the case may be, the Work,\n\n      - distribute the Work or copies thereof,\n\n      - lend and rent the Work or copies thereof,\n\n      - sub-license rights in the Work or copies thereof.\n\n   Those rights can be exercised on any media, supports and formats, whether now known or later invented, as far as the applicable law permits so.\n\n   In the countries where moral rights apply, the Licensor waives his right to exercise his moral right to the extent allowed by law in order to make effective the licence of the economic rights here above listed.\n\n   The Licensor grants to the Licensee royalty-free, non exclusive usage rights to any patents held by the Licensor, to the extent necessary to make use of the rights granted on the Work under this Licence.\n\n   3. Communication of the Source Code\n\n   The Licensor may provide the Work either in its Source Code form, or as Executable Code. If the Work is provided as Executable Code, the Licensor provides in addition a machine-readable copy of the Source Code of the Work along with each copy of the Work that the Licensor distributes or indicates, in a notice following the copyright notice attached to the Work, a repository where the Source Code is easily and freely accessible for as long as the Licensor continues to distribute and/or communicate the Work.\n\n   4. Limitations on copyright\n\n   Nothing in this Licence is intended to deprive the Licensee of the benefits from any exception or limitation to the exclusive rights of the rights owners in the Original Work or Software, of the exhaustion of those rights or of other applicable limitations thereto.\n\n   5. Obligations of the Licensee\n\n   The grant of the rights mentioned above is subject to some restrictions and obligations imposed on the Licensee. Those obligations are the following:\n\n   Attribution right: the Licensee shall keep intact all copyright, patent or trademarks notices and all notices that refer to the Licence and to the disclaimer of warranties. The Licensee must include a copy of such notices and a copy of the Licence with every copy of the Work he/she distributes and/or communicates. The Licensee must cause any Derivative Work to carry prominent notices stating that the Work has been modified and the date of modification.\n\n   Copyleft clause: If the Licensee distributes and/or communicates copies of the Original Works or Derivative Works based upon the Original Work, this Distribution and/or Communication will be done under the terms of this Licence or of a later version of this Licence unless the Original Work is expressly distributed only under this version of the Licence. The Licensee (becoming Licensor) cannot offer or impose any additional terms or conditions on the Work or Derivative Work that alter or restrict the terms of the Licence.\n\n   Compatibility clause: If the Licensee Distributes and/or Communicates Derivative Works or copies thereof based upon both the Original Work and another work licensed under a Compatible Licence, this Distribution and/or Communication can be done under the terms of this Compatible Licence. For the sake of this clause, \"Compatible Licence,\" refers to the licences listed in the appendix attached to this Licence. Should the Licensee's obligations under the Compatible Licence conflict with his/her obligations under this Licence, the obligations of the Compatible Licence shall prevail.\n\n   Provision of Source Code: When distributing and/or communicating copies of the Work, the Licensee will provide a machine-readable copy of the Source Code or indicate a repository where this Source will be easily and freely available for as long as the Licensee continues to distribute and/or communicate the Work.\n\n   Legal Protection: This Licence does not grant permission to use the trade names, trademarks, service marks, or names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the copyright notice.\n\n   6. Chain of Authorship\n\n   The original Licensor warrants that the copyright in the Original Work granted hereunder is owned by him/her or licensed to him/her and that he/she has the power and authority to grant the Licence.\n\n   Each Contributor warrants that the copyright in the modifications he/she brings to the Work are owned by him/her or licensed to him/her and that he/she has the power and authority to grant the Licence.\n\n   Each time You accept the Licence, the original Licensor and subsequent Contributors grant You a licence to their contributions to the Work, under the terms of this Licence.\n\n   7. Disclaimer of Warranty\n\n   The Work is a work in progress, which is continuously improved by numerous contributors. It is not a finished work and may therefore contain defects or \"bugs\" inherent to this type of software development.\n\n   For the above reason, the Work is provided under the Licence on an \"as is\" basis and without warranties of any kind concerning the Work, including without limitation merchantability, fitness for a particular purpose, absence of defects or errors, accuracy, non-infringement of intellectual property rights other than copyright as stated in Article 6 of this Licence.\n\n   This disclaimer of warranty is an essential part of the Licence and a condition for the grant of any rights to the Work.\n\n   8. Disclaimer of Liability\n\n   Except in the cases of wilful misconduct or damages directly caused to natural persons, the Licensor will in no event be liable for any direct or indirect, material or moral, damages of any kind, arising out of the Licence or of the use of the Work, including without limitation, damages for loss of goodwill, work stoppage, computer failure or malfunction, loss of data or any commercial damage, even if the Licensor has been advised of the possibility of such damage. However, the Licensor will be liable under statutory product liability laws as far such laws apply to the Work.\n\n   9. Additional agreements\n\n   While distributing the Original Work or Derivative Works, You may choose to conclude an additional agreement to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or services consistent with this Licence. However, in accepting such obligations, You may act only on your own behalf and on your sole responsibility, not on behalf of the original Licensor or any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against such Contributor by the fact You have accepted any such warranty or additional liability.\n\n   10. Acceptance of the Licence\n\n   The provisions of this Licence can be accepted by clicking on an icon \"I agree\" placed under the bottom of a window displaying the text of this Licence or by affirming consent in any other similar way, in accordance with the rules of applicable law. Clicking on that icon indicates your clear and irrevocable acceptance of this Licence and all of its terms and conditions.\n\n   Similarly, you irrevocably accept this Licence and all of its terms and conditions by exercising any rights granted to You by Article 2 of this Licence, such as the use of the Work, the creation by You of a Derivative Work or the Distribution and/or Communication by You of the Work or copies thereof.\n\n   11. Information to the public\n\n   In case of any Distribution and/or Communication of the Work by means of electronic communication by You (for example, by offering to download the Work from a remote location) the distribution channel or media (for example, a website) must at least provide to the public the information requested by the applicable law regarding the Licensor, the Licence and the way it may be accessible, concluded, stored and reproduced by the Licensee.\n\n   12. Termination of the Licence\n\n   The Licence and the rights granted hereunder will terminate automatically upon any breach by the Licensee of the terms of the Licence. Such a termination will not terminate the licences of any person who has received the Work from the Licensee under the Licence, provided such persons remain in full compliance with the Licence.\n\n   13. Miscellaneous\n\n   Without prejudice of Article 9 above, the Licence represents the complete agreement between the Parties as to the Work licensed hereunder.\n\n   If any provision of the Licence is invalid or unenforceable under applicable law, this will not affect the validity or enforceability of the Licence as a whole. Such provision will be construed and/or reformed so as necessary to make it valid and enforceable.\n\n   The European Commission may publish other linguistic versions and/or new versions of this Licence, so far this is required and reasonable, without reducing the scope of the rights granted by the Licence. New versions of the Licence will be published with a unique version number.\n\n   All linguistic versions of this Licence, approved by the European Commission, have identical value. Parties can take advantage of the linguistic version of their choice.\n\n   14. Jurisdiction\n\n   Any litigation resulting from the interpretation of this License, arising between the European Commission, as a Licensor, and any Licensee, will be subject to the jurisdiction of the Court of Justice of the European Communities, as laid down in article 238 of the Treaty establishing the European Community.\n\n   Any litigation arising between Parties, other than the European Commission, and resulting from the interpretation of this License, will be subject to the exclusive jurisdiction of the competent court where the Licensor resides or conducts its primary business.\n\n   15. Applicable Law\n\n   This Licence shall be governed by the law of the European Union country where the Licensor resides or has his registered office.\n\n   This licence shall be governed by the Belgian law if:\n\n      - a litigation arises between the European Commission, as a Licensor, and any Licensee;\n\n      - the Licensor, other than the European Commission, has no residence or registered office inside a European Union country.\n\nAppendix\n\n\"Compatible Licences\" according to article 5 EUPL are:\n\n   - GNU General Public License (GNU GPL) v. 2\n\n   - Open Software License (OSL) v. 2.1, v. 3.0\n\n   - Common Public License v. 1.0\n\n   - Eclipse Public License v. 1.0\n\n   - Cecill v. 2.0"],"licenseIds":["EUPL-1.1"],"keywords":["1 eupl c","1 or has","linguistic versions and","versions and or","public license gnu","license gnu gpl","gnu gpl v","licence v 1 1","v 1 1 eupl","1 1 eupl c","1 eupl c the","v 1 1 or","1 1 or has","1 or has expressed","other linguistic versions and","linguistic versions and or","versions and or new","choice 14 jurisdiction any","general public license gnu","public license gnu gpl","license gnu gpl v","gnu gpl v 2","public licence v 1 1","licence v 1 1 eupl","v 1 1 eupl c","1 1 eupl c the","1 eupl c the european","the eupl v 1 1","eupl v 1 1 or","v 1 1 or has","1 1 or has expressed","1 or has expressed by","version of the licence the","the licence the licensee becoming","publish other linguistic versions and","other linguistic versions and or","linguistic versions and or new","versions and or new versions","their choice 14 jurisdiction any","choice 14 jurisdiction any litigation","gnu general public license gnu","general public license gnu gpl","public license gnu gpl v","license gnu gpl v 2","gnu gpl v 2 open"]},{"licenseTexts":["European Union Public Licence v. 1.2\n\nEUPL © the European Union 2007, 2016\n\nThis European Union Public Licence (the 'EUPL') applies to the Work (as defined below) which is provided under the terms of this Licence. Any use of the Work, other than as authorised under this Licence is prohibited (to the extent such use is covered by a right of the copyright holder of the Work).\n\nThe Work is provided under the terms of this Licence when the Licensor (as defined below) has placed the following notice immediately following the copyright notice for the Work:\n\n   \n\n   Licensed under the EUPL\n\n   \n\n   or has expressed by any other means his willingness to license under the EUPL.\n\n   1. Definitions\n\n   In this Licence, the following terms have the following meaning:\n\n      — 'The Licence': this Licence.\n\n      — 'The Original Work': the work or software distributed or communicated by the Licensor under this Licence, available as Source Code and also as Executable Code as the case may be.\n\n      — 'Derivative Works': the works or software that could be created by the Licensee, based upon the Original Work or modifications thereof. This Licence does not define the extent of modification or dependence on the Original Work required in order to classify a work as a Derivative Work; this extent is determined by copyright law applicable in the country mentioned in Article 15.\n\n      — 'The Work': the Original Work or its Derivative Works.\n\n      — 'The Source Code': the human-readable form of the Work which is the most convenient for people to study and modify.\n\n      — 'The Executable Code': any code which has generally been compiled and which is meant to be interpreted by a computer as a program.\n\n      — 'The Licensor': the natural or legal person that distributes or communicates the Work under the Licence.\n\n      — 'Contributor(s)': any natural or legal person who modifies the Work under the Licence, or otherwise contributes to the creation of a Derivative Work.\n\n      — 'The Licensee' or 'You': any natural or legal person who makes any usage of the Work under the terms of the Licence.\n\n      — 'Distribution' or 'Communication': any act of selling, giving, lending, renting, distributing, communicating, transmitting, or otherwise making available, online or offline, copies of the Work or providing access to its essential functionalities at the disposal of any other natural or legal person.\n\n   2. Scope of the rights granted by the Licence\n\n   The Licensor hereby grants You a worldwide, royalty-free, non-exclusive, sublicensable licence to do the following, for the duration of copyright vested in the Original Work:\n\n      — use the Work in any circumstance and for all usage,\n\n      — reproduce the Work,\n\n      — modify the Work, and make Derivative Works based upon the Work,\n\n      — communicate to the public, including the right to make available or display the Work or copies thereof to the public and perform publicly, as the case may be, the Work,\n\n      — distribute the Work or copies thereof,\n\n      — lend and rent the Work or copies thereof,\n\n      — sublicense rights in the Work or copies thereof.\n\n   Those rights can be exercised on any media, supports and formats, whether now known or later invented, as far as the applicable law permits so.\n\n   In the countries where moral rights apply, the Licensor waives his right to exercise his moral right to the extent allowed by law in order to make effective the licence of the economic rights here above listed.\n\n   The Licensor grants to the Licensee royalty-free, non-exclusive usage rights to any patents held by the Licensor, to the extent necessary to make use of the rights granted on the Work under this Licence.\n\n   3. Communication of the Source Code\n\n   The Licensor may provide the Work either in its Source Code form, or as Executable Code. If the Work is provided as Executable Code, the Licensor provides in addition a machine-readable copy of the Source Code of the Work along with each copy of the Work that the Licensor distributes or indicates, in a notice following the copyright notice attached to the Work, a repository where the Source Code is easily and freely accessible for as long as the Licensor continues to distribute or communicate the Work.\n\n   4. Limitations on copyright\n\n   Nothing in this Licence is intended to deprive the Licensee of the benefits from any exception or limitation to the exclusive rights of the rights owners in the Work, of the exhaustion of those rights or of other applicable limitations thereto.\n\n   5. Obligations of the Licensee\n\n   The grant of the rights mentioned above is subject to some restrictions and obligations imposed on the Licensee. Those obligations are the following:\n\n   Attribution right: The Licensee shall keep intact all copyright, patent or trademarks notices and all notices that refer to the Licence and to the disclaimer of warranties. The Licensee must include a copy of such notices and a copy of the Licence with every copy of the Work he/she distributes or communicates. The Licensee must cause any Derivative Work to carry prominent notices stating that the Work has been modified and the date of modification.\n\n   Copyleft clause: If the Licensee distributes or communicates copies of the Original Works or Derivative Works, this Distribution or Communication will be done under the terms of this Licence or of a later version of this Licence unless the Original Work is expressly distributed only under this version of the Licence — for example by communicating 'EUPL v. 1.2 only'. The Licensee (becoming Licensor) cannot offer or impose any additional terms or conditions on the Work or Derivative Work that alter or restrict the terms of the Licence.\n\n   Compatibility clause: If the Licensee Distributes or Communicates Derivative Works or copies thereof based upon both the Work and another work licensed under a Compatible Licence, this Distribution or Communication can be done under the terms of this Compatible Licence. For the sake of this clause, 'Compatible Licence' refers to the licences listed in the appendix attached to this Licence. Should the Licensee's obligations under the Compatible Licence conflict with his/her obligations under this Licence, the obligations of the Compatible Licence shall prevail.\n\n   Provision of Source Code: When distributing or communicating copies of the Work, the Licensee will provide a machine-readable copy of the Source Code or indicate a repository where this Source will be easily and freely available for as long as the Licensee continues to distribute or communicate the Work.\n\n   Legal Protection: This Licence does not grant permission to use the trade names, trademarks, service marks, or names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the copyright notice.\n\n   6. Chain of Authorship\n\n   The original Licensor warrants that the copyright in the Original Work granted hereunder is owned by him/her or licensed to him/her and that he/she has the power and authority to grant the Licence.\n\n   Each Contributor warrants that the copyright in the modifications he/she brings to the Work are owned by him/her or licensed to him/her and that he/she has the power and authority to grant the Licence.\n\n   Each time You accept the Licence, the original Licensor and subsequent Contributors grant You a licence to their contributions to the Work, under the terms of this Licence.\n\n   7. Disclaimer of Warranty\n\n   The Work is a work in progress, which is continuously improved by numerous Contributors. It is not a finished work and may therefore contain defects or 'bugs' inherent to this type of development.\n\n   For the above reason, the Work is provided under the Licence on an 'as is' basis and without warranties of any kind concerning the Work, including without limitation merchantability, fitness for a particular purpose, absence of defects or errors, accuracy, non-infringement of intellectual property rights other than copyright as stated in Article 6 of this Licence.\n\n   This disclaimer of warranty is an essential part of the Licence and a condition for the grant of any rights to the Work.\n\n   8. Disclaimer of Liability\n\n   Except in the cases of wilful misconduct or damages directly caused to natural persons, the Licensor will in no event be liable for any direct or indirect, material or moral, damages of any kind, arising out of the Licence or of the use of the Work, including without limitation, damages for loss of goodwill, work stoppage, computer failure or malfunction, loss of data or any commercial damage, even if the Licensor has been advised of the possibility of such damage. However, the Licensor will be liable under statutory product liability laws as far such laws apply to the Work.\n\n   9. Additional agreements\n\n   While distributing the Work, You may choose to conclude an additional agreement, defining obligations or services consistent with this Licence. However, if accepting obligations, You may act only on your own behalf and on your sole responsibility, not on behalf of the original Licensor or any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against such Contributor by the fact You have accepted any warranty or additional liability.\n\n   10. Acceptance of the Licence\n\n   The provisions of this Licence can be accepted by clicking on an icon 'I agree' placed under the bottom of a window displaying the text of this Licence or by affirming consent in any other similar way, in accordance with the rules of applicable law. Clicking on that icon indicates your clear and irrevocable acceptance of this Licence and all of its terms and conditions.\n\n   Similarly, you irrevocably accept this Licence and all of its terms and conditions by exercising any rights granted to You by Article 2 of this Licence, such as the use of the Work, the creation by You of a Derivative Work or the Distribution or Communication by You of the Work or copies thereof.\n\n   11. Information to the public\n\n   In case of any Distribution or Communication of the Work by means of electronic communication by You (for example, by offering to download the Work from a remote location) the distribution channel or media (for example, a website) must at least provide to the public the information requested by the applicable law regarding the Licensor, the Licence and the way it may be accessible, concluded, stored and reproduced by the Licensee.\n\n   12. Termination of the Licence\n\n   The Licence and the rights granted hereunder will terminate automatically upon any breach by the Licensee of the terms of the Licence.\n\n   Such a termination will not terminate the licences of any person who has received the Work from the Licensee under the Licence, provided such persons remain in full compliance with the Licence.\n\n   13. Miscellaneous\n\n   Without prejudice of Article 9 above, the Licence represents the complete agreement between the Parties as to the Work.\n\n   If any provision of the Licence is invalid or unenforceable under applicable law, this will not affect the validity or enforceability of the Licence as a whole. Such provision will be construed or reformed so as necessary to make it valid and enforceable.\n\n   The European Commission may publish other linguistic versions or new versions of this Licence or updated versions of the Appendix, so far this is required and reasonable, without reducing the scope of the rights granted by the Licence. New versions of the Licence will be published with a unique version number.\n\n   All linguistic versions of this Licence, approved by the European Commission, have identical value. Parties can take advantage of the linguistic version of their choice.\n\n   14. Jurisdiction\n\n   Without prejudice to specific agreement between parties,\n\n      — any litigation resulting from the interpretation of this License, arising between the European Union institutions, bodies, offices or agencies, as a Licensor, and any Licensee, will be subject to the jurisdiction of the Court of Justice of the European Union, as laid down in article 272 of the Treaty on the Functioning of the European Union,\n\n      — any litigation arising between other parties and resulting from the interpretation of this License, will be subject to the exclusive jurisdiction of the competent court where the Licensor resides or conducts its primary business.\n\n   15. Applicable Law\n\n   Without prejudice to specific agreement between parties,\n\n      — this Licence shall be governed by the law of the European Union Member State where the Licensor has his seat, resides or has his registered office,\n\n      — this licence shall be governed by Belgian law if the Licensor has no seat, residence or registered office inside a European Union Member State.\n\nAppendix\n\n'Compatible Licences' according to Article 5 EUPL are:\n\n   — GNU General Public License (GPL) v. 2, v. 3\n\n   — GNU Affero General Public License (AGPL) v. 3\n\n   — Open Software License (OSL) v. 2.1, v. 3.0\n\n   — Eclipse Public License (EPL) v. 1.0\n\n   — CeCILL v. 2.0, v. 2.1\n\n   — Mozilla Public Licence (MPL) v. 2\n\n   — GNU Lesser General Public Licence (LGPL) v. 2.1, v. 3\n\n   — Creative Commons Attribution-ShareAlike v. 3.0 Unported (CC BY-SA 3.0) for works other than software\n\n   — European Union Public Licence (EUPL) v. 1.1, v. 1.2\n\n   — Québec Free and Open-Source Licence — Reciprocity (LiLiQ-R) or Strong Reciprocity (LiLiQ-R+).\n\nThe European Commission may update this Appendix to later versions of the above licences without producing a new version of the EUPL, as long as they provide the rights granted in Article 2 of this Licence and protect the covered Source Code from exclusive appropriation.\n\nAll other changes or additions to this Appendix require the production of a new EUPL version."],"licenseIds":["EUPL-1.2"],"keywords":["1 2 eupl","2 eupl the","eupl the european","european union 2007","union 2007 2016","2007 2016 this","2016 this european","the eupl or","eupl or has","any other means","other means his","means his willingness","original work the","or software distributed","software distributed or","work or its","that distributes or","licence distribution or","making available online","online or offline","or offline copies","offline copies of","copies thereof sublicense","thereof sublicense rights","sublicense rights in","she distributes or","works this distribution","the licence for","licence for example","example by communicating","by communicating eupl","communicating eupl v","1 2 only","2 only the","only the licensee","both the work","when distributing or","distributing or communicating","type of development","of development for","additional agreement defining","agreement defining obligations","defining obligations or","obligations or services","licence however if","however if accepting","if accepting obligations","accepting obligations you","accepted any warranty","any distribution or","work if any","construed or reformed","linguistic versions or","versions or new","licence or updated","or updated versions","of the appendix","the appendix so","appendix so far","14 jurisdiction without","jurisdiction without prejudice","between parties any","parties any litigation","european union institutions","union institutions bodies","institutions bodies offices","bodies offices or","offices or agencies","or agencies as","agencies as a","european union as","union as laid","in article 272","article 272 of","272 of the","the treaty on","treaty on the","on the functioning","the functioning of","european union any","union any litigation","arising between other","between other parties","other parties and","parties and resulting","applicable law without","law without prejudice","between parties this","parties this licence","member state where","state where the","licensor has his","has his seat","his seat resides","seat resides or","governed by belgian","by belgian law","has no seat","no seat residence","seat residence or","member state appendix","state appendix compatible","v 2 v","2 v 3","v 3 gnu","3 gnu affero","public license agpl","license agpl v","agpl v 3","v 3 open","3 open software","3 0 eclipse","public license epl","license epl v","epl v 1","2 0 v","0 v 2","2 1 mozilla","1 mozilla public","mozilla public licence","public licence mpl","licence mpl v","mpl v 2","v 2 gnu","2 gnu lesser","public licence lgpl","licence lgpl v","lgpl v 2","v 3 creative","3 creative commons","attribution sharealike v","sharealike v 3","0 unported cc","unported cc by","by sa 3","sa 3 0","3 0 for","0 for works","for works other","other than software","than software european","software european union","public licence eupl","licence eupl v","1 1 v","1 v 1","1 2 qu","2 qu bec","qu bec free","bec free and","open source licence","source licence reciprocity","licence reciprocity liliq","liliq r or","r or strong","or strong reciprocity","strong reciprocity liliq","liliq r the","r the european","commission may update","may update this","update this appendix","this appendix to","appendix to later","to later versions","the above licences","above licences without","licences without producing","without producing a","producing a new","of the eupl","the eupl as","eupl as long","as they provide","they provide the","provide the rights","licence and protect","and protect the","protect the covered","covered source code","code from exclusive","from exclusive appropriation","exclusive appropriation all","appropriation all other","all other changes","other changes or","to this appendix","this appendix require","appendix require the","require the production","of a new","a new eupl","new eupl version","licence v 1 2","v 1 2 eupl","1 2 eupl the","2 eupl the european","eupl the european union","the european union 2007","european union 2007 2016"]},{"licenseTexts":["Entessa Public License Version. 1.0 Copyright (c) 2003 Entessa, LLC. All rights reserved.\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n   2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   3. The end-user documentation included with the redistribution, if any, must include the following acknowledgment:\n\n   \"This product includes open source software developed by openSEAL (http://www.openseal.org/).\"\n\n   Alternately, this acknowledgment may appear in the software itself, if and wherever such third-party acknowledgments normally appear.\n\n   4. The names \"openSEAL\" and \"Entessa\" must not be used to endorse or promote products derived from this software without prior written permission. For written permission, please contact epl@entessa.com.\n\n   5. Products derived from this software may not be called \"openSEAL\", nor may \"openSEAL\" appear in their name, without prior written permission of Entessa.\n\nTHIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL ENTESSA, LLC, OPENSEAL OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\nThis software consists of voluntary contributions made by many individuals on behalf of openSEAL and was originally based on software contributed by Entessa, LLC, http://www.entessa.com. For more information on the openSEAL, please see \u003chttp://www.openseal.org/\u003e."],"licenseIds":["Entessa"],"keywords":["entessa public license","c 2003 entessa","2003 entessa llc","entessa llc all","product includes open","includes open source","source software developed","developed by openseal","by openseal http","openseal http www","openseal org alternately","the names openseal","names openseal and","openseal and entessa","and entessa must","entessa must not","please contact epl","contact epl entessa","epl entessa com","entessa com 5","com 5 products","be called openseal","called openseal nor","openseal nor may","nor may openseal","may openseal appear","openseal appear in","permission of entessa","of entessa this","entessa this software","event shall entessa","shall entessa llc","entessa llc openseal","llc openseal or","openseal or its","behalf of openseal","of openseal and","openseal and was","based on software","on software contributed","software contributed by","contributed by entessa","by entessa llc","entessa llc http","llc http www","http www entessa","www entessa com","entessa com for","com for more","on the openseal","the openseal please","openseal please see","entessa public license version","0 copyright c 2003","copyright c 2003 entessa","c 2003 entessa llc","2003 entessa llc all","entessa llc all rights","this product includes open","product includes open source","includes open source software","open source software developed","source software developed by","software developed by openseal","developed by openseal http","by openseal http www","openseal http www openseal","www openseal org alternately","openseal org alternately this","appear 4 the names","4 the names openseal","the names openseal and","names openseal and entessa","openseal and entessa must","and entessa must not","entessa must not be","permission please contact epl","please contact epl entessa","contact epl entessa com","epl entessa com 5","entessa com 5 products","com 5 products derived","not be called openseal","be called openseal nor","called openseal nor may","openseal nor may openseal","nor may openseal appear","may openseal appear in","openseal appear in their","written permission of entessa","permission of entessa this","of entessa this software","entessa this software is","no event shall entessa","event shall entessa llc","shall entessa llc openseal","entessa llc openseal or","llc openseal or its","openseal or its contributors","on behalf of openseal","behalf of openseal and","of openseal and was","openseal and was originally","originally based on software","based on software contributed","on software contributed by","software contributed by entessa","contributed by entessa llc","by entessa llc http","entessa llc http www","llc http www entessa","http www entessa com","www entessa com for","entessa com for more","com for more information","information on the openseal","on the openseal please","the openseal please see","openseal please see http","see http www openseal","entessa public license version 1","1 0 copyright c 2003","0 copyright c 2003 entessa","copyright c 2003 entessa llc","c 2003 entessa llc all","2003 entessa llc all rights","entessa llc all rights reserved","acknowledgment this product includes open","this product includes open source","product includes open source software","includes open source software developed","open source software developed by","source software developed by openseal","software developed by openseal http","developed by openseal http www","by openseal http www openseal","openseal http www openseal org","http www openseal org alternately","www openseal org alternately this","openseal org alternately this acknowledgment","normally appear 4 the names","appear 4 the names openseal","4 the names openseal and","the names openseal and entessa","names openseal and entessa must","openseal and entessa must not","and entessa must not be","entessa must not be used","written permission please contact epl","permission please contact epl entessa","please contact epl entessa com","contact epl entessa com 5","epl entessa com 5 products","entessa com 5 products derived","com 5 products derived from","may not be called openseal","not be called openseal nor","be called openseal nor may","called openseal nor may openseal","openseal nor may openseal appear","nor may openseal appear in","may openseal appear in their","openseal appear in their name","prior written permission of entessa","written permission of entessa this","permission of entessa this software","of entessa this software is","entessa this software is provided","in no event shall entessa","no event shall entessa llc","event shall entessa llc openseal","shall entessa llc openseal or","entessa llc openseal or its","llc openseal or its contributors","openseal or its contributors be","individuals on behalf of openseal","on behalf of openseal and","behalf of openseal and was","of openseal and was originally","openseal and was originally based","was originally based on software","originally based on software contributed","based on software contributed by","on software contributed by entessa","software contributed by entessa llc","contributed by entessa llc http","by entessa llc http www","entessa llc http www entessa","llc http www entessa com","http www entessa com for","www entessa com for more","entessa com for more information","com for more information on","more information on the openseal","information on the openseal please","on the openseal please see","the openseal please see http","openseal please see http www","please see http www openseal","see http www openseal org"]},{"licenseTexts":["ERLANG PUBLIC LICENSE Version 1.1\n\n   1. Definitions.\n\n      1.1. ``Contributor'' means each entity that creates or contributes to the creation of Modifications.\n\n      1.2. ``Contributor Version'' means the combination of the Original Code, prior Modifications used by a Contributor, and the Modifications made by that particular Contributor.\n\n      1.3. ``Covered Code'' means the Original Code or Modifications or the combination of the Original Code and Modifications, in each case including portions thereof.\n\n      1.4. ``Electronic Distribution Mechanism'' means a mechanism generally accepted in the software development community for the electronic transfer of data.\n\n      1.5. ``Executable'' means Covered Code in any form other than Source Code.\n\n      1.6. ``Initial Developer'' means the individual or entity identified as the Initial Developer in the Source Code notice required by Exhibit A.\n\n      1.7. ``Larger Work'' means a work which combines Covered Code or portions thereof with code not governed by the terms of this License.\n\n      1.8. ``License'' means this document.\n\n      1.9. ``Modifications'' means any addition to or deletion from the substance or structure of either the Original Code or any previous Modifications. When Covered Code is released as a series of files, a Modification is:\n\n         A. Any addition to or deletion from the contents of a file containing Original Code or previous Modifications.\n\n         B. Any new file that contains any part of the Original Code or previous Modifications.\n\n      1.10. ``Original Code'' means Source Code of computer software code which is described in the Source Code notice required by Exhibit A as Original Code, and which, at the time of its release under this License is not already Covered Code governed by this License.\n\n      1.11. ``Source Code'' means the preferred form of the Covered Code for making modifications to it, including all modules it contains, plus any associated interface definition files, scripts used to control compilation and installation of an Executable, or a list of source code differential comparisons against either the Original Code or another well known, available Covered Code of the Contributor's choice. The Source Code can be in a compressed or archival form, provided the appropriate decompression or de-archiving software is widely available for no charge.\n\n      1.12. ``You'' means an individual or a legal entity exercising rights under, and complying with all of the terms of, this License. For legal entities, ``You'' includes any entity which controls, is controlled by, or is under common control with You. For purposes of this definition, ``control'' means (a) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (b) ownership of fifty percent (50%) or more of the outstanding shares or beneficial ownership of such entity.\n\n   2. Source Code License.\n\n      2.1. The Initial Developer Grant. The Initial Developer hereby grants You a world-wide, royalty-free, non-exclusive license, subject to third party intellectual property claims:\n\n         (a) to use, reproduce, modify, display, perform, sublicense and distribute the Original Code (or portions thereof) with or without Modifications, or as part of a Larger Work; and\n\n         (b) under patents now or hereafter owned or controlled by Initial Developer, to make, have made, use and sell (``Utilize'') the Original Code (or portions thereof), but solely to the extent that any such patent is reasonably necessary to enable You to Utilize the Original Code (or portions thereof) and not to any greater extent that may be necessary to Utilize further Modifications or combinations.\n\n      2.2. Contributor Grant. Each Contributor hereby grants You a world-wide, royalty-free, non-exclusive license, subject to third party intellectual property claims:\n\n         (a) to use, reproduce, modify, display, perform, sublicense and distribute the Modifications created by such Contributor (or portions thereof) either on an unmodified basis, with other Modifications, as Covered Code or as part of a Larger Work; and\n\n         (b) under patents now or hereafter owned or controlled by Contributor, to Utilize the Contributor Version (or portions thereof), but solely to the extent that any such patent is reasonably necessary to enable You to Utilize the Contributor Version (or portions thereof), and not to any greater extent that may be necessary to Utilize further Modifications or combinations.\n\n   3. Distribution Obligations.\n\n      3.1. Application of License. The Modifications which You contribute are governed by the terms of this License, including without limitation Section 2.2. The Source Code version of Covered Code may be distributed only under the terms of this License, and You must include a copy of this License with every copy of the Source Code You distribute. You may not offer or impose any terms on any Source Code version that alters or restricts the applicable version of this License or the recipients' rights hereunder. However, You may include an additional document offering the additional rights described in Section 3.5.\n\n      3.2. Availability of Source Code. Any Modification which You contribute must be made available in Source Code form under the terms of this License either on the same media as an Executable version or via an accepted Electronic Distribution Mechanism to anyone to whom you made an Executable version available; and if made available via Electronic Distribution Mechanism, must remain available for at least twelve (12) months after the date it initially became available, or at least six (6) months after a subsequent version of that particular Modification has been made available to such recipients. You are responsible for ensuring that the Source Code version remains available even if the Electronic Distribution Mechanism is maintained by a third party.\n\n      3.3. Description of Modifications. You must cause all Covered Code to which you contribute to contain a file documenting the changes You made to create that Covered Code and the date of any change. You must include a prominent statement that the Modification is derived, directly or indirectly, from Original Code provided by the Initial Developer and including the name of the Initial Developer in (a) the Source Code, and (b) in any notice in an Executable version or related documentation in which You describe the origin or ownership of the Covered Code.\n\n      3.4. Intellectual Property Matters\n\n         (a) Third Party Claims. If You have knowledge that a party claims an intellectual property right in particular functionality or code (or its utilization under this License), you must include a text file with the source code distribution titled ``LEGAL'' which describes the claim and the party making the claim in sufficient detail that a recipient will know whom to contact. If you obtain such knowledge after You make Your Modification available as described in Section 3.2, You shall promptly modify the LEGAL file in all copies You make available thereafter and shall take other steps (such as notifying appropriate mailing lists or newsgroups) reasonably calculated to inform those who received the Covered Code that new knowledge has been obtained.\n\n         (b) Contributor APIs. If Your Modification is an application programming interface and You own or control patents which are reasonably necessary to implement that API, you must also include this information in the LEGAL file.\n\n      3.5. Required Notices. You must duplicate the notice in Exhibit A in each file of the Source Code, and this License in any documentation for the Source Code, where You describe recipients' rights relating to Covered Code. If You created one or more Modification(s), You may add your name as a Contributor to the notice described in Exhibit A. If it is not possible to put such notice in a particular Source Code file due to its structure, then you must include such notice in a location (such as a relevant directory file) where a user would be likely to look for such a notice. You may choose to offer, and to charge a fee for, warranty, support, indemnity or liability obligations to one or more recipients of Covered Code. However, You may do so only on Your own behalf, and not on behalf of the Initial Developer or any Contributor. You must make it absolutely clear than any such warranty, support, indemnity or liability obligation is offered by You alone, and You hereby agree to indemnify the Initial Developer and every Contributor for any liability incurred by the Initial Developer or such Contributor as a result of warranty, support, indemnity or liability terms You offer.\n\n      3.6. Distribution of Executable Versions. You may distribute Covered Code in Executable form only if the requirements of Section 3.1-3.5 have been met for that Covered Code, and if You include a notice stating that the Source Code version of the Covered Code is available under the terms of this License, including a description of how and where You have fulfilled the obligations of Section 3.2. The notice must be conspicuously included in any notice in an Executable version, related documentation or collateral in which You describe recipients' rights relating to the Covered Code. You may distribute the Executable version of Covered Code under a license of Your choice, which may contain terms different from this License, provided that You are in compliance with the terms of this License and that the license for the Executable version does not attempt to limit or alter the recipient's rights in the Source Code version from the rights set forth in this License. If You distribute the Executable version under a different license You must make it absolutely clear that any terms which differ from this License are offered by You alone, not by the Initial Developer or any Contributor. You hereby agree to indemnify the Initial Developer and every Contributor for any liability incurred by the Initial Developer or such Contributor as a result of any such terms You offer.\n\n      3.7. Larger Works. You may create a Larger Work by combining Covered Code with other code not governed by the terms of this License and distribute the Larger Work as a single product. In such a case, You must make sure the requirements of this License are fulfilled for the Covered Code.\n\n   4. Inability to Comply Due to Statute or Regulation. If it is impossible for You to comply with any of the terms of this License with respect to some or all of the Covered Code due to statute or regulation then You must: (a) comply with the terms of this License to the maximum extent possible; and (b) describe the limitations and the code they affect. Such description must be included in the LEGAL file described in Section 3.4 and must be included with all distributions of the Source Code. Except to the extent prohibited by statute or regulation, such description must be sufficiently detailed for a recipient of ordinary skill to be able to understand it.\n\n   5. Application of this License.\n\n   This License applies to code to which the Initial Developer has attached the notice in Exhibit A, and to related Covered Code.\n\n   6. CONNECTION TO MOZILLA PUBLIC LICENSE\n\n   This Erlang License is a derivative work of the Mozilla Public License, Version 1.0. It contains terms which differ from the Mozilla Public License, Version 1.0.\n\n   7. DISCLAIMER OF WARRANTY.\n\n   COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN ``AS IS'' BASIS, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER.\n\n   8. TERMINATION.\n\n   This License and the rights granted hereunder will terminate automatically if You fail to comply with terms herein and fail to cure such breach within 30 days of becoming aware of the breach. All sublicenses to the Covered Code which are properly granted shall survive any termination of this License. Provisions which, by their nature, must remain in effect beyond the termination of this License shall survive.\n\n   9. DISCLAIMER OF LIABILITY\n\n   Any utilization of Covered Code shall not cause the Initial Developer or any Contributor to be liable for any damages (neither direct nor indirect).\n\n   10. MISCELLANEOUS\n\n   This License represents the complete agreement concerning the subject matter hereof. If any provision is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable. This License shall be construed by and in accordance with the substantive laws of Sweden. Any dispute, controversy or claim arising out of or relating to this License, or the breach, termination or invalidity thereof, shall be subject to the exclusive jurisdiction of Swedish courts, with the Stockholm City Court as the first instance.\n\nEXHIBIT A.\n\n``The contents of this file are subject to the Erlang Public License, Version 1.1, (the \"License\"); you may not use this file except in compliance with the License. You should have received a copy of the Erlang Public License along with this software. If not, it can be retrieved via the world wide web at http://www.erlang.org/.\n\nSoftware distributed under the License is distributed on an \"AS IS\" basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the specific language governing rights and limitations under the License.\n\nThe Initial Developer of the Original Code is Ericsson Utvecklings AB. Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings AB. All Rights Reserved.''"],"licenseIds":["ErlPL-1.1"],"keywords":["code 6 connection","6 connection to","connection to mozilla","to mozilla public","license this erlang","this erlang license","erlang license is","1 0 it","0 it contains","it contains terms","0 7 disclaimer","survive 9 disclaimer","of liability any","liability any utilization","any utilization of","utilization of covered","covered code shall","cause the initial","contributor to be","to be liable","any damages neither","damages neither direct","neither direct nor","direct nor indirect","nor indirect 10","indirect 10 miscellaneous","any provision is","provision is held","be construed by","construed by and","and in accordance","with the substantive","the substantive laws","substantive laws of","laws of sweden","of sweden any","sweden any dispute","or the breach","the breach termination","breach termination or","termination or invalidity","or invalidity thereof","invalidity thereof shall","jurisdiction of swedish","of swedish courts","swedish courts with","courts with the","with the stockholm","the stockholm city","stockholm city court","city court as","court as the","as the first","the first instance","first instance exhibit","instance exhibit a","to the erlang","license you should","of the erlang","software if not","if not it","not it can","can be retrieved","be retrieved via","retrieved via the","via the world","wide web at","web at http","http www erlang","www erlang org","erlang org software","org software distributed","code is ericsson","is ericsson utvecklings","utvecklings ab portions","ab portions created","created by ericsson","by ericsson are","ericsson are copyright","are copyright 1999","copyright 1999 ericsson","1999 ericsson utvecklings","utvecklings ab all","ab all rights","modifications which you contribute","modification which you contribute","covered code 6 connection","code 6 connection to","6 connection to mozilla","connection to mozilla public","to mozilla public license","mozilla public license this","public license this erlang","license this erlang license","this erlang license is","erlang license is a","license is a derivative","work of the mozilla","version 1 0 it","1 0 it contains","0 it contains terms","it contains terms which","version 1 0 7","1 0 7 disclaimer","0 7 disclaimer of","shall survive 9 disclaimer","survive 9 disclaimer of","9 disclaimer of liability","disclaimer of liability any","of liability any utilization","liability any utilization of","any utilization of covered","utilization of covered code","of covered code shall","covered code shall not","code shall not cause","not cause the initial","cause the initial developer","any contributor to be","contributor to be liable","to be liable for","for any damages neither","any damages neither direct","damages neither direct nor","neither direct nor indirect","direct nor indirect 10","nor indirect 10 miscellaneous","indirect 10 miscellaneous this","if any provision is","any provision is held","provision is held to","shall be construed by","be construed by and","construed by and in","by and in accordance","and in accordance with","accordance with the substantive","with the substantive laws","the substantive laws of","substantive laws of sweden","laws of sweden any","of sweden any dispute","sweden any dispute controversy","license or the breach","or the breach termination","the breach termination or","breach termination or invalidity","termination or invalidity thereof","or invalidity thereof shall","invalidity thereof shall be","thereof shall be subject","exclusive jurisdiction of swedish","jurisdiction of swedish courts","of swedish courts with","swedish courts with the","courts with the stockholm","with the stockholm city","the stockholm city court","stockholm city court as","city court as the","court as the first","as the first instance","the first instance exhibit","first instance exhibit a","instance exhibit a the","subject to the erlang","to the erlang public","the license you should","license you should have","copy of the erlang","of the erlang public","erlang public license along","along with this software","with this software if","this software if not","software if not it","if not it can","not it can be","it can be retrieved","can be retrieved via","be retrieved via the","retrieved via the world","via the world wide","the world wide web","world wide web at","wide web at http","web at http www","at http www erlang","http www erlang org","www erlang org software","erlang org software distributed","org software distributed under","original code is ericsson","code is ericsson utvecklings","is ericsson utvecklings ab","ericsson utvecklings ab portions","utvecklings ab portions created","ab portions created by","portions created by ericsson","created by ericsson are"]},{"licenseTexts":["Copyright (c) 1999-2002 Henrik Theiling \n\nLicence Version 2\n\n\n\nThis software is provided 'as-is', without warranty of any kind, express or implied. In no event will the authors or copyright holders be held liable for any damages arising from the use of this software.\n\nPermission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions:\n\n   1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated.\n\n   2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.\n\n   3. You must not use any of the names of the authors or copyright holders of the original software for advertising or publicity pertaining to distribution without specific, written prior permission.\n\n   4. If you change this software and redistribute parts or all of it in any form, you must make the source code of the altered version of this software available.\n\n   5. This notice may not be removed or altered from any source distribution.\n\nThis licence is governed by the Laws of Germany. Disputes shall be settled by Saarbruecken City Court."],"licenseIds":["Eurosym"],"keywords":["1999 2002 henrik","2002 henrik theiling","henrik theiling licence","theiling licence version","version 2 this","2 this software","holders be held","be appreciated 2","appreciated 2 altered","software 3 you","must not use","original software for","software for advertising","for advertising or","to distribution without","distribution without specific","prior permission 4","permission 4 if","software and redistribute","and redistribute parts","redistribute parts or","parts or all","all of it","the altered version","altered version of","this software available","software available 5","available 5 this","5 this notice","source distribution this","distribution this licence","laws of germany","of germany disputes","germany disputes shall","settled by saarbruecken","by saarbruecken city","saarbruecken city court","c 1999 2002 henrik","1999 2002 henrik theiling","2002 henrik theiling licence","henrik theiling licence version","theiling licence version 2","licence version 2 this","version 2 this software","2 this software is","will the authors or","copyright holders be held","holders be held liable","would be appreciated 2","be appreciated 2 altered","appreciated 2 altered source","original software 3 you","software 3 you must","you must not use","must not use any","of the names of","or copyright holders of","copyright holders of the","holders of the original","the original software for","original software for advertising","software for advertising or","for advertising or publicity","pertaining to distribution without","to distribution without specific","distribution without specific written","written prior permission 4","prior permission 4 if","permission 4 if you","4 if you change","change this software and","this software and redistribute","software and redistribute parts","and redistribute parts or","redistribute parts or all","parts or all of","or all of it","all of it in","of it in any","it in any form","form you must make","code of the altered","of the altered version","the altered version of","altered version of this","version of this software","of this software available","this software available 5","software available 5 this","available 5 this notice","5 this notice may","any source distribution this","source distribution this licence","distribution this licence is","the laws of germany","laws of germany disputes","of germany disputes shall","germany disputes shall be","be settled by saarbruecken","settled by saarbruecken city","by saarbruecken city court","copyright c 1999 2002 henrik","c 1999 2002 henrik theiling","1999 2002 henrik theiling licence","2002 henrik theiling licence version","henrik theiling licence version 2","theiling licence version 2 this","licence version 2 this software","version 2 this software is","2 this software is provided","implied in no event will","event will the authors or","will the authors or copyright","or copyright holders be held","copyright holders be held liable","holders be held liable for","documentation would be appreciated 2","would be appreciated 2 altered","be appreciated 2 altered source","appreciated 2 altered source versions","the original software 3 you","original software 3 you must","software 3 you must not","3 you must not use","you must not use any","must not use any of","use any of the names","any of the names of","of the names of the","names of the authors or","authors or copyright holders of","or copyright holders of the","copyright holders of the original","holders of the original software","of the original software for","the original software for advertising","original software for advertising or","software for advertising or publicity","for advertising or publicity pertaining","publicity pertaining to distribution without","pertaining to distribution without specific","to distribution without specific written","distribution without specific written prior","specific written prior permission 4","written prior permission 4 if","prior permission 4 if you","permission 4 if you change","4 if you change this","you change this software and","change this software and redistribute","this software and redistribute parts","software and redistribute parts or","and redistribute parts or all","redistribute parts or all of","parts or all of it","or all of it in","all of it in any","of it in any form","it in any form you","any form you must make","form you must make the","source code of the altered","code of the altered version","of the altered version of","the altered version of this","altered version of this software","version of this software available","of this software available 5","this software available 5 this","software available 5 this notice","available 5 this notice may","5 this notice may not","from any source distribution this","any source distribution this licence","source distribution this licence is","distribution this licence is governed","by the laws of germany","the laws of germany disputes","laws of germany disputes shall","of germany disputes shall be","germany disputes shall be settled","shall be settled by saarbruecken","be settled by saarbruecken city","settled by saarbruecken city court"]},{"licenseTexts":["Copying and distribution of this file, with or without modification, are permitted in any medium without royalty provided the copyright notice and this notice are preserved. This file is offered as-is, without any warranty."],"licenseIds":["FSFAP"],"keywords":["copying and distribution","this file with","are permitted in","permitted in any","medium without royalty","without royalty provided","royalty provided the","and this notice","this notice are","are preserved this","preserved this file","file is offered","is offered as","offered as is","copying and distribution of","and distribution of this","distribution of this file","of this file with","this file with or","modification are permitted in","are permitted in any","permitted in any medium","any medium without royalty","medium without royalty provided","without royalty provided the","royalty provided the copyright","notice and this notice","and this notice are","this notice are preserved","notice are preserved this","are preserved this file","preserved this file is","this file is offered","file is offered as","is offered as is","offered as is without","copying and distribution of this","and distribution of this file","distribution of this file with","of this file with or","this file with or without","without modification are permitted in","modification are permitted in any","are permitted in any medium","permitted in any medium without","in any medium without royalty","any medium without royalty provided","medium without royalty provided the","without royalty provided the copyright","royalty provided the copyright notice","copyright notice and this notice","notice and this notice are","and this notice are preserved","this notice are preserved this","notice are preserved this file","are preserved this file is","preserved this file is offered","this file is offered as","file is offered as is","is offered as is without","offered as is without any"]},{"licenseTexts":["Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.\n\nThis configure script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it."],"licenseIds":["FSFUL"],"keywords":["copyright c 1992","c 1992 1996","1992 1996 1998","1996 1998 2012","1998 2012 free","2012 free software","inc this configure","this configure script","configure script is","script is free","copyright c 1992 1996","c 1992 1996 1998","1992 1996 1998 2012","1996 1998 2012 free","1998 2012 free software","2012 free software foundation","foundation inc this configure","inc this configure script","this configure script is","configure script is free","script is free software","copyright c 1992 1996 1998","c 1992 1996 1998 2012","1992 1996 1998 2012 free","1996 1998 2012 free software","1998 2012 free software foundation","2012 free software foundation inc","software foundation inc this configure","foundation inc this configure script","inc this configure script is","this configure script is free","configure script is free software","script is free software the","copy distribute and modify it"]},{"licenseTexts":["Copyright 1996-2006 Free Software Foundation, Inc.\n\nThis file is free software; the Free Software Foundation gives unlimited permission to copy and/or distribute it, with or without modifications, as long as this notice is preserved."],"licenseIds":["FSFULLR"],"keywords":["copyright 1996 2006","1996 2006 free","2006 free software","inc this file","file is free","copy and or","distribute it with","without modifications as","modifications as long","as this notice","copyright 1996 2006 free","1996 2006 free software","2006 free software foundation","foundation inc this file","inc this file is","this file is free","file is free software","to copy and or","copy and or distribute","and or distribute it","or distribute it with","distribute it with or","or without modifications as","without modifications as long","modifications as long as","as long as this","long as this notice","as this notice is","this notice is preserved","copyright 1996 2006 free software","1996 2006 free software foundation","2006 free software foundation inc","software foundation inc this file","foundation inc this file is","inc this file is free","this file is free software","file is free software the","unlimited permission to copy and","permission to copy and or","to copy and or distribute","copy and or distribute it","and or distribute it with","or distribute it with or","distribute it with or without","it with or without modifications","with or without modifications as","or without modifications as long","without modifications as long as","modifications as long as this","as long as this notice","long as this notice is","as this notice is preserved"]},{"licenseTexts":["The FreeType Project LICENSE\n\n2006-Jan-27 Copyright 1996-2002, 2006 by David Turner, Robert Wilhelm, and Werner Lemberg\n\nIntroduction\n\nThe FreeType Project is distributed in several archive packages; some of them may contain, in addition to the FreeType font engine, various tools and contributions which rely on, or relate to, the FreeType Project.\n\nThis license applies to all files found in such packages, and which do not fall under their own explicit license. The license affects thus the FreeType font engine, the test programs, documentation and makefiles, at the very least.\n\nThis license was inspired by the BSD, Artistic, and IJG (Independent JPEG Group) licenses, which all encourage inclusion and use of free software in commercial and freeware products alike. As a consequence, its main points are that:\n\n   o We don't promise that this software works. However, we will be interested in any kind of bug reports. (`as is' distribution)\n\n   o You can use this software for whatever you want, in parts or full form, without having to pay us. (`royalty-free' usage)\n\n   o You may not pretend that you wrote this software. If you use it, or only parts of it, in a program, you must acknowledge somewhere in your documentation that you have used the FreeType code. (`credits')\n\nWe specifically permit and encourage the inclusion of this software, with or without modifications, in commercial products. We disclaim all warranties covering The FreeType Project and assume no liability related to The FreeType Project.\n\nFinally, many people asked us for a preferred form for a credit/disclaimer to use in compliance with this license. We thus encourage you to use the following text:\n\n\"\"\" Portions of this software are copyright © \u003cyear\u003e The FreeType Project (www.freetype.org). All rights reserved. \"\"\"\n\nPlease replace \u003cyear\u003e with the value from the FreeType version you actually use.\n\nLegal Terms\n\n   0. Definitions\n\n   Throughout this license, the terms `package', `FreeType Project', and `FreeType archive' refer to the set of files originally distributed by the authors (David Turner, Robert Wilhelm, and Werner Lemberg) as the `FreeType Project', be they named as alpha, beta or final release.\n\n   `You' refers to the licensee, or person using the project, where `using' is a generic term including compiling the project's source code as well as linking it to form a `program' or `executable'. This program is referred to as `a program using the FreeType engine'.\n\n   This license applies to all files distributed in the original FreeType Project, including all source code, binaries and documentation, unless otherwise stated in the file in its original, unmodified form as distributed in the original archive. If you are unsure whether or not a particular file is covered by this license, you must contact us to verify this.\n\n   The FreeType Project is copyright (C) 1996-2000 by David Turner, Robert Wilhelm, and Werner Lemberg. All rights reserved except as specified below.\n\n   1. No Warranty\n\n   THE FREETYPE PROJECT IS PROVIDED `AS IS' WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT WILL ANY OF THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY DAMAGES CAUSED BY THE USE OR THE INABILITY TO USE, OF THE FREETYPE PROJECT.\n\n   2. Redistribution\n\n   This license grants a worldwide, royalty-free, perpetual and irrevocable right and license to use, execute, perform, compile, display, copy, create derivative works of, distribute and sublicense the FreeType Project (in both source and object code forms) and derivative works thereof for any purpose; and to authorize others to exercise some or all of the rights granted herein, subject to the following conditions:\n\n      o Redistribution of source code must retain this license file (`FTL.TXT') unaltered; any additions, deletions or changes to the original files must be clearly indicated in accompanying documentation. The copyright notices of the unaltered, original files must be preserved in all copies of source files.\n\n      o Redistribution in binary form must provide a disclaimer that states that the software is based in part of the work of the FreeType Team, in the distribution documentation. We also encourage you to put an URL to the FreeType web page in your documentation, though this isn't mandatory.\n\n   These conditions apply to any software derived from or based on the FreeType Project, not just the unmodified files. If you use our work, you must acknowledge us. However, no fee need be paid to us.\n\n   3. Advertising\n\n   Neither the FreeType authors and contributors nor you shall use the name of the other for commercial, advertising, or promotional purposes without specific prior written permission.\n\n   We suggest, but do not require, that you use one or more of the following phrases to refer to this software in your documentation or advertising materials: `FreeType Project', `FreeType Engine', `FreeType library', or `FreeType Distribution'.\n\n   As you have not signed this license, you are not required to accept it. However, as the FreeType Project is copyrighted material, only this license, or another one contracted with the authors, grants you the right to use, distribute, and modify it. Therefore, by using, distributing, or modifying the FreeType Project, you indicate that you understand and accept all the terms of this license.\n\n   4. Contacts\n\n   There are two mailing lists related to FreeType:\n\n      o freetype@nongnu.org\n\n      Discusses general use and applications of FreeType, as well as future and wanted additions to the library and distribution. If you are looking for support, start in this list if you haven't found anything to help you in the documentation.\n\n      o freetype-devel@nongnu.org\n\n      Discusses bugs, as well as engine internals, design issues, specific licenses, porting, etc.\n\n   Our home page can be found at\n\n   http://www.freetype.org --- end of FTL.TXT ---"],"licenseIds":["FTL"],"keywords":["freetype project license","project license 2006","license 2006 jan","2006 jan 27","jan 27 copyright","27 copyright 1996","copyright 1996 2002","1996 2002 2006","2002 2006 by","2006 by david","werner lemberg introduction","lemberg introduction the","introduction the freetype","project is distributed","distributed in several","in several archive","several archive packages","archive packages some","packages some of","some of them","of them may","them may contain","contain in addition","font engine various","engine various tools","various tools and","tools and contributions","and contributions which","contributions which rely","which rely on","rely on or","on or relate","or relate to","relate to the","freetype project this","project this license","all files found","files found in","found in such","in such packages","such packages and","packages and which","do not fall","fall under their","their own explicit","own explicit license","explicit license the","the license affects","license affects thus","affects thus the","thus the freetype","font engine the","engine the test","the test programs","test programs documentation","programs documentation and","documentation and makefiles","and makefiles at","makefiles at the","the very least","very least this","least this license","license was inspired","was inspired by","inspired by the","the bsd artistic","bsd artistic and","artistic and ijg","and ijg independent","ijg independent jpeg","jpeg group licenses","group licenses which","licenses which all","which all encourage","all encourage inclusion","encourage inclusion and","inclusion and use","use of free","commercial and freeware","and freeware products","freeware products alike","products alike as","alike as a","a consequence its","consequence its main","its main points","main points are","points are that","are that o","that o we","o we don","software works however","works however we","however we will","we will be","will be interested","be interested in","interested in any","in any kind","kind of bug","of bug reports","bug reports as","reports as is","as is distribution","is distribution o","distribution o you","o you can","you want in","want in parts","in parts or","parts or full","or full form","full form without","form without having","having to pay","pay us royalty","us royalty free","royalty free usage","free usage o","usage o you","o you may","use it or","it or only","or only parts","only parts of","you have used","have used the","used the freetype","the freetype code","freetype code credits","code credits we","credits we specifically","encourage the inclusion","modifications in commercial","commercial products we","products we disclaim","we disclaim all","all warranties covering","warranties covering the","covering the freetype","project and assume","and assume no","no liability related","liability related to","freetype project finally","project finally many","finally many people","many people asked","people asked us","asked us for","us for a","for a preferred","a preferred form","for a credit","a credit disclaimer","credit disclaimer to","disclaimer to use","use in compliance","this license we","license we thus","we thus encourage","thus encourage you","following text portions","text portions of","software are copyright","copyright year the","year the freetype","freetype project www","project www freetype","freetype org all","org all rights","reserved please replace","please replace year","replace year with","year with the","with the value","the value from","value from the","from the freetype","the freetype version","freetype version you","version you actually","you actually use","actually use legal","use legal terms","legal terms 0","terms 0 definitions","0 definitions throughout","definitions throughout this","the terms package","terms package freetype","package freetype project","project and freetype","and freetype archive","freetype archive refer","archive refer to","of files originally","files originally distributed","originally distributed by","the authors david"]},{"licenseTexts":["Fair Source License, version 0.9 Copyright (C) [year] [copyright owner] Licensor: [legal name of licensor] Software: [name software and version if applicable] Use Limitation: [number] users License Grant. Licensor hereby grants to each recipient of the Software (\"you\") a non-exclusive, non-transferable, royalty-free and fully-paid-up license, under all of the Licensors copyright and patent rights, to use, copy, distribute, prepare derivative works of, publicly perform and display the Software, subject to the Use Limitation and the conditions set forth below. Use Limitation. The license granted above allows use by up to the number of users per entity set forth above (the \"Use Limitation\"). For determining the number of users, \"you\" includes all affiliates, meaning legal entities controlling, controlled by, or under common control with you. If you exceed the Use Limitation, your use is subject to payment of Licensors then-current list price for licenses. Conditions. Redistribution in source code or other forms must include a copy of this license document to be provided in a reasonable manner. Any redistribution of the Software is only allowed subject to this license. Trademarks. This license does not grant you any right in the trademarks, service marks, brand names or logos of Licensor. DISCLAIMER. THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OR CONDITION, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. LICENSORS HEREBY DISCLAIM ALL LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE. Termination. If you violate the terms of this license, your rights will terminate automatically and will not be reinstated without the prior written consent of Licensor. Any such termination will not affect the right of others who may have received copies of the Software from you."],"licenseIds":["Fair-Source-0.9"],"keywords":["fair source license","0 9 copyright","9 copyright c","year copyright owner","copyright owner licensor","owner licensor legal","licensor legal name","legal name of","of licensor software","licensor software name","software name software","name software and","software and version","and version if","version if applicable","if applicable use","applicable use limitation","use limitation number","limitation number users","number users license","users license grant","software you a","free and fully","and fully paid","fully paid up","paid up license","up license under","license under all","under all of","of the licensors","the licensors copyright","licensors copyright and","copy distribute prepare","perform and display","and display the","the software subject","use limitation and","limitation and the","and the conditions","forth below use","below use limitation","use limitation the","limitation the license","license granted above","granted above allows","above allows use","allows use by","use by up","by up to","to the number","of users per","users per entity","per entity set","entity set forth","set forth above","forth above the","above the use","use limitation for","limitation for determining","determining the number","of users you","users you includes","you includes all","includes all affiliates","all affiliates meaning","affiliates meaning legal","meaning legal entities","legal entities controlling","entities controlling controlled","with you if","if you exceed","you exceed the","exceed the use","use limitation your","limitation your use","your use is","subject to payment","to payment of","payment of licensors","of licensors then","licensors then current","then current list","current list price","list price for","price for licenses","for licenses conditions","licenses conditions redistribution","conditions redistribution in","other forms must","forms must include","license document to","be provided in","reasonable manner any","manner any redistribution","software is only","is only allowed","only allowed subject","allowed subject to","this license trademarks","license trademarks this","any right in","right in the","service marks brand","marks brand names","brand names or","names or logos","of licensor disclaimer","licensor disclaimer the","or condition express","condition express or","and noninfringement licensors","noninfringement licensors hereby","licensors hereby disclaim","disclaim all liability","all liability whether","the software termination","software termination if","if you violate","your rights will","rights will terminate","automatically and will","not be reinstated","be reinstated without","reinstated without the","of licensor any","licensor any such","affect the right","right of others","others who may","received copies of","fair source license version","version 0 9 copyright","0 9 copyright c","9 copyright c year","c year copyright owner","year copyright owner licensor","copyright owner licensor legal","owner licensor legal name","licensor legal name of","legal name of licensor","name of licensor software","of licensor software name","licensor software name software","software name software and","name software and version","software and version if","and version if applicable","version if applicable use","if applicable use limitation","applicable use limitation number","use limitation number users","limitation number users license","number users license grant","users license grant licensor","recipient of the software","the software you a","software you a non","transferable royalty free and","royalty free and fully","free and fully paid","and fully paid up","fully paid up license","paid up license under","up license under all","license under all of","under all of the","all of the licensors","of the licensors copyright","the licensors copyright and","licensors copyright and patent","and patent rights to","patent rights to use","use copy distribute prepare","copy distribute prepare derivative","publicly perform and display","perform and display the","and display the software","display the software subject","the software subject to","subject to the use","to the use limitation","the use limitation and","use limitation and the","limitation and the conditions","and the conditions set","set forth below use","forth below use limitation","below use limitation the","use limitation the license","limitation the license granted","the license granted above","license granted above allows","granted above allows use","above allows use by","allows use by up","use by up to","by up to the","up to the number","to the number of","number of users per"]},{"licenseTexts":["Fair License \u003cCopyright Information\u003e\n\nUsage of the works is permitted provided that this instrument is retained with the works, so that any entity that uses the works is notified of this instrument.\n\nDISCLAIMER: THE WORKS ARE WITHOUT WARRANTY."],"licenseIds":["Fair"],"keywords":["fair license copyright","license copyright information","copyright information usage","information usage of","works is permitted","that this instrument","this instrument is","instrument is retained","is retained with","retained with the","with the works","the works so","works so that","that any entity","entity that uses","uses the works","works is notified","notified of this","of this instrument","this instrument disclaimer","instrument disclaimer the","disclaimer the works","the works are","works are without","are without warranty","fair license copyright information","license copyright information usage","copyright information usage of","information usage of the","usage of the works","of the works is","the works is permitted","works is permitted provided","provided that this instrument","that this instrument is","this instrument is retained","instrument is retained with","is retained with the","retained with the works","with the works so","the works so that","works so that any","so that any entity","that any entity that","any entity that uses","entity that uses the","that uses the works","uses the works is","the works is notified","works is notified of","is notified of this","notified of this instrument","of this instrument disclaimer","this instrument disclaimer the","instrument disclaimer the works","disclaimer the works are","the works are without","works are without warranty","fair license copyright information usage","license copyright information usage of","copyright information usage of the","information usage of the works","usage of the works is","of the works is permitted","the works is permitted provided","works is permitted provided that","permitted provided that this instrument","provided that this instrument is","that this instrument is retained","this instrument is retained with","instrument is retained with the","is retained with the works","retained with the works so","with the works so that","the works so that any","works so that any entity","so that any entity that","that any entity that uses","any entity that uses the","entity that uses the works","that uses the works is","uses the works is notified","the works is notified of","works is notified of this","is notified of this instrument","notified of this instrument disclaimer","of this instrument disclaimer the","this instrument disclaimer the works","instrument disclaimer the works are","disclaimer the works are without","the works are without warranty"]},{"licenseTexts":["THE FRAMEWORX OPEN LICENSE 1.0\n\nThis License Agreement, The Frameworx Open License 1.0, has been entered into between The Frameworx Company and you, the licensee hereunder, effective as of Your acceptance of the Frameworx Code Base or an Downstream Distribution (each as defined below).\n\nAGREEMENT BACKGROUND\n\nThe Frameworx Company is committed to the belief that open source software results in better quality, greater technical and product innovation in the market place and a more empowered and productive developer and end-user community. Our objective is to ensure that the Frameworx Code Base, and the source code for improvements and innovations to it, remain free and open to the community.To further these beliefs and objectives, we are distributing the Frameworx Code Base, without royalties and in source code form, to the community pursuant to this License Agreement.\n\nAGREEMENT TERMS\n\nThe Frameworx Company and You have agreed as follows:\n\n   1. Definitions.The following terms have the following respective meanings:\n\n      (a) Frameworx Code Base means the software developed by The Frameworx Company and made available under this License Agreement\n\n      (b) Downstream Distribution means any direct or indirect release, distribution or remote availability of software (i) that directly or indirectly contains, or depends for its intended functioning on, the Frameworx Code Base or any portion or element thereof and (ii) in which rights to use and distribute such Frameworx Code Base software depend, directly or indirectly, on the License provided in Section 2 below.\n\n      (c) \"Source Code\" to any software means the preferred form for making modifications to that software, including any associated documentation, interface definition files and compilation or installation scripts, or any version thereof that has been compressed or archived, and can be reconstituted, using an appropriate and generally available archival or compression technology.\n\n      (d) Value-Added Services means any commercial or fee-based software-related service, including without limitation: system or application development or consulting; technical or end-user support or training; distribution maintenance, configuration or versioning; or outsourced, hosted or network-based application services.\n\n   2. License Grant. Subject to the terms and conditions hereof, The Frameworx Company hereby grants You a non-exclusive license (the License), subject to third party intellectual property claims, and for no fee other than a nominal charge reflecting the costs of physical distribution, to:\n\n      (a) use the Frameworx Code Base, in either Source Code or machine-readable form;\n\n      (b) make modifications, additions and deletions to the content or structure of the Frameworx Code Base; or\n\n      (c) create larger works or derivative works including the Frameworx Code Base or any portion or element thereof; and\n\n      (d) release, distribute or make available, either generally or to any specific third-party, any of the foregoing in Source Code or binary form.\n\n   3. License Conditions. The grant of the License under Section 1 hereof, and your exercise of all rights in connection with this License Agreement, will remain subject to the following terms and conditions, as well as to the other provisions hereof:\n\n      (a) Complete Source Code for any Downstream Distribution directly or indirectly made by You that contains, or depends for its intended functionality on, the Frameworx Code Base, or any portion or element thereof, shall be made freely available to all users thereof on terms and conditions no more restrictive, and no less favorable for any user (including, without limitation, with regard to Source Code availability and royalty-free use) than those terms and conditions provided in this License Agreement.\n\n      (b) Any Value-Added Services that you offer or provide, directly or indirectly, in relation to any Downstream Distribution shall be offered and provided on commercial terms that are reasonably commensurate to the fair market value of such Value-Added Services. In addition, the terms and conditions on which any such Value Added Services are so offered or provided shall be consistent with, and shall fully support, the intent and purpose of this License Agreement.\n\n      (c) All Downstream Distributions shall:\n\n         (i) include all portions and elements of the Frameworx Code Base required to build the Source Code of such Downstream Distribution into a fully functional machine-executable system, or additional build scripts or comparable software necessary and sufficient for such purposes;\n\n         (ii) include, in each file containing any portion or element of the Frameworx Code Base, the following identifying legend: This file contains software that has been made available under The Frameworx Open License 1.0. Use and distribution hereof are subject to the restrictions set forth therein.\n\n         (iii) include all other copyright notices, authorship credits, warranty disclaimers (including that provided in Section 6 below), legends, documentation, annotations and comments contained in the Frameworx Code Base as provided to You hereunder;\n\n         (iv) contain an unaltered copy of the html file named frameworx_community_invitation.html included within the Frameworx Code Base that acknowledges new users and provides them with information on the Frameworx Code Base community;\n\n         (v) contain an unaltered copy of the text file named the_frameworx_license.txt included within the Frameworx Code Base that includes a text copy of the form of this License Agreement; and\n\n         (vi) prominently display to any viewer or user of the Source Code of such Open Downstream Distribution, in the place and manner normally used for such displays, the following legend:\n\n   Source code licensed under from The Frameworx Company is contained herein, and such source code has been obtained either under The Frameworx Open License, or another license granted by The Frameworx Company. Use and distribution hereof is subject to the restrictions provided in the relevant such license and to the copyrights of the licensor thereunder. A copy of The Frameworx Open License is provided in a file named the_frameworx_license.txt and included herein, and may also be available for inspection at http://www.frameworx.com.\n\n   4. Restrictions on Open Downstream Distributions. Each Downstream Distribution made by You, and by any party directly or indirectly obtaining rights to the Frameworx Code Base through You, shall be made subject to a license grant or agreement to the extent necessary so that each distributee under that Downstream Distribution will be subject to the same restrictions on re-distribution and use as are binding on You hereunder. You may satisfy this licensing requirement either by:\n\n      (a) requiring as a condition to any Downstream Distribution made by you, or by any direct or indirect distributee of Your Downstream Distribution (or any portion or element thereof), that each distributee under the relevant Downstream Distribution obtain a direct license (on the same terms and conditions as those in this License Agreement) from The Frameworx Company; or\n\n      (b) sub-licensing all (and not less than all) of Your rights and obligations hereunder to that distributee, including (without limitation) Your obligation to require distributees to be bound by license restrictions as contemplated by this Section 4 above.\n\n   The Frameworx Company hereby grants to you all rights to sub-license your rights hereunder as necessary to fully effect the intent and purpose of this Section 4 above, provided, however, that your rights and obligations hereunder shall be unaffected by any such sublicensing. In addition, The Frameworx Company expressly retains all rights to take all appropriate action (including legal action) against any such direct or indirect sub-licensee to ensure its full compliance with the intent and purposes of this License Agreement.\n\n   5. Intellectual Property. Except as expressly provided herein, this License Agreement preserves and respects Your and The Frameworx Companys respective intellectual property rights, including, in the case of The Frameworx Company, its copyrights and patent rights relating to the Frameworx Code Base.\n\n   6. Warranty Disclaimer. THE SOFTWARE LICENSED HEREUNDER IS PROVIDED ``AS IS.'' ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT, ARE HEREBY DISCLAIMED. IN NO EVENT SHALL THE LICENSOR OF THIS SOFTWARE, BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES INCLUDING (BUT NOT LIMITED TO) PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n   7. License Violation. The License, and all of your rights thereunder, shall be deemed automatically terminated and void as of any Downstream Distribution directly or indirectly made or facilitated by You that violates the provisions of this License Agreement, provided, however, that this License Agreement shall survive any such termination in order to remedy the effects of such violation. This License Agreement shall be binding on the legal successors and assigns of the parties hereto.\n\n   Your agreement to the foregoing as of the date hereof has been evidenced by your acceptance of the relevant software distribution hereunder. (C) THE FRAMEWORX COMPANY 2003"],"licenseIds":["Frameworx-1.0"],"keywords":["agreement the frameworx","1 0 has","has been entered","been entered into","entered into between","into between the","between the frameworx","the licensee hereunder","licensee hereunder effective","hereunder effective as","as of your","base or an","or an downstream","an downstream distribution","downstream distribution each","distribution each as","each as defined","defined below agreement","below agreement background","agreement background the","background the frameworx","company is committed","is committed to","committed to the","to the belief","the belief that","belief that open","source software results","results in better","in better quality","better quality greater","quality greater technical","greater technical and","technical and product","and product innovation","product innovation in","innovation in the","in the market","the market place","market place and","place and a","and a more","a more empowered","more empowered and","empowered and productive","and productive developer","productive developer and","developer and end","and end user","end user community","user community our","community our objective","our objective is","objective is to","that the frameworx","base and the","code for improvements","for improvements and","improvements and innovations","and innovations to","innovations to it","to it remain","it remain free","remain free and","and open to","open to the","the community to","community to further","to further these","further these beliefs","these beliefs and","beliefs and objectives","and objectives we","objectives we are","we are distributing","are distributing the","distributing the frameworx","code base without","base without royalties","without royalties and","royalties and in","form to the","the community pursuant","community pursuant to","agreement agreement terms","agreement terms the","terms the frameworx","you have agreed","have agreed as","agreed as follows","follows 1 definitions","definitions the following","the following respective","following respective meanings","respective meanings a","meanings a frameworx","a frameworx code","code base means","base means the","company and made","agreement b downstream","b downstream distribution","downstream distribution means","distribution means any","means any direct","or indirect release","indirect release distribution","release distribution or","distribution or remote","or remote availability","remote availability of","availability of software","of software i","software i that","i that directly","or indirectly contains","indirectly contains or","its intended functioning","intended functioning on","functioning on the","ii in which","in which rights","which rights to","distribute such frameworx","such frameworx code","code base software","base software depend","software depend directly","depend directly or","or indirectly on","indirectly on the","on the license","2 below c","below c source","any software means","modifications to that","to that software","that software including","software including any","including any associated","files and compilation","and compilation or","compilation or installation","or installation scripts","installation scripts or","scripts or any","or any version","any version thereof","version thereof that","thereof that has","has been compressed","been compressed or","compressed or archived","or archived and","archived and can","can be reconstituted","be reconstituted using","reconstituted using an","using an appropriate","an appropriate and","appropriate and generally","and generally available","generally available archival","available archival or","archival or compression","or compression technology","compression technology d","technology d value","d value added","added services means","services means any","means any commercial","any commercial or","commercial or fee","or fee based","fee based software","based software related","software related service","related service including","without limitation system","limitation system or","system or application","or application development","application development or","development or consulting","or consulting technical","consulting technical or","technical or end","or end user","end user support","user support or","support or training","or training distribution","training distribution maintenance","distribution maintenance configuration","maintenance configuration or","configuration or versioning","or versioning or","versioning or outsourced","or outsourced hosted"]},{"licenseTexts":["FreeImage Public License - Version 1.0\n\n   1. Definitions.\n\n      1.1. \"Contributor\" means each entity that creates or contributes to the creation of Modifications.\n\n      1.2. \"Contributor Version\" means the combination of the Original Code, prior Modifications used by a Contributor, and the Modifications made by that particular Contributor.\n\n      1.3. \"Covered Code\" means the Original Code or Modifications or the combination of the Original Code and Modifications, in each case including portions thereof.\n\n      1.4. \"Electronic Distribution Mechanism\" means a mechanism generally accepted in the software development community for the electronic transfer of data.\n\n      1.5. \"Executable\" means Covered Code in any form other than Source Code.\n\n      1.6. \"Initial Developer\" means the individual or entity identified as the Initial Developer in the Source Code notice required by Exhibit A.\n\n      1.7. \"Larger Work\" means a work which combines Covered Code or portions thereof with code not governed by the terms of this License.\n\n      1.8. \"License\" means this document.\n\n      1.9. \"Modifications\" means any addition to or deletion from the substance or structure of either the Original Code or any previous Modifications. When Covered Code is released as a series of files, a\n\n      Modification is:\n\n         A. Any addition to or deletion from the contents of a file containing Original Code or previous Modifications.\n\n         B. Any new file that contains any part of the Original Code or previous Modifications.\n\n      1.10. \"Original Code\" means Source Code of computer software code which is described in the Source Code notice required by Exhibit A as Original Code, and which, at the time of its release under this License is not already Covered Code governed by this License.\n\n      1.11. \"Source Code\" means the preferred form of the Covered Code for making modifications to it, including all modules it contains, plus any associated interface definition files, scripts used to control compilation and installation of an Executable, or a list of source code differential comparisons against either the Original Code or another well known, available Covered Code of the Contributor's choice. The Source Code can be in a compressed or archival form, provided the appropriate decompression or de-archiving software is widely available for no charge.\n\n      1.12. \"You\" means an individual or a legal entity exercising rights under, and complying with all of the terms of, this License or a future version of this License issued under Section 6.1. For legal entities, \"You\" includes any entity which controls, is controlled by, or is under common control with You. For purposes of this definition, \"control\" means (a) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (b) ownership of fifty percent (50%) or more of the outstanding shares or beneficial ownership of such entity.\n\n   2. Source Code License.\n\n      2.1. The Initial Developer Grant.\n\n      The Initial Developer hereby grants You a world-wide, royalty-free, non-exclusive license, subject to third party intellectual property claims:\n\n         (a) to use, reproduce, modify, display, perform, sublicense and distribute the Original Code (or portions thereof) with or without Modifications, or as part of a Larger Work; and\n\n         (b) under patents now or hereafter owned or controlled by Initial Developer, to make, have made, use and sell (\"Utilize\") the Original Code (or portions thereof), but solely to the extent that any such patent is reasonably necessary to enable You to Utilize the Original Code (or portions thereof) and not to any greater extent that may be necessary to Utilize further Modifications or combinations.\n\n      2.2. Contributor Grant.\n\n      Each Contributor hereby grants You a world-wide, royalty-free, non-exclusive license, subject to third party intellectual property claims:\n\n         (a) to use, reproduce, modify, display, perform, sublicense and distribute the Modifications created by such Contributor (or portions thereof) either on an unmodified basis, with other Modifications, as Covered Code or as part of a Larger Work; and\n\n         (b) under patents now or hereafter owned or controlled by Contributor, to Utilize the Contributor Version (or portions thereof), but solely to the extent that any such patent is reasonably necessary to enable You to Utilize the Contributor Version (or portions thereof), and not to any greater extent that may be necessary to Utilize further Modifications or combinations.\n\n   3. Distribution Obligations.\n\n      3.1. Application of License.\n\n      The Modifications which You create or to which You contribute are governed by the terms of this License, including without limitation Section 2.2. The Source Code version of Covered Code may be distributed only under the terms of this License or a future version of this License released under Section 6.1, and You must include a copy of this License with every copy of the Source Code You distribute. You may not offer or impose any terms on any Source Code version that alters or restricts the applicable version of this License or the recipients' rights hereunder. However, You may include an additional document offering the additional rights described in Section 3.5.\n\n      3.2. Availability of Source Code.\n\n      Any Modification which You create or to which You contribute must be made available in Source Code form under the terms of this License either on the same media as an Executable version or via an accepted Electronic Distribution Mechanism to anyone to whom you made an Executable version available; and if made available via Electronic Distribution Mechanism, must remain available for at least twelve (12) months after the date it initially became available, or at least six (6) months after a subsequent version of that particular Modification has been made available to such recipients. You are responsible for ensuring that the Source Code version remains available even if the Electronic Distribution Mechanism is maintained by a third party.\n\n      3.3. Description of Modifications.\n\n      You must cause all Covered Code to which you contribute to contain a file documenting the changes You made to create that Covered Code and the date of any change. You must include a prominent statement that the Modification is derived, directly or indirectly, from Original Code provided by the Initial Developer and including the name of the Initial Developer in (a) the Source Code, and (b) in any notice in an Executable version or related documentation in which You describe the origin or ownership of the Covered Code.\n\n      3.4. Intellectual Property Matters\n\n         (a) Third Party Claims.\n\n         If You have knowledge that a party claims an intellectual property right in particular functionality or code (or its utilization under this License), you must include a text file with the source code distribution titled \"LEGAL\" which describes the claim and the party making the claim in sufficient detail that a recipient will know whom to contact. If you obtain such knowledge after You make Your Modification available as described in Section 3.2, You shall promptly modify the LEGAL file in all copies You make available thereafter and shall take other steps (such as notifying appropriate mailing lists or newsgroups) reasonably calculated to inform those who received the Covered Code that new knowledge has been obtained.\n\n         (b) Contributor APIs.\n\n         If Your Modification is an application programming interface and You own or control patents which are reasonably necessary to implement that API, you must also include this information in the LEGAL file.\n\n      3.5. Required Notices.\n\n      You must duplicate the notice in Exhibit A in each file of the Source Code, and this License in any documentation for the Source Code, where You describe recipients' rights relating to Covered Code. If You created one or more Modification(s), You may add your name as a Contributor to the notice described in Exhibit A. If it is not possible to put such notice in a particular Source Code file due to its structure, then you must include such notice in a location (such as a relevant directory file) where a user would be likely to look for such a notice. You may choose to offer, and to charge a fee for, warranty, support, indemnity or liability obligations to one or more recipients of Covered Code. However, You may do so only on Your own behalf, and not on behalf of the Initial Developer or any Contributor. You must make it absolutely clear than any such warranty, support, indemnity or liability obligation is offered by You alone, and You hereby agree to indemnify the Initial Developer and every Contributor for any liability incurred by the Initial Developer or such Contributor as a result of warranty, support, indemnity or liability terms You offer.\n\n      3.6. Distribution of Executable Versions.\n\n      You may distribute Covered Code in Executable form only if the requirements of Section 3.1-3.5 have been met for that Covered Code, and if You include a notice stating that the Source Code version of the Covered Code is available under the terms of this License, including a description of how and where You have fulfilled the obligations of Section 3.2. The notice must be conspicuously included in any notice in an Executable version, related documentation or collateral in which You descr ibe recipients' rights relating to the Covered Code. You may distribute the Executable version of Covered Code under a license of Your choice, which may contain terms different from this License, provided that You are in compliance with the terms of this License and that the license for the Executable version does not attempt to limit or alter the recipient's rights in the Source Code version from the rights set forth in this License. If You distribute the Executable version under a different license You must make it absolutely clear that any terms which differ from this License are offered by You alone, not by the Initial Developer or any Contributor. You hereby agree to indemnify the Initial Developer and every Contributor for any liability incurred by the Initial Developer or such Contributor as a result of any such terms You offer.\n\n      3.7. Larger Works.\n\n      You may create a Larger Work by combining Covered Code with other code not governed by the terms of this License and distribute the Larger Work as a single product. In such a case, You must make sure the requirements of this License are fulfilled for the Covered Code.\n\n   4. Inability to Comply Due to Statute or Regulation.\n\n   If it is impossible for You to comply with any of the terms of this License with respect to some or all of the Covered Code due to statute or regulation then You must: (a) comply with the terms of this License to the maximum extent possible; and (b) describe the limitations and the code they affect. Such description must be included in the LEGAL file described in Section 3.4 and must be included with all distributions of the Source Code. Except to the extent prohibited by statute or regulation, such description must be sufficiently detailed for a recipient of ordinary skill to be able to understand it.\n\n   5. Application of this License.\n\n   This License applies to code to which the Initial Developer has attached the notice in Exhibit A, and to related Covered Code.\n\n   6. Versions of the License.\n\n      6.1. New Versions.\n\n      Floris van den Berg may publish revised and/or new versions of the License from time to time. Each version will be given a distinguishing version number.\n\n      6.2. Effect of New Versions.\n\n      Once Covered Code has been published under a particular version of the License, You may always continue to use it under the terms of that version. You may also choose to use such Covered Code under the terms of any subsequent version of the License published by Floris van den Berg\n\n      No one other than Floris van den Berg has the right to modify the terms applicable to Covered Code created under this License.\n\n      6.3. Derivative Works.\n\n      If you create or use a modified version of this License (which you may only do in order to apply it to code which is not already Covered Code governed by this License), you must (a) rename Your license so that the phrases \"FreeImage\", `FreeImage Public License\", \"FIPL\", or any confusingly similar phrase do not appear anywhere in your license and (b) otherwise make it clear that your version of the license contains terms which differ from the FreeImage Public License. (Filling in the name of the Initial Developer, Original Code or Contributor in the notice described in Exhibit A shall not of themselves be deemed to be modifications of this License.)\n\n   7. DISCLAIMER OF WARRANTY.\n\n   COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN \"AS IS\" BASIS, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER.\n\n   8. TERMINATION.\n\n   This License and the rights granted hereunder will terminate automatically if You fail to comply with terms herein and fail to cure such breach within 30 days of becoming aware of the breach. All sublicenses to the Covered Code which are properly granted shall survive any termination of this License. Provisions which, by their nature, must remain in effect beyond the termination of this License shall survive.\n\n   9. LIMITATION OF LIABILITY.\n\n   UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER TORT (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL THE INITIAL DEVELOPER, ANY OTHER CONTRIBUTOR, OR ANY DISTRIBUTOR OF COVERED CODE, OR ANY SUPPLIER OF ANY OF SUCH PARTIES, BE LIABLE TO YOU OR ANY OTHER PERSON FOR ANY INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, COMPUTER FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER COMMERCIAL DAMAGES OR LOSSES, EVEN IF SUCH PARTY SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF LIABILITY SHALL NOT APPLY TO LIABILITY FOR DEATH OR PERSONAL INJURY RESULTING FROM SUCH PARTY'S NEGLIGENCE TO THE EXTENT APPLICABLE LAW PROHIBITS SUCH LIMITATION. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OR LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THAT EXCLUSION AND LIMITATION MAY NOT APPLY TO YOU.\n\n   10. U.S. GOVERNMENT END USERS.\n\n   The Covered Code is a \"commercial item,\" as that term is defined in 48 C.F.R. 2.101 (Oct. 1995), consisting of \"commercial computer software\" and \"commercial computer software documentation,\" as such terms are used in 48 C.F.R. 12.212 (Sept. 1995). Consistent with 48 C.F.R. 12.212 and 48 C.F.R. 227.7202-1 through 227.7202-4 (June 1995), all U.S. Government End Users acquire Covered Code with only those rights set forth herein.\n\n   11. MISCELLANEOUS.\n\n   This License represents the complete agreement concerning subject matter hereof. If any provision of this License is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable. This License shall be governed by Dutch law provisions (except to the extent applicable law, if any, provides otherwise), excluding its conflict-of-law provisions. With respect to disputes in which at least one party is a citizen of, or an entity chartered or registered to do business in, the The Netherlands: (a) unless otherwise agreed in writing, all disputes relating to this License (excepting any dispute relating to intellectual property rights) shall be subject to final and binding arbitration, with the losing party paying all costs of arbitration; (b) any arbitration relating to this Agreement shall be held in Almelo, The Netherlands; and (c) any litigation relating to this Agreement shall be subject to the jurisdiction of the court of Almelo, The Netherlands with the losing party responsible for costs, including without limitation, court costs and reasonable attorneys fees and expenses. Any law or regulation which provides that the language of a contract shall be construed against the drafter shall not apply to this License.\n\n   12. RESPONSIBILITY FOR CLAIMS.\n\n   Except in cases where another Contributor has failed to comply with Section 3.4, You are responsible for damages arising, directly or indirectly, out of Your utilization of rights under this License, based on the number of copies of Covered Code you made available, the revenues you received from utilizing such rights, and other relevant factors. You agree to work with affected parties to distribute responsibility on an equitable basis. EXHIBIT A.\n\n\"The contents of this file are subject to the FreeImage Public License Version 1.0 (the \"License\"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://home.wxs.nl/~flvdberg/freeimage-license.txt\n\nSoftware distributed under the License is distributed on an \"AS IS\" basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the specific language governing rights and limitations under the License."],"licenseIds":["FreeImage"],"keywords":["which you descr","you descr ibe","descr ibe recipients","ibe recipients rights","new versions floris","versions floris van","den berg may","berg may publish","published by floris","by floris van","den berg no","berg no one","other than floris","than floris van","den berg has","berg has the","the phrases freeimage","phrases freeimage freeimage","freeimage freeimage public","public license fipl","license fipl or","fipl or any","from the freeimage","governed by dutch","by dutch law","dutch law provisions","the the netherlands","the netherlands a","netherlands a unless","held in almelo","in almelo the","the netherlands and","netherlands and c","court of almelo","of almelo the","the netherlands with","netherlands with the","and expenses any","expenses any law","to the freeimage","at http home","http home wxs","home wxs nl","wxs nl flvdberg","nl flvdberg freeimage","flvdberg freeimage license","freeimage license txt","license txt software","txt software distributed","in which you descr","which you descr ibe","you descr ibe recipients","descr ibe recipients rights","ibe recipients rights relating","1 new versions floris","new versions floris van","versions floris van den","van den berg may","den berg may publish","berg may publish revised","license published by floris","published by floris van","by floris van den","van den berg no","den berg no one","berg no one other","one other than floris","other than floris van","than floris van den","van den berg has","den berg has the","berg has the right","that the phrases freeimage","the phrases freeimage freeimage","phrases freeimage freeimage public","freeimage freeimage public license","freeimage public license fipl","public license fipl or","license fipl or any","fipl or any confusingly","differ from the freeimage","from the freeimage public","freeimage public license filling","be governed by dutch","governed by dutch law","by dutch law provisions","dutch law provisions except","business in the the","in the the netherlands","the the netherlands a","the netherlands a unless","netherlands a unless otherwise","be held in almelo","held in almelo the","in almelo the netherlands","almelo the netherlands and","the netherlands and c","netherlands and c any","the court of almelo","court of almelo the","of almelo the netherlands","almelo the netherlands with","the netherlands with the","netherlands with the losing","fees and expenses any","and expenses any law","expenses any law or","subject to the freeimage","to the freeimage public","license at http home","at http home wxs","http home wxs nl","home wxs nl flvdberg","wxs nl flvdberg freeimage","nl flvdberg freeimage license","flvdberg freeimage license txt","freeimage license txt software","license txt software distributed","txt software distributed under","collateral in which you descr","in which you descr ibe","which you descr ibe recipients","you descr ibe recipients rights","descr ibe recipients rights relating","ibe recipients rights relating to","6 1 new versions floris","1 new versions floris van","new versions floris van den","versions floris van den berg","floris van den berg may","van den berg may publish","den berg may publish revised","berg may publish revised and","the license published by floris","license published by floris van","published by floris van den","by floris van den berg","floris van den berg no","van den berg no one","den berg no one other","berg no one other than","no one other than floris","one other than floris van","other than floris van den","than floris van den berg","floris van den berg has","van den berg has the","den berg has the right","berg has the right to","so that the phrases freeimage","that the phrases freeimage freeimage","the phrases freeimage freeimage public","phrases freeimage freeimage public license","freeimage freeimage public license fipl","freeimage public license fipl or","public license fipl or any","license fipl or any confusingly","fipl or any confusingly similar","which differ from the freeimage","differ from the freeimage public","from the freeimage public license","the freeimage public license filling","freeimage public license filling in","shall be governed by dutch","be governed by dutch law","governed by dutch law provisions","by dutch law provisions except","dutch law provisions except to","do business in the the","business in the the netherlands","in the the netherlands a","the the netherlands a unless","the netherlands a unless otherwise","netherlands a unless otherwise agreed","shall be held in almelo","be held in almelo the","held in almelo the netherlands","in almelo the netherlands and","almelo the netherlands and c","the netherlands and c any","netherlands and c any litigation","of the court of almelo","the court of almelo the","court of almelo the netherlands","of almelo the netherlands with","almelo the netherlands with the","the netherlands with the losing","netherlands with the losing party","attorneys fees and expenses any","fees and expenses any law","and expenses any law or","expenses any law or regulation","are subject to the freeimage","subject to the freeimage public","to the freeimage public license","the freeimage public license version","the license at http home","license at http home wxs","at http home wxs nl","http home wxs nl flvdberg"]},{"licenseTexts":["GNU Free Documentation License\n\nVersion 1.1, March 2000\n\nCopyright (C) 2000 Free Software Foundation, Inc. 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n\nEveryone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.\n\n   0. PREAMBLE\n\n   The purpose of this License is to make a manual, textbook, or other written document \"free\" in the sense of freedom: to assure everyone the effective freedom to copy and redistribute it, with or without modifying it, either commercially or noncommercially. Secondarily, this License preserves for the author and publisher a way to get credit for their work, while not being considered responsible for modifications made by others.\n\n   This License is a kind of \"copyleft\", which means that derivative works of the document must themselves be free in the same sense. It complements the GNU General Public License, which is a copyleft license designed for free software.\n\n   We have designed this License in order to use it for manuals for free software, because free software needs free documentation: a free program should come with manuals providing the same freedoms that the software does. But this License is not limited to software manuals; it can be used for any textual work, regardless of subject matter or whether it is published as a printed book. We recommend this License principally for works whose purpose is instruction or reference.\n\n   1. APPLICABILITY AND DEFINITIONS\n\n   This License applies to any manual or other work that contains a notice placed by the copyright holder saying it can be distributed under the terms of this License. The \"Document\", below, refers to any such manual or work. Any member of the public is a licensee, and is addressed as \"you\".\n\n   A \"Modified Version\" of the Document means any work containing the Document or a portion of it, either copied verbatim, or with modifications and/or translated into another language.\n\n   A \"Secondary Section\" is a named appendix or a front-matter section of the Document that deals exclusively with the relationship of the publishers or authors of the Document to the Document's overall subject (or to related matters) and contains nothing that could fall directly within that overall subject. (For example, if the Document is in part a textbook of mathematics, a Secondary Section may not explain any mathematics.) The relationship could be a matter of historical connection with the subject or with related matters, or of legal, commercial, philosophical, ethical or political position regarding them.\n\n   The \"Invariant Sections\" are certain Secondary Sections whose titles are designated, as being those of Invariant Sections, in the notice that says that the Document is released under this License.\n\n   The \"Cover Texts\" are certain short passages of text that are listed, as Front-Cover Texts or Back-Cover Texts, in the notice that says that the Document is released under this License.\n\n   A \"Transparent\" copy of the Document means a machine-readable copy, represented in a format whose specification is available to the general public, whose contents can be viewed and edited directly and straightforwardly with generic text editors or (for images composed of pixels) generic paint programs or (for drawings) some widely available drawing editor, and that is suitable for input to text formatters or for automatic translation to a variety of formats suitable for input to text formatters. A copy made in an otherwise Transparent file format whose markup has been designed to thwart or discourage subsequent modification by readers is not Transparent. A copy that is not \"Transparent\" is called \"Opaque\".\n\n   Examples of suitable formats for Transparent copies include plain ASCII without markup, Texinfo input format, LaTeX input format, SGML or XML using a publicly available DTD, and standard-conforming simple HTML designed for human modification. Opaque formats include PostScript, PDF, proprietary formats that can be read and edited only by proprietary word processors, SGML or XML for which the DTD and/or processing tools are not generally available, and the machine-generated HTML produced by some word processors for output purposes only.\n\n   The \"Title Page\" means, for a printed book, the title page itself, plus such following pages as are needed to hold, legibly, the material this License requires to appear in the title page. For works in formats which do not have any title page as such, \"Title Page\" means the text near the most prominent appearance of the work's title, preceding the beginning of the body of the text.\n\n   2. VERBATIM COPYING\n\n   You may copy and distribute the Document in any medium, either commercially or noncommercially, provided that this License, the copyright notices, and the license notice saying this License applies to the Document are reproduced in all copies, and that you add no other conditions whatsoever to those of this License. You may not use technical measures to obstruct or control the reading or further copying of the copies you make or distribute. However, you may accept compensation in exchange for copies. If you distribute a large enough number of copies you must also follow the conditions in section 3.\n\n   You may also lend copies, under the same conditions stated above, and you may publicly display copies.\n\n   3. COPYING IN QUANTITY\n\n   If you publish printed copies of the Document numbering more than 100, and the Document's license notice requires Cover Texts, you must enclose the copies in covers that carry, clearly and legibly, all these Cover Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on the back cover. Both covers must also clearly and legibly identify you as the publisher of these copies. The front cover must present the full title with all words of the title equally prominent and visible. You may add other material on the covers in addition. Copying with changes limited to the covers, as long as they preserve the title of the Document and satisfy these conditions, can be treated as verbatim copying in other respects.\n\n   If the required texts for either cover are too voluminous to fit legibly, you should put the first ones listed (as many as fit reasonably) on the actual cover, and continue the rest onto adjacent pages.\n\n   If you publish or distribute Opaque copies of the Document numbering more than 100, you must either include a machine-readable Transparent copy along with each Opaque copy, or state in or with each Opaque copy a publicly-accessible computer-network location containing a complete Transparent copy of the Document, free of added material, which the general network-using public has access to download anonymously at no charge using public-standard network protocols. If you use the latter option, you must take reasonably prudent steps, when you begin distribution of Opaque copies in quantity, to ensure that this Transparent copy will remain thus accessible at the stated location until at least one year after the last time you distribute an Opaque copy (directly or through your agents or retailers) of that edition to the public.\n\n   It is requested, but not required, that you contact the authors of the Document well before redistributing any large number of copies, to give them a chance to provide you with an updated version of the Document.\n\n   4. MODIFICATIONS\n\n   You may copy and distribute a Modified Version of the Document under the conditions of sections 2 and 3 above, provided that you release the Modified Version under precisely this License, with the Modified Version filling the role of the Document, thus licensing distribution and modification of the Modified Version to whoever possesses a copy of it. In addition, you must do these things in the Modified Version:\n\n      A. Use in the Title Page (and on the covers, if any) a title distinct from that of the Document, and from those of previous versions (which should, if there were any, be listed in the History section of the Document). You may use the same title as a previous version if the original publisher of that version gives permission.\n\n      B. List on the Title Page, as authors, one or more persons or entities responsible for authorship of the modifications in the Modified Version, together with at least five of the principal authors of the Document (all of its principal authors, if it has less than five).\n\n      C. State on the Title page the name of the publisher of the Modified Version, as the publisher.\n\n      D. Preserve all the copyright notices of the Document.\n\n      E. Add an appropriate copyright notice for your modifications adjacent to the other copyright notices.\n\n      F. Include, immediately after the copyright notices, a license notice giving the public permission to use the Modified Version under the terms of this License, in the form shown in the Addendum below.\n\n      G. Preserve in that license notice the full lists of Invariant Sections and required Cover Texts given in the Document's license notice.\n\n      H. Include an unaltered copy of this License.\n\n      I. Preserve the section entitled \"History\", and its title, and add to it an item stating at least the title, year, new authors, and publisher of the Modified Version as given on the Title Page. If there is no section entitled \"History\" in the Document, create one stating the title, year, authors, and publisher of the Document as given on its Title Page, then add an item describing the Modified Version as stated in the previous sentence.\n\n      J. Preserve the network location, if any, given in the Document for public access to a Transparent copy of the Document, and likewise the network locations given in the Document for previous versions it was based on. These may be placed in the \"History\" section. You may omit a network location for a work that was published at least four years before the Document itself, or if the original publisher of the version it refers to gives permission.\n\n      K. In any section entitled \"Acknowledgements\" or \"Dedications\", preserve the section's title, and preserve in the section all the substance and tone of each of the contributor acknowledgements and/or dedications given therein.\n\n      L. Preserve all the Invariant Sections of the Document, unaltered in their text and in their titles. Section numbers or the equivalent are not considered part of the section titles.\n\n      M. Delete any section entitled \"Endorsements\". Such a section may not be included in the Modified Version.\n\n      N. Do not retitle any existing section as \"Endorsements\" or to conflict in title with any Invariant Section.\n\n   If the Modified Version includes new front-matter sections or appendices that qualify as Secondary Sections and contain no material copied from the Document, you may at your option designate some or all of these sections as invariant. To do this, add their titles to the list of Invariant Sections in the Modified Version's license notice. These titles must be distinct from any other section titles.\n\n   You may add a section entitled \"Endorsements\", provided it contains nothing but endorsements of your Modified Version by various parties--for example, statements of peer review or that the text has been approved by an organization as the authoritative definition of a standard.\n\n   You may add a passage of up to five words as a Front-Cover Text, and a passage of up to 25 words as a Back-Cover Text, to the end of the list of Cover Texts in the Modified Version. Only one passage of Front-Cover Text and one of Back-Cover Text may be added by (or through arrangements made by) any one entity. If the Document already includes a cover text for the same cover, previously added by you or by arrangement made by the same entity you are acting on behalf of, you may not add another; but you may replace the old one, on explicit permission from the previous publisher that added the old one.\n\n   The author(s) and publisher(s) of the Document do not by this License give permission to use their names for publicity for or to assert or imply endorsement of any Modified Version.\n\n   5. COMBINING DOCUMENTS\n\n   You may combine the Document with other documents released under this License, under the terms defined in section 4 above for modified versions, provided that you include in the combination all of the Invariant Sections of all of the original documents, unmodified, and list them all as Invariant Sections of your combined work in its license notice.\n\n   The combined work need only contain one copy of this License, and multiple identical Invariant Sections may be replaced with a single copy. If there are multiple Invariant Sections with the same name but different contents, make the title of each such section unique by adding at the end of it, in parentheses, the name of the original author or publisher of that section if known, or else a unique number. Make the same adjustment to the section titles in the list of Invariant Sections in the license notice of the combined work.\n\n   In the combination, you must combine any sections entitled \"History\" in the various original documents, forming one section entitled \"History\"; likewise combine any sections entitled \"Acknowledgements\", and any sections entitled \"Dedications\". You must delete all sections entitled \"Endorsements.\"\n\n   6. COLLECTIONS OF DOCUMENTS\n\n   You may make a collection consisting of the Document and other documents released under this License, and replace the individual copies of this License in the various documents with a single copy that is included in the collection, provided that you follow the rules of this License for verbatim copying of each of the documents in all other respects.\n\n   You may extract a single document from such a collection, and distribute it individually under this License, provided you insert a copy of this License into the extracted document, and follow this License in all other respects regarding verbatim copying of that document.\n\n   7. AGGREGATION WITH INDEPENDENT WORKS\n\n   A compilation of the Document or its derivatives with other separate and independent documents or works, in or on a volume of a storage or distribution medium, does not as a whole count as a Modified Version of the Document, provided no compilation copyright is claimed for the compilation. Such a compilation is called an \"aggregate\", and this License does not apply to the other self-contained works thus compiled with the Document, on account of their being thus compiled, if they are not themselves derivative works of the Document.\n\n   If the Cover Text requirement of section 3 is applicable to these copies of the Document, then if the Document is less than one quarter of the entire aggregate, the Document's Cover Texts may be placed on covers that surround only the Document within the aggregate. Otherwise they must appear on covers around the whole aggregate.\n\n   8. TRANSLATION\n\n   Translation is considered a kind of modification, so you may distribute translations of the Document under the terms of section 4. Replacing Invariant Sections with translations requires special permission from their copyright holders, but you may include translations of some or all Invariant Sections in addition to the original versions of these Invariant Sections. You may include a translation of this License provided that you also include the original English version of this License. In case of a disagreement between the translation and the original English version of this License, the original English version will prevail.\n\n   9. TERMINATION\n\n   You may not copy, modify, sublicense, or distribute the Document except as expressly provided for under this License. Any other attempt to copy, modify, sublicense or distribute the Document is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance.\n\n   10. FUTURE REVISIONS OF THIS LICENSE\n\n   The Free Software Foundation may publish new, revised versions of the GNU Free Documentation License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. See http://www.gnu.org/copyleft/.\n\n   Each version of the License is given a distinguishing version number. If the Document specifies that a particular numbered version of this License \"or any later version\" applies to it, you have the option of following the terms and conditions either of that specified version or of any later version that has been published (not as a draft) by the Free Software Foundation. If the Document does not specify a version number of this License, you may choose any version ever published (not as a draft) by the Free Software Foundation. ADDENDUM: How to use this License for your documents\n\nTo use this License in a document you have written, include a copy of the License in the document and put the following copyright and license notices just after the title page:\n\nCopyright (c) YEAR YOUR NAME. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.1 or any later version published by the Free Software Foundation; with the Invariant Sections being LIST THEIR TITLES, with the Front-Cover Texts being LIST, and with the Back-Cover Texts being LIST. A copy of the license is included in the section entitled \"GNU Free Documentation License\".\n\nIf you have no Invariant Sections, write \"with no Invariant Sections\" instead of saying which ones are invariant. If you have no Front-Cover Texts, write \"no Front-Cover Texts\" instead of \"Front-Cover Texts being LIST\"; likewise for Back-Cover Texts.\n\nIf your document contains nontrivial examples of program code, we recommend releasing these examples in parallel under your choice of free software license, such as the GNU General Public License, to permit their use in free software."],"licenseIds":["GFDL-1.1-or-later","GFDL-1.1-only","GFDL-1.1"],"keywords":["march 2000 copyright","2000 copyright c","c 2000 free","2000 free software","or other written","other written document","written document free","license the document","you a modified","overall subject for","subject for example","example if the","license the cover","license a transparent","general public whose","public whose contents","whose contents can","contents can be","can be viewed","be viewed and","viewed and edited","and edited directly","edited directly and","directly and straightforwardly","and straightforwardly with","whose markup has","has been designed","been designed to","designed to thwart","not transparent a","transparent a copy","simple html designed","html designed for","human modification opaque","modification opaque formats","formats include postscript","include postscript pdf","postscript pdf proprietary","pdf proprietary formats","generated html produced","html produced by","the text 2","text 2 verbatim","printed copies of","copy a publicly","publicly accessible computer","accessible computer network","network location containing","location containing a","containing a complete","added material which","material which the","to download anonymously","download anonymously at","anonymously at no","no charge using","charge using public","network protocols if","protocols if you","it has less","has less than","less than five","than five c","five c state","entitled history and","history and its","and its title","permission k in","k in any","in any section","the section s","section s title","s title and","title and preserve","existing section as","section as endorsements","as endorsements or","invariant section if","section if the","notice the combined","does not as","a whole count","whole count as","count as a","the document provided","document provided no","provided no compilation","no compilation copyright","compilation copyright is","is claimed for","claimed for the","for the compilation","the compilation such","compilation such a","such a compilation","a compilation is","compilation is called","an aggregate and","aggregate and this","the other self","other self contained","self contained works","contained works thus","works thus compiled","thus compiled with","compiled with the","with the document","the document on","document on account","on account of","account of their","of their being","their being thus","being thus compiled","thus compiled if","compiled if they","than one quarter","one quarter of","quarter of the","covers that surround","that surround only","surround only the","only the document","the aggregate otherwise","aggregate otherwise they","appear on covers","on covers around","covers around the","around the whole","license in case","english version will","will prevail 9","prevail 9 termination","foundation with the","being list a","list a copy","have no invariant","invariant sections write","sections write with","write with no","invariant sections instead","sections instead of","instead of saying","of saying which","saying which ones","which ones are","ones are invariant","are invariant if","invariant if you","have no front","cover texts write","texts write no","write no front","cover texts instead","texts instead of","instead of front","being list likewise","list likewise for","likewise for back","for back cover","cover texts if","texts if your","version 1 1 march","1 march 2000 copyright","march 2000 copyright c","2000 copyright c 2000","copyright c 2000 free","c 2000 free software","2000 free software foundation","textbook or other written","or other written document","other written document free","written document free in","other work that contains","work that contains a","this license the document","license the document below","as you a modified","you a modified version","that overall subject for","overall subject for example","subject for example if","for example if the","example if the document","this license the cover","license the cover texts","this license a transparent","license a transparent copy","the general public whose","general public whose contents","public whose contents can","whose contents can be","contents can be viewed","can be viewed and","be viewed and edited","viewed and edited directly","and edited directly and","edited directly and straightforwardly","directly and straightforwardly with","and straightforwardly with generic"]},{"licenseTexts":["GNU Free Documentation License\n\nVersion 1.2, November 2002\n\nCopyright (C) 2000,2001,2002 Free Software Foundation, Inc. 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n\nEveryone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.\n\n   0. PREAMBLE\n\n   The purpose of this License is to make a manual, textbook, or other functional and useful document \"free\" in the sense of freedom: to assure everyone the effective freedom to copy and redistribute it, with or without modifying it, either commercially or noncommercially. Secondarily, this License preserves for the author and publisher a way to get credit for their work, while not being considered responsible for modifications made by others.\n\n   This License is a kind of \"copyleft\", which means that derivative works of the document must themselves be free in the same sense. It complements the GNU General Public License, which is a copyleft license designed for free software.\n\n   We have designed this License in order to use it for manuals for free software, because free software needs free documentation: a free program should come with manuals providing the same freedoms that the software does. But this License is not limited to software manuals; it can be used for any textual work, regardless of subject matter or whether it is published as a printed book. We recommend this License principally for works whose purpose is instruction or reference.\n\n   1. APPLICABILITY AND DEFINITIONS\n\n   This License applies to any manual or other work, in any medium, that contains a notice placed by the copyright holder saying it can be distributed under the terms of this License. Such a notice grants a world-wide, royalty-free license, unlimited in duration, to use that work under the conditions stated herein. The \"Document\", below, refers to any such manual or work. Any member of the public is a licensee, and is addressed as \"you\". You accept the license if you copy, modify or distribute the work in a way requiring permission under copyright law.\n\n   A \"Modified Version\" of the Document means any work containing the Document or a portion of it, either copied verbatim, or with modifications and/or translated into another language.\n\n   A \"Secondary Section\" is a named appendix or a front-matter section of the Document that deals exclusively with the relationship of the publishers or authors of the Document to the Document's overall subject (or to related matters) and contains nothing that could fall directly within that overall subject. (Thus, if the Document is in part a textbook of mathematics, a Secondary Section may not explain any mathematics.) The relationship could be a matter of historical connection with the subject or with related matters, or of legal, commercial, philosophical, ethical or political position regarding them.\n\n   The \"Invariant Sections\" are certain Secondary Sections whose titles are designated, as being those of Invariant Sections, in the notice that says that the Document is released under this License. If a section does not fit the above definition of Secondary then it is not allowed to be designated as Invariant. The Document may contain zero Invariant Sections. If the Document does not identify any Invariant Sections then there are none.\n\n   The \"Cover Texts\" are certain short passages of text that are listed, as Front-Cover Texts or Back-Cover Texts, in the notice that says that the Document is released under this License. A Front-Cover Text may be at most 5 words, and a Back-Cover Text may be at most 25 words.\n\n   A \"Transparent\" copy of the Document means a machine-readable copy, represented in a format whose specification is available to the general public, that is suitable for revising the document straightforwardly with generic text editors or (for images composed of pixels) generic paint programs or (for drawings) some widely available drawing editor, and that is suitable for input to text formatters or for automatic translation to a variety of formats suitable for input to text formatters. A copy made in an otherwise Transparent file format whose markup, or absence of markup, has been arranged to thwart or discourage subsequent modification by readers is not Transparent. An image format is not Transparent if used for any substantial amount of text. A copy that is not \"Transparent\" is called \"Opaque\".\n\n   Examples of suitable formats for Transparent copies include plain ASCII without markup, Texinfo input format, LaTeX input format, SGML or XML using a publicly available DTD, and standard-conforming simple HTML, PostScript or PDF designed for human modification. Examples of transparent image formats include PNG, XCF and JPG. Opaque formats include proprietary formats that can be read and edited only by proprietary word processors, SGML or XML for which the DTD and/or processing tools are not generally available, and the machine-generated HTML, PostScript or PDF produced by some word processors for output purposes only.\n\n   The \"Title Page\" means, for a printed book, the title page itself, plus such following pages as are needed to hold, legibly, the material this License requires to appear in the title page. For works in formats which do not have any title page as such, \"Title Page\" means the text near the most prominent appearance of the work's title, preceding the beginning of the body of the text.\n\n   A section \"Entitled XYZ\" means a named subunit of the Document whose title either is precisely XYZ or contains XYZ in parentheses following text that translates XYZ in another language. (Here XYZ stands for a specific section name mentioned below, such as \"Acknowledgements\", \"Dedications\", \"Endorsements\", or \"History\".) To \"Preserve the Title\" of such a section when you modify the Document means that it remains a section \"Entitled XYZ\" according to this definition.\n\n   The Document may include Warranty Disclaimers next to the notice which states that this License applies to the Document. These Warranty Disclaimers are considered to be included by reference in this License, but only as regards disclaiming warranties: any other implication that these Warranty Disclaimers may have is void and has no effect on the meaning of this License.\n\n   2. VERBATIM COPYING\n\n   You may copy and distribute the Document in any medium, either commercially or noncommercially, provided that this License, the copyright notices, and the license notice saying this License applies to the Document are reproduced in all copies, and that you add no other conditions whatsoever to those of this License. You may not use technical measures to obstruct or control the reading or further copying of the copies you make or distribute. However, you may accept compensation in exchange for copies. If you distribute a large enough number of copies you must also follow the conditions in section 3.\n\n   You may also lend copies, under the same conditions stated above, and you may publicly display copies.\n\n   3. COPYING IN QUANTITY\n\n   If you publish printed copies (or copies in media that commonly have printed covers) of the Document, numbering more than 100, and the Document's license notice requires Cover Texts, you must enclose the copies in covers that carry, clearly and legibly, all these Cover Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on the back cover. Both covers must also clearly and legibly identify you as the publisher of these copies. The front cover must present the full title with all words of the title equally prominent and visible. You may add other material on the covers in addition. Copying with changes limited to the covers, as long as they preserve the title of the Document and satisfy these conditions, can be treated as verbatim copying in other respects.\n\n   If the required texts for either cover are too voluminous to fit legibly, you should put the first ones listed (as many as fit reasonably) on the actual cover, and continue the rest onto adjacent pages.\n\n   If you publish or distribute Opaque copies of the Document numbering more than 100, you must either include a machine-readable Transparent copy along with each Opaque copy, or state in or with each Opaque copy a computer-network location from which the general network-using public has access to download using public-standard network protocols a complete Transparent copy of the Document, free of added material. If you use the latter option, you must take reasonably prudent steps, when you begin distribution of Opaque copies in quantity, to ensure that this Transparent copy will remain thus accessible at the stated location until at least one year after the last time you distribute an Opaque copy (directly or through your agents or retailers) of that edition to the public.\n\n   It is requested, but not required, that you contact the authors of the Document well before redistributing any large number of copies, to give them a chance to provide you with an updated version of the Document.\n\n   4. MODIFICATIONS\n\n   You may copy and distribute a Modified Version of the Document under the conditions of sections 2 and 3 above, provided that you release the Modified Version under precisely this License, with the Modified Version filling the role of the Document, thus licensing distribution and modification of the Modified Version to whoever possesses a copy of it. In addition, you must do these things in the Modified Version:\n\n      A. Use in the Title Page (and on the covers, if any) a title distinct from that of the Document, and from those of previous versions (which should, if there were any, be listed in the History section of the Document). You may use the same title as a previous version if the original publisher of that version gives permission.\n\n      B. List on the Title Page, as authors, one or more persons or entities responsible for authorship of the modifications in the Modified Version, together with at least five of the principal authors of the Document (all of its principal authors, if it has fewer than five), unless they release you from this requirement.\n\n      C. State on the Title page the name of the publisher of the Modified Version, as the publisher.\n\n      D. Preserve all the copyright notices of the Document.\n\n      E. Add an appropriate copyright notice for your modifications adjacent to the other copyright notices.\n\n      F. Include, immediately after the copyright notices, a license notice giving the public permission to use the Modified Version under the terms of this License, in the form shown in the Addendum below.\n\n      G. Preserve in that license notice the full lists of Invariant Sections and required Cover Texts given in the Document's license notice.\n\n      H. Include an unaltered copy of this License.\n\n      I. Preserve the section Entitled \"History\", Preserve its Title, and add to it an item stating at least the title, year, new authors, and publisher of the Modified Version as given on the Title Page. If there is no section Entitled \"History\" in the Document, create one stating the title, year, authors, and publisher of the Document as given on its Title Page, then add an item describing the Modified Version as stated in the previous sentence.\n\n      J. Preserve the network location, if any, given in the Document for public access to a Transparent copy of the Document, and likewise the network locations given in the Document for previous versions it was based on. These may be placed in the \"History\" section. You may omit a network location for a work that was published at least four years before the Document itself, or if the original publisher of the version it refers to gives permission.\n\n      K. For any section Entitled \"Acknowledgements\" or \"Dedications\", Preserve the Title of the section, and preserve in the section all the substance and tone of each of the contributor acknowledgements and/or dedications given therein.\n\n      L. Preserve all the Invariant Sections of the Document, unaltered in their text and in their titles. Section numbers or the equivalent are not considered part of the section titles.\n\n      M. Delete any section Entitled \"Endorsements\". Such a section may not be included in the Modified Version.\n\n      N. Do not retitle any existing section to be Entitled \"Endorsements\" or to conflict in title with any Invariant Section.\n\n      O. Preserve any Warranty Disclaimers.\n\n   If the Modified Version includes new front-matter sections or appendices that qualify as Secondary Sections and contain no material copied from the Document, you may at your option designate some or all of these sections as invariant. To do this, add their titles to the list of Invariant Sections in the Modified Version's license notice. These titles must be distinct from any other section titles.\n\n   You may add a section Entitled \"Endorsements\", provided it contains nothing but endorsements of your Modified Version by various parties--for example, statements of peer review or that the text has been approved by an organization as the authoritative definition of a standard.\n\n   You may add a passage of up to five words as a Front-Cover Text, and a passage of up to 25 words as a Back-Cover Text, to the end of the list of Cover Texts in the Modified Version. Only one passage of Front-Cover Text and one of Back-Cover Text may be added by (or through arrangements made by) any one entity. If the Document already includes a cover text for the same cover, previously added by you or by arrangement made by the same entity you are acting on behalf of, you may not add another; but you may replace the old one, on explicit permission from the previous publisher that added the old one.\n\n   The author(s) and publisher(s) of the Document do not by this License give permission to use their names for publicity for or to assert or imply endorsement of any Modified Version.\n\n   5. COMBINING DOCUMENTS\n\n   You may combine the Document with other documents released under this License, under the terms defined in section 4 above for modified versions, provided that you include in the combination all of the Invariant Sections of all of the original documents, unmodified, and list them all as Invariant Sections of your combined work in its license notice, and that you preserve all their Warranty Disclaimers.\n\n   The combined work need only contain one copy of this License, and multiple identical Invariant Sections may be replaced with a single copy. If there are multiple Invariant Sections with the same name but different contents, make the title of each such section unique by adding at the end of it, in parentheses, the name of the original author or publisher of that section if known, or else a unique number. Make the same adjustment to the section titles in the list of Invariant Sections in the license notice of the combined work.\n\n   In the combination, you must combine any sections Entitled \"History\" in the various original documents, forming one section Entitled \"History\"; likewise combine any sections Entitled \"Acknowledgements\", and any sections Entitled \"Dedications\". You must delete all sections Entitled \"Endorsements\".\n\n   6. COLLECTIONS OF DOCUMENTS\n\n   You may make a collection consisting of the Document and other documents released under this License, and replace the individual copies of this License in the various documents with a single copy that is included in the collection, provided that you follow the rules of this License for verbatim copying of each of the documents in all other respects.\n\n   You may extract a single document from such a collection, and distribute it individually under this License, provided you insert a copy of this License into the extracted document, and follow this License in all other respects regarding verbatim copying of that document.\n\n   7. AGGREGATION WITH INDEPENDENT WORKS\n\n   A compilation of the Document or its derivatives with other separate and independent documents or works, in or on a volume of a storage or distribution medium, is called an \"aggregate\" if the copyright resulting from the compilation is not used to limit the legal rights of the compilation's users beyond what the individual works permit. When the Document is included in an aggregate, this License does not apply to the other works in the aggregate which are not themselves derivative works of the Document.\n\n   If the Cover Text requirement of section 3 is applicable to these copies of the Document, then if the Document is less than one half of the entire aggregate, the Document's Cover Texts may be placed on covers that bracket the Document within the aggregate, or the electronic equivalent of covers if the Document is in electronic form. Otherwise they must appear on printed covers that bracket the whole aggregate.\n\n   8. TRANSLATION\n\n   Translation is considered a kind of modification, so you may distribute translations of the Document under the terms of section 4. Replacing Invariant Sections with translations requires special permission from their copyright holders, but you may include translations of some or all Invariant Sections in addition to the original versions of these Invariant Sections. You may include a translation of this License, and all the license notices in the Document, and any Warranty Disclaimers, provided that you also include the original English version of this License and the original versions of those notices and disclaimers. In case of a disagreement between the translation and the original version of this License or a notice or disclaimer, the original version will prevail.\n\n   If a section in the Document is Entitled \"Acknowledgements\", \"Dedications\", or \"History\", the requirement (section 4) to Preserve its Title (section 1) will typically require changing the actual title.\n\n   9. TERMINATION\n\n   You may not copy, modify, sublicense, or distribute the Document except as expressly provided for under this License. Any other attempt to copy, modify, sublicense or distribute the Document is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance.\n\n   10. FUTURE REVISIONS OF THIS LICENSE\n\n   The Free Software Foundation may publish new, revised versions of the GNU Free Documentation License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. See http://www.gnu.org/copyleft/.\n\n   Each version of the License is given a distinguishing version number. If the Document specifies that a particular numbered version of this License \"or any later version\" applies to it, you have the option of following the terms and conditions either of that specified version or of any later version that has been published (not as a draft) by the Free Software Foundation. If the Document does not specify a version number of this License, you may choose any version ever published (not as a draft) by the Free Software Foundation. ADDENDUM: How to use this License for your documents\n\nTo use this License in a document you have written, include a copy of the License in the document and put the following copyright and license notices just after the title page:\n\nCopyright (c) YEAR YOUR NAME. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copy of the license is included in the section entitled \"GNU Free Documentation License\".\n\nIf you have Invariant Sections, Front-Cover Texts and Back-Cover Texts, replace the \"with...Texts.\" line with this:\n\nwith the Invariant Sections being LIST THEIR TITLES, with the Front-Cover Texts being LIST, and with the Back-Cover Texts being LIST.\n\nIf you have Invariant Sections without Cover Texts, or some other combination of the three, merge those two alternatives to suit the situation.\n\nIf your document contains nontrivial examples of program code, we recommend releasing these examples in parallel under your choice of free software license, such as the GNU General Public License, to permit their use in free software."],"licenseIds":["GFDL-1.2-or-later","GFDL-1.2-only","GFDL-1.2"],"keywords":["1 2 november","2 november 2002","november 2002 copyright","2002 copyright c","2001 2002 free","2002 free software","the text a","text a section","version 1 2 november","1 2 november 2002","2 november 2002 copyright","november 2002 copyright c","2002 copyright c 2000","2000 2001 2002 free","2001 2002 free software","2002 free software foundation","of the text a","the text a section","text a section entitled","1 2 or any","license version 1 2 november","version 1 2 november 2002","1 2 november 2002 copyright","2 november 2002 copyright c","november 2002 copyright c 2000","2002 copyright c 2000 2001","c 2000 2001 2002 free","2000 2001 2002 free software","2001 2002 free software foundation","2002 free software foundation inc","body of the text a","of the text a section","the text a section entitled","text a section entitled xyz","version 1 2 or any","1 2 or any later"]},{"licenseTexts":["GNU Free Documentation License\n\nVersion 1.3, 3 November 2008 Copyright (C) 2000, 2001, 2002, 2007, 2008 Free Software Foundation, Inc. \u003chttp://fsf.org/\u003e\n\nEveryone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.\n\n   0. PREAMBLE\n\n   The purpose of this License is to make a manual, textbook, or other functional and useful document \"free\" in the sense of freedom: to assure everyone the effective freedom to copy and redistribute it, with or without modifying it, either commercially or noncommercially. Secondarily, this License preserves for the author and publisher a way to get credit for their work, while not being considered responsible for modifications made by others.\n\n   This License is a kind of \"copyleft\", which means that derivative works of the document must themselves be free in the same sense. It complements the GNU General Public License, which is a copyleft license designed for free software.\n\n   We have designed this License in order to use it for manuals for free software, because free software needs free documentation: a free program should come with manuals providing the same freedoms that the software does. But this License is not limited to software manuals; it can be used for any textual work, regardless of subject matter or whether it is published as a printed book. We recommend this License principally for works whose purpose is instruction or reference.\n\n   1. APPLICABILITY AND DEFINITIONS\n\n   This License applies to any manual or other work, in any medium, that contains a notice placed by the copyright holder saying it can be distributed under the terms of this License. Such a notice grants a world-wide, royalty-free license, unlimited in duration, to use that work under the conditions stated herein. The \"Document\", below, refers to any such manual or work. Any member of the public is a licensee, and is addressed as \"you\". You accept the license if you copy, modify or distribute the work in a way requiring permission under copyright law.\n\n   A \"Modified Version\" of the Document means any work containing the Document or a portion of it, either copied verbatim, or with modifications and/or translated into another language.\n\n   A \"Secondary Section\" is a named appendix or a front-matter section of the Document that deals exclusively with the relationship of the publishers or authors of the Document to the Document's overall subject (or to related matters) and contains nothing that could fall directly within that overall subject. (Thus, if the Document is in part a textbook of mathematics, a Secondary Section may not explain any mathematics.) The relationship could be a matter of historical connection with the subject or with related matters, or of legal, commercial, philosophical, ethical or political position regarding them.\n\n   The \"Invariant Sections\" are certain Secondary Sections whose titles are designated, as being those of Invariant Sections, in the notice that says that the Document is released under this License. If a section does not fit the above definition of Secondary then it is not allowed to be designated as Invariant. The Document may contain zero Invariant Sections. If the Document does not identify any Invariant Sections then there are none.\n\n   The \"Cover Texts\" are certain short passages of text that are listed, as Front-Cover Texts or Back-Cover Texts, in the notice that says that the Document is released under this License. A Front-Cover Text may be at most 5 words, and a Back-Cover Text may be at most 25 words.\n\n   A \"Transparent\" copy of the Document means a machine-readable copy, represented in a format whose specification is available to the general public, that is suitable for revising the document straightforwardly with generic text editors or (for images composed of pixels) generic paint programs or (for drawings) some widely available drawing editor, and that is suitable for input to text formatters or for automatic translation to a variety of formats suitable for input to text formatters. A copy made in an otherwise Transparent file format whose markup, or absence of markup, has been arranged to thwart or discourage subsequent modification by readers is not Transparent. An image format is not Transparent if used for any substantial amount of text. A copy that is not \"Transparent\" is called \"Opaque\".\n\n   Examples of suitable formats for Transparent copies include plain ASCII without markup, Texinfo input format, LaTeX input format, SGML or XML using a publicly available DTD, and standard-conforming simple HTML, PostScript or PDF designed for human modification. Examples of transparent image formats include PNG, XCF and JPG. Opaque formats include proprietary formats that can be read and edited only by proprietary word processors, SGML or XML for which the DTD and/or processing tools are not generally available, and the machine-generated HTML, PostScript or PDF produced by some word processors for output purposes only.\n\n   The \"Title Page\" means, for a printed book, the title page itself, plus such following pages as are needed to hold, legibly, the material this License requires to appear in the title page. For works in formats which do not have any title page as such, \"Title Page\" means the text near the most prominent appearance of the work's title, preceding the beginning of the body of the text.\n\n   The \"publisher\" means any person or entity that distributes copies of the Document to the public.\n\n   A section \"Entitled XYZ\" means a named subunit of the Document whose title either is precisely XYZ or contains XYZ in parentheses following text that translates XYZ in another language. (Here XYZ stands for a specific section name mentioned below, such as \"Acknowledgements\", \"Dedications\", \"Endorsements\", or \"History\".) To \"Preserve the Title\" of such a section when you modify the Document means that it remains a section \"Entitled XYZ\" according to this definition.\n\n   The Document may include Warranty Disclaimers next to the notice which states that this License applies to the Document. These Warranty Disclaimers are considered to be included by reference in this License, but only as regards disclaiming warranties: any other implication that these Warranty Disclaimers may have is void and has no effect on the meaning of this License.\n\n   2. VERBATIM COPYING\n\n   You may copy and distribute the Document in any medium, either commercially or noncommercially, provided that this License, the copyright notices, and the license notice saying this License applies to the Document are reproduced in all copies, and that you add no other conditions whatsoever to those of this License. You may not use technical measures to obstruct or control the reading or further copying of the copies you make or distribute. However, you may accept compensation in exchange for copies. If you distribute a large enough number of copies you must also follow the conditions in section 3.\n\n   You may also lend copies, under the same conditions stated above, and you may publicly display copies.\n\n   3. COPYING IN QUANTITY\n\n   If you publish printed copies (or copies in media that commonly have printed covers) of the Document, numbering more than 100, and the Document's license notice requires Cover Texts, you must enclose the copies in covers that carry, clearly and legibly, all these Cover Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on the back cover. Both covers must also clearly and legibly identify you as the publisher of these copies. The front cover must present the full title with all words of the title equally prominent and visible. You may add other material on the covers in addition. Copying with changes limited to the covers, as long as they preserve the title of the Document and satisfy these conditions, can be treated as verbatim copying in other respects.\n\n   If the required texts for either cover are too voluminous to fit legibly, you should put the first ones listed (as many as fit reasonably) on the actual cover, and continue the rest onto adjacent pages.\n\n   If you publish or distribute Opaque copies of the Document numbering more than 100, you must either include a machine-readable Transparent copy along with each Opaque copy, or state in or with each Opaque copy a computer-network location from which the general network-using public has access to download using public-standard network protocols a complete Transparent copy of the Document, free of added material. If you use the latter option, you must take reasonably prudent steps, when you begin distribution of Opaque copies in quantity, to ensure that this Transparent copy will remain thus accessible at the stated location until at least one year after the last time you distribute an Opaque copy (directly or through your agents or retailers) of that edition to the public.\n\n   It is requested, but not required, that you contact the authors of the Document well before redistributing any large number of copies, to give them a chance to provide you with an updated version of the Document.\n\n   4. MODIFICATIONS\n\n   You may copy and distribute a Modified Version of the Document under the conditions of sections 2 and 3 above, provided that you release the Modified Version under precisely this License, with the Modified Version filling the role of the Document, thus licensing distribution and modification of the Modified Version to whoever possesses a copy of it. In addition, you must do these things in the Modified Version:\n\n      A. Use in the Title Page (and on the covers, if any) a title distinct from that of the Document, and from those of previous versions (which should, if there were any, be listed in the History section of the Document). You may use the same title as a previous version if the original publisher of that version gives permission.\n\n      B. List on the Title Page, as authors, one or more persons or entities responsible for authorship of the modifications in the Modified Version, together with at least five of the principal authors of the Document (all of its principal authors, if it has fewer than five), unless they release you from this requirement.\n\n      C. State on the Title page the name of the publisher of the Modified Version, as the publisher.\n\n      D. Preserve all the copyright notices of the Document.\n\n      E. Add an appropriate copyright notice for your modifications adjacent to the other copyright notices.\n\n      F. Include, immediately after the copyright notices, a license notice giving the public permission to use the Modified Version under the terms of this License, in the form shown in the Addendum below.\n\n      G. Preserve in that license notice the full lists of Invariant Sections and required Cover Texts given in the Document's license notice. H. Include an unaltered copy of this License.\n\n      I. Preserve the section Entitled \"History\", Preserve its Title, and add to it an item stating at least the title, year, new authors, and publisher of the Modified Version as given on the Title Page. If there is no section Entitled \"History\" in the Document, create one stating the title, year, authors, and publisher of the Document as given on its Title Page, then add an item describing the Modified Version as stated in the previous sentence.\n\n      J. Preserve the network location, if any, given in the Document for public access to a Transparent copy of the Document, and likewise the network locations given in the Document for previous versions it was based on. These may be placed in the \"History\" section. You may omit a network location for a work that was published at least four years before the Document itself, or if the original publisher of the version it refers to gives permission.\n\n      K. For any section Entitled \"Acknowledgements\" or \"Dedications\", Preserve the Title of the section, and preserve in the section all the substance and tone of each of the contributor acknowledgements and/or dedications given therein.\n\n      L. Preserve all the Invariant Sections of the Document, unaltered in their text and in their titles. Section numbers or the equivalent are not considered part of the section titles.\n\n      M. Delete any section Entitled \"Endorsements\". Such a section may not be included in the Modified Version.\n\n      N. Do not retitle any existing section to be Entitled \"Endorsements\" or to conflict in title with any Invariant Section.\n\n      O. Preserve any Warranty Disclaimers.\n\n   If the Modified Version includes new front-matter sections or appendices that qualify as Secondary Sections and contain no material copied from the Document, you may at your option designate some or all of these sections as invariant. To do this, add their titles to the list of Invariant Sections in the Modified Version's license notice. These titles must be distinct from any other section titles.\n\n   You may add a section Entitled \"Endorsements\", provided it contains nothing but endorsements of your Modified Version by various parties--for example, statements of peer review or that the text has been approved by an organization as the authoritative definition of a standard.\n\n   You may add a passage of up to five words as a Front-Cover Text, and a passage of up to 25 words as a Back-Cover Text, to the end of the list of Cover Texts in the Modified Version. Only one passage of Front-Cover Text and one of Back-Cover Text may be added by (or through arrangements made by) any one entity. If the Document already includes a cover text for the same cover, previously added by you or by arrangement made by the same entity you are acting on behalf of, you may not add another; but you may replace the old one, on explicit permission from the previous publisher that added the old one.\n\n   The author(s) and publisher(s) of the Document do not by this License give permission to use their names for publicity for or to assert or imply endorsement of any Modified Version.\n\n   5. COMBINING DOCUMENTS\n\n   You may combine the Document with other documents released under this License, under the terms defined in section 4 above for modified versions, provided that you include in the combination all of the Invariant Sections of all of the original documents, unmodified, and list them all as Invariant Sections of your combined work in its license notice, and that you preserve all their Warranty Disclaimers.\n\n   The combined work need only contain one copy of this License, and multiple identical Invariant Sections may be replaced with a single copy. If there are multiple Invariant Sections with the same name but different contents, make the title of each such section unique by adding at the end of it, in parentheses, the name of the original author or publisher of that section if known, or else a unique number. Make the same adjustment to the section titles in the list of Invariant Sections in the license notice of the combined work.\n\n   In the combination, you must combine any sections Entitled \"History\" in the various original documents, forming one section Entitled \"History\"; likewise combine any sections Entitled \"Acknowledgements\", and any sections Entitled \"Dedications\". You must delete all sections Entitled \"Endorsements\".\n\n   6. COLLECTIONS OF DOCUMENTS\n\n   You may make a collection consisting of the Document and other documents released under this License, and replace the individual copies of this License in the various documents with a single copy that is included in the collection, provided that you follow the rules of this License for verbatim copying of each of the documents in all other respects.\n\n   You may extract a single document from such a collection, and distribute it individually under this License, provided you insert a copy of this License into the extracted document, and follow this License in all other respects regarding verbatim copying of that document.\n\n   7. AGGREGATION WITH INDEPENDENT WORKS\n\n   A compilation of the Document or its derivatives with other separate and independent documents or works, in or on a volume of a storage or distribution medium, is called an \"aggregate\" if the copyright resulting from the compilation is not used to limit the legal rights of the compilation's users beyond what the individual works permit. When the Document is included in an aggregate, this License does not apply to the other works in the aggregate which are not themselves derivative works of the Document.\n\n   If the Cover Text requirement of section 3 is applicable to these copies of the Document, then if the Document is less than one half of the entire aggregate, the Document's Cover Texts may be placed on covers that bracket the Document within the aggregate, or the electronic equivalent of covers if the Document is in electronic form. Otherwise they must appear on printed covers that bracket the whole aggregate.\n\n   8. TRANSLATION\n\n   Translation is considered a kind of modification, so you may distribute translations of the Document under the terms of section 4. Replacing Invariant Sections with translations requires special permission from their copyright holders, but you may include translations of some or all Invariant Sections in addition to the original versions of these Invariant Sections. You may include a translation of this License, and all the license notices in the Document, and any Warranty Disclaimers, provided that you also include the original English version of this License and the original versions of those notices and disclaimers. In case of a disagreement between the translation and the original version of this License or a notice or disclaimer, the original version will prevail.\n\n   If a section in the Document is Entitled \"Acknowledgements\", \"Dedications\", or \"History\", the requirement (section 4) to Preserve its Title (section 1) will typically require changing the actual title.\n\n   9. TERMINATION\n\n   You may not copy, modify, sublicense, or distribute the Document except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense, or distribute it is void, and will automatically terminate your rights under this License.\n\n   However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation.\n\n   Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice.\n\n   Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License. If your rights have been terminated and not permanently reinstated, receipt of a copy of some or all of the same material does not give you any rights to use it.\n\n   10. FUTURE REVISIONS OF THIS LICENSE\n\n   The Free Software Foundation may publish new, revised versions of the GNU Free Documentation License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. See http://www.gnu.org/copyleft/.\n\n   Each version of the License is given a distinguishing version number. If the Document specifies that a particular numbered version of this License \"or any later version\" applies to it, you have the option of following the terms and conditions either of that specified version or of any later version that has been published (not as a draft) by the Free Software Foundation. If the Document does not specify a version number of this License, you may choose any version ever published (not as a draft) by the Free Software Foundation. If the Document specifies that a proxy can decide which future versions of this License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Document.\n\n   11. RELICENSING\n\n   \"Massive Multiauthor Collaboration Site\" (or \"MMC Site\") means any World Wide Web server that publishes copyrightable works and also provides prominent facilities for anybody to edit those works. A public wiki that anybody can edit is an example of such a server. A \"Massive Multiauthor Collaboration\" (or \"MMC\") contained in the site means any set of copyrightable works thus published on the MMC site.\n\n   \"CC-BY-SA\" means the Creative Commons Attribution-Share Alike 3.0 license published by Creative Commons Corporation, a not-for-profit corporation with a principal place of business in San Francisco, California, as well as future copyleft versions of that license published by that same organization.\n\n   \"Incorporate\" means to publish or republish a Document, in whole or in part, as part of another Document.\n\n   An MMC is \"eligible for relicensing\" if it is licensed under this License, and if all works that were first published under this License somewhere other than this MMC, and subsequently incorporated in whole or in part into the MMC, (1) had no cover texts or invariant sections, and (2) were thus incorporated prior to November 1, 2008.\n\n   The operator of an MMC Site may republish an MMC contained in the site under CC-BY-SA on the same site at any time before August 1, 2009, provided the MMC is eligible for relicensing. ADDENDUM: How to use this License for your documents\n\nTo use this License in a document you have written, include a copy of the License in the document and put the following copyright and license notices just after the title page:\n\nCopyright (c) YEAR YOUR NAME. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copy of the license is included in the section entitled \"GNU Free Documentation License\".\n\nIf you have Invariant Sections, Front-Cover Texts and Back-Cover Texts, replace the \"with...Texts.\" line with this:\n\nwith the Invariant Sections being LIST THEIR TITLES, with the Front-Cover Texts being LIST, and with the Back-Cover Texts being LIST.\n\nIf you have Invariant Sections without Cover Texts, or some other combination of the three, merge those two alternatives to suit the situation.\n\nIf your document contains nontrivial examples of program code, we recommend releasing these examples in parallel under your choice of free software license, such as the GNU General Public License, to permit their use in free software."],"licenseIds":["GFDL-1.3-or-later","GFDL-1.3-only","GFDL-1.3"],"keywords":["3 3 november","3 november 2008","november 2008 copyright","2001 2002 2007","2002 2007 2008","2007 2008 free","2008 free software","the text the","text the publisher","the publisher means","publisher means any","that distributes copies","distributes copies of","the public a","public a section","distribute it is","license however if","permanently reinstated receipt","reinstated receipt of","copy of some","same material does","material does not","give you any","use it 10","it 10 future","for the document","the document 11","document 11 relicensing","11 relicensing massive","relicensing massive multiauthor","multiauthor collaboration site","collaboration site or","site or mmc","or mmc site","mmc site means","means any world","any world wide","wide web server","web server that","server that publishes","that publishes copyrightable","publishes copyrightable works","copyrightable works and","works and also","and also provides","also provides prominent","provides prominent facilities","prominent facilities for","facilities for anybody","for anybody to","anybody to edit","to edit those","edit those works","those works a","works a public","a public wiki","public wiki that","wiki that anybody","that anybody can","anybody can edit","can edit is","edit is an","such a server","a server a","server a massive","a massive multiauthor","multiauthor collaboration or","collaboration or mmc","or mmc contained","the site means","means any set","any set of","set of copyrightable","of copyrightable works","copyrightable works thus","works thus published","thus published on","published on the","on the mmc","the mmc site","mmc site cc","site cc by","by sa means","sa means the","means the creative","commons attribution share","attribution share alike","share alike 3","alike 3 0","0 license published","published by creative","commons corporation a","corporation a not","for profit corporation","profit corporation with","corporation with a","with a principal","a principal place","of business in","business in san","in san francisco","san francisco california","francisco california as","california as well","as future copyleft","future copyleft versions","copyleft versions of","that license published","published by that","by that same","that same organization","same organization incorporate","organization incorporate means","incorporate means to","means to publish","to publish or","publish or republish","or republish a","republish a document","a document in","document in whole","part as part","part of another","of another document","another document an","document an mmc","an mmc is","for relicensing if","relicensing if it","it is licensed","and if all","if all works","all works that","works that were","that were first","were first published","first published under","this license somewhere","license somewhere other","somewhere other than","than this mmc","this mmc and","mmc and subsequently","subsequently incorporated in","incorporated in whole","in part into","part into the","into the mmc","the mmc 1","mmc 1 had","1 had no","had no cover","no cover texts","texts or invariant","or invariant sections","sections and 2","and 2 were","2 were thus","were thus incorporated","thus incorporated prior","incorporated prior to","prior to november","to november 1","november 1 2008","1 2008 the","2008 the operator","operator of an","of an mmc","an mmc site","mmc site may","site may republish","may republish an","republish an mmc","an mmc contained","the site under","site under cc","under cc by","by sa on","sa on the","the same site","same site at","site at any","any time before","time before august","before august 1","august 1 2009","1 2009 provided","2009 provided the","provided the mmc","the mmc is","for relicensing addendum","relicensing addendum how","version 1 3 3","1 3 3 november","3 3 november 2008","3 november 2008 copyright","november 2008 copyright c","2008 copyright c 2000","2000 2001 2002 2007","2001 2002 2007 2008"]},{"licenseTexts":["GL2PS LICENSE Version 2, November 2003 Copyright (C) 2003, Christophe Geuzaine\n\nPermission to use, copy, and distribute this software and its documentation for any purpose with or without fee is hereby granted, provided that the copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation.\n\nPermission to modify and distribute modified versions of this software is granted, provided that:\n\n   1) the modifications are licensed under the same terms as this software;\n\n   2) you make available the source code of any modifications that you distribute, either on the same media as you distribute any executable or other form of this software, or via a mechanism generally accepted in the software development community for the electronic transfer of data.\n\nThis software is provided \"as is\" without express or implied warranty."],"licenseIds":["GL2PS"],"keywords":["gl2ps license version","version 2 november","2 november 2003","november 2003 copyright","2003 copyright c","c 2003 christophe","2003 christophe geuzaine","christophe geuzaine permission","geuzaine permission to","1 the modifications","software 2 you","2 you make","of data this","data this software","gl2ps license version 2","license version 2 november","version 2 november 2003","2 november 2003 copyright","november 2003 copyright c","2003 copyright c 2003","copyright c 2003 christophe","c 2003 christophe geuzaine","2003 christophe geuzaine permission","christophe geuzaine permission to","geuzaine permission to use","the copyright notice appear","permission to modify and","to modify and distribute","modify and distribute modified","granted provided that 1","that 1 the modifications","1 the modifications are","licensed under the same","terms as this software","as this software 2","this software 2 you","software 2 you make","2 you make available","you make available the","of any modifications that","other form of this","form of this software","this software or via","software or via a","transfer of data this","of data this software","data this software is","gl2ps license version 2 november","license version 2 november 2003","version 2 november 2003 copyright","2 november 2003 copyright c","november 2003 copyright c 2003","2003 copyright c 2003 christophe","copyright c 2003 christophe geuzaine","c 2003 christophe geuzaine permission","2003 christophe geuzaine permission to","christophe geuzaine permission to use","geuzaine permission to use copy","granted provided that the copyright","that the copyright notice appear","the copyright notice appear in","documentation permission to modify and","permission to modify and distribute","to modify and distribute modified","modify and distribute modified versions","versions of this software is","is granted provided that 1","granted provided that 1 the","provided that 1 the modifications","that 1 the modifications are","1 the modifications are licensed","are licensed under the same","licensed under the same terms","same terms as this software","terms as this software 2","as this software 2 you","this software 2 you make","software 2 you make available","2 you make available the","you make available the source","code of any modifications that","of any modifications that you","or other form of this","other form of this software","form of this software or","of this software or via","this software or via a","software or via a mechanism","electronic transfer of data this","transfer of data this software","of data this software is","data this software is provided"]},{"licenseTexts":["GNU GENERAL PUBLIC LICENSE\n\nVersion 1, February 1989\n\nCopyright (C) 1989 Free Software Foundation, Inc. 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n\nEveryone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.\n\nPreamble\n\nThe license agreements of most software companies try to keep users at the mercy of those companies. By contrast, our General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. The General Public License applies to the Free Software Foundation's software and to any other program whose authors commit to using it. You can use it for your programs, too.\n\nWhen we speak of free software, we are referring to freedom, not price. Specifically, the General Public License is designed to make sure that you have the freedom to give away or sell copies of free software, that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things.\n\nTo protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it.\n\nFor example, if you distribute copies of a such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must tell them their rights.\n\nWe protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software.\n\nAlso, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations.\n\nThe precise terms and conditions for copying, distribution and modification follow.\n\nGNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION\n\n   0. This License Agreement applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The \"Program\", below, refers to any such program or work, and a \"work based on the Program\" means either the Program or any work containing the Program or a portion of it, either verbatim or with modifications. Each licensee is addressed as \"you\".\n\n   1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this General Public License and to the absence of any warranty; and give any other recipients of the Program a copy of this General Public License along with the Program. You may charge a fee for the physical act of transferring a copy.\n\n   2. You may modify your copy or copies of the Program or any portion of it, and copy and distribute such modifications under the terms of Paragraph 1 above, provided that you also do the following:\n\n      a) cause the modified files to carry prominent notices stating that you changed the files and the date of any change; and\n\n      b) cause the whole of any work that you distribute or publish, that in whole or in part contains the Program or any part thereof, either with or without modifications, to be licensed at no charge to all third parties under the terms of this General Public License (except that you may choose to grant warranty protection to some or all third parties, at your option).\n\n      c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the simplest and most usual way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this General Public License.\n\n      d) You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee.\n\n   Mere aggregation of another independent work with the Program (or its derivative) on a volume of a storage or distribution medium does not bring the other work under the scope of these terms.\n\n   3. You may copy and distribute the Program (or a portion or derivative of it, under Paragraph 2) in object code or executable form under the terms of Paragraphs 1 and 2 above provided that you also do one of the following:\n\n      a) accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Paragraphs 1 and 2 above; or,\n\n      b) accompany it with a written offer, valid for at least three years, to give any third party free (except for a nominal charge for the cost of distribution) a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Paragraphs 1 and 2 above; or,\n\n      c) accompany it with the information you received as to where the corresponding source code may be obtained. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form alone.)\n\n   Source code for a work means the preferred form of the work for making modifications to it. For an executable file, complete source code means all the source code for all modules it contains; but, as a special exception, it need not include source code for modules which are standard libraries that accompany the operating system on which the executable file runs, or for standard header files or definitions files that accompany that operating system.\n\n   4. You may not copy, modify, sublicense, distribute or transfer the Program except as expressly provided under this General Public License. Any attempt otherwise to copy, modify, sublicense, distribute or transfer the Program is void, and will automatically terminate your rights to use the Program under this License. However, parties who have received copies, or rights to use copies, from you under this General Public License will not have their licenses terminated so long as such parties remain in full compliance.\n\n   5. By copying, distributing or modifying the Program (or any work based on the Program) you indicate your acceptance of this license to do so, and all its terms and conditions.\n\n   6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein.\n\n   7. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.\n\n   Each version is given a distinguishing version number. If the Program specifies a version number of the license which applies to it and \"any later version\", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of the license, you may choose any version ever published by the Free Software Foundation.\n\n   8. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally.\n\n   \n\n   NO WARRANTY 9.\n\n   BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM \"AS IS\" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.\n\n   10. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS\n\nAppendix: How to Apply These Terms to Your New Programs\n\nIf you develop a new program, and you want it to be of the greatest possible use to humanity, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms.\n\nTo do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the \"copyright\" line and a pointer to where the full notice is found.\n\n\u003cone line to give the program's name and a brief idea of what it does.\u003e\n\nCopyright (C) 19yy \u003cname of author\u003e\n\nThis program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 1, or (at your option) any later version.\n\nThis program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.\n\nYou should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.\n\nAlso add information on how to contact you by electronic and paper mail.\n\nIf the program is interactive, make it output a short notice like this when it starts in an interactive mode:\n\nGnomovision version 69, Copyright (C) 19xx name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details.\n\nThe hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program.\n\nYou should also get your employer (if you work as a programmer) or your school, if any, to sign a \"copyright disclaimer\" for the program, if necessary. Here a sample; alter the names:\n\nYoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (a program to direct compilers to make passes at assemblers) written by James Hacker.\n\n\u003csignature of Ty Coon\u003e, 1 April 1989 Ty Coon, President of Vice\n\nThat's all there is to it!"],"licenseIds":["GPL-1.0-or-later","GPL-1.0-only","GPL-1.0+","GPL-1.0"],"keywords":["version 1 february","1 february 1989","february 1989 copyright","c 1989 free","1989 free software","preamble the license","software companies try","companies try to","try to keep","to keep users","keep users at","users at the","its users the","users the general","using it you","for your programs","not price specifically","price specifically the","specifically the general","freedom to give","away or sell","of a such","a such a","authors reputations the","reputations the precise","modification follow gnu","follow gnu general","with modifications each","modifications each licensee","as you 1","you 1 you","to this general","a copy 2","copy 2 you","part contains the","part thereof either","thereof either with","without modifications to","modifications to be","public license except","license except that","to grant warranty","grant warranty protection","option c if","in the simplest","the simplest and","simplest and most","and most usual","most usual way","usual way to","a fee mere","fee mere aggregation","of another independent","another independent work","independent work with","its derivative on","derivative on a","scope of these","these terms 3","terms 3 you","third party free","party free except","free except for","except for a","for a nominal","nominal charge for","for the cost","of distribution a","above or c","as to where","where the corresponding","be obtained this","obtained this alternative","executable form alone","form alone source","alone source code","it contains but","contains but as","but as a","special exception it","exception it need","it need not","for modules which","modules which are","which are standard","are standard libraries","standard libraries that","libraries that accompany","that accompany the","file runs or","runs or for","or for standard","for standard header","standard header files","header files or","files or definitions","or definitions files","definitions files that","files that accompany","that accompany that","accompany that operating","that operating system","operating system 4","system 4 you","public license any","or rights to","to use copies","use copies from","copies from you","compliance 5 by","5 by copying","conditions 6 each","herein 7 the","7 the free","software foundation 8","foundation 8 if","8 if you","no warranty 9","warranty 9 because","9 because the","or correction 10","correction 10 in","10 in no","use to humanity","to humanity the","humanity the best","copyright c 19yy","c 19yy name","19yy name of","version 1 or","1 or at","foundation inc 675","inc 675 mass","675 mass ave","mass ave cambridge","ave cambridge ma","cambridge ma 02139","ma 02139 usa","02139 usa also","copyright c 19xx","c 19xx name","19xx name of","necessary here a","here a sample","program gnomovision a","gnomovision a program","program to direct","to direct compilers","direct compilers to","compilers to make","to make passes","make passes at","passes at assemblers","at assemblers written","assemblers written by","license version 1 february","version 1 february 1989","1 february 1989 copyright","february 1989 copyright c","copyright c 1989 free","c 1989 free software","1989 free software foundation","allowed preamble the license","preamble the license agreements","most software companies try","software companies try to","companies try to keep","try to keep users","to keep users at","keep users at the","users at the mercy","all its users the","its users the general","users the general public","applies to the free","to using it you","using it you can","it for your programs","for your programs too","freedom not price specifically","not price specifically the","price specifically the general","specifically the general public","the freedom to give","freedom to give away","to give away or","give away or sell","away or sell copies","sell copies of free","free software that you","software that you receive","distribute copies of a","copies of a such","of a such a","a such a program","them their rights we","original authors reputations the","authors reputations the precise","reputations the precise terms","and modification follow gnu"]},{"licenseTexts":["GNU GENERAL PUBLIC LICENSE\n\nVersion 2, June 1991\n\nCopyright (C) 1989, 1991 Free Software Foundation, Inc.\n\n51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA\n\nEveryone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.\n\nPreamble\n\nThe licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Lesser General Public License instead.) You can apply it to your programs, too.\n\nWhen we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things.\n\nTo protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it.\n\nFor example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights.\n\nWe protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software.\n\nAlso, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations.\n\nFinally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all.\n\nThe precise terms and conditions for copying, distribution and modification follow.\n\nTERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION\n\n   0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The \"Program\", below, refers to any such program or work, and a \"work based on the Program\" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term \"modification\".) Each licensee is addressed as \"you\".\n\n   Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does.\n\n   1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program.\n\n   You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee.\n\n   2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions:\n\n      a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change.\n\n      b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License.\n\n      c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.)\n\n   These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it.\n\n   Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program.\n\n   In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License.\n\n   3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following:\n\n      a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or,\n\n      b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or,\n\n      c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.)\n\n   The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable.\n\n   If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code.\n\n   4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance.\n\n   5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it.\n\n   6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License.\n\n   7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program.\n\n   If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances.\n\n   It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice.\n\n   This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License.\n\n   8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License.\n\n   9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.\n\n   Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and \"any later version\", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation.\n\n   10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally.\n\n   NO WARRANTY\n\n   11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM \"AS IS\" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.\n\n   12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS\n\nHow to Apply These Terms to Your New Programs\n\nIf you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms.\n\nTo do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the \"copyright\" line and a pointer to where the full notice is found.\n\n\u003cone line to give the program's name and an idea of what it does.\u003e\n\nCopyright (C) \u003cyyyy\u003e \u003cname of author\u003e\n\nThis program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.\n\nThis program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.\n\nYou should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n\nAlso add information on how to contact you by electronic and paper mail.\n\nIf the program is interactive, make it output a short notice like this when it starts in an interactive mode:\n\nGnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details.\n\nThe hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program.\n\nYou should also get your employer (if you work as a programmer) or your school, if any, to sign a \"copyright disclaimer\" for the program, if necessary. Here is a sample; alter the names:\n\nYoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker.\n\n\u003c signature of Ty Coon \u003e , 1 April 1989 Ty Coon, President of Vice"],"licenseIds":["GPL-2.0+"],"keywords":null},{"licenseTexts":["GNU GENERAL PUBLIC LICENSE\n\nVersion 2, June 1991\n\nCopyright (C) 1989, 1991 Free Software Foundation, Inc. \n\n51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA\n\nEveryone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.\n\nPreamble\n\nThe licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Lesser General Public License instead.) You can apply it to your programs, too.\n\nWhen we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things.\n\nTo protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it.\n\nFor example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights.\n\nWe protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software.\n\nAlso, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations.\n\nFinally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all.\n\nThe precise terms and conditions for copying, distribution and modification follow.\n\nTERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION\n\n   0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The \"Program\", below, refers to any such program or work, and a \"work based on the Program\" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term \"modification\".) Each licensee is addressed as \"you\".\n\n   Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does.\n\n   1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program.\n\n   You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee.\n\n   2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions:\n\n      a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change.\n\n      b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License.\n\n      c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.)\n\n   These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it.\n\n   Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program.\n\n   In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License.\n\n   3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following:\n\n      a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or,\n\n      b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or,\n\n      c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.)\n\n   The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable.\n\n   If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code.\n\n   4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance.\n\n   5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it.\n\n   6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License.\n\n   7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program.\n\n   If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances.\n\n   It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice.\n\n   This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License.\n\n   8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License.\n\n   9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.\n\n   Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and \"any later version\", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation.\n\n   10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally.\n\n   NO WARRANTY\n\n   11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM \"AS IS\" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.\n\n   12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS\n\nHow to Apply These Terms to Your New Programs\n\nIf you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms.\n\nTo do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the \"copyright\" line and a pointer to where the full notice is found.\n\n\u003cone line to give the program's name and an idea of what it does.\u003e\n\nCopyright (C)\u003c yyyy\u003e \u003cname of author\u003e\n\nThis program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.\n\nThis program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.\n\nYou should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n\nAlso add information on how to contact you by electronic and paper mail.\n\nIf the program is interactive, make it output a short notice like this when it starts in an interactive mode:\n\nGnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details.\n\nThe hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program.\n\nYou should also get your employer (if you work as a programmer) or your school, if any, to sign a \"copyright disclaimer\" for the program, if necessary. Here is a sample; alter the names:\n\nYoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker.\n\n\u003csignature of Ty Coon \u003e, 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License."],"licenseIds":["GPL-2.0-or-later","GPL-2.0-only","GPL-2.0"],"keywords":["of vice this","vice this general","president of vice this","of vice this general","vice this general public","coon president of vice this","president of vice this general","of vice this general public","vice this general public license","this general public license does"]},{"licenseTexts":["insert GPL v2 license text here\n\nGCC Linking Exception\n\nIn addition to the permissions in the GNU General Public License, the Free Software Foundation gives you unlimited permission to link the compiled version of this file into combinations with other programs, and to distribute those combinations without any restriction coming from the use of this file. (The General Public License restrictions do apply in other respects; for example, they cover modification of the file, and distribution when not linked into a combine executable."],"licenseIds":["GPL-2.0-with-GCC-exception"],"keywords":["here gcc linking","gcc linking exception","linking exception in","exception in addition","the permissions in","permissions in the","in the gnu","foundation gives you","to link the","link the compiled","the compiled version","compiled version of","this file into","file into combinations","into combinations with","other programs and","programs and to","to distribute those","distribute those combinations","those combinations without","combinations without any","without any restriction","any restriction coming","restriction coming from","coming from the","file the general","public license restrictions","license restrictions do","restrictions do apply","do apply in","other respects for","respects for example","for example they","example they cover","they cover modification","cover modification of","the file and","file and distribution","and distribution when","distribution when not","when not linked","not linked into","linked into a","into a combine","a combine executable","license text here gcc","text here gcc linking","here gcc linking exception","gcc linking exception in","linking exception in addition","exception in addition to","addition to the permissions","to the permissions in","the permissions in the","permissions in the gnu","in the gnu general","software foundation gives you","foundation gives you unlimited","unlimited permission to link","permission to link the","to link the compiled","link the compiled version","the compiled version of","compiled version of this","of this file into","this file into combinations","file into combinations with","into combinations with other","combinations with other programs","with other programs and","other programs and to","programs and to distribute","and to distribute those","to distribute those combinations","distribute those combinations without","those combinations without any","combinations without any restriction","without any restriction coming","any restriction coming from","restriction coming from the","coming from the use","use of this file","of this file the","this file the general","file the general public","general public license restrictions","public license restrictions do","license restrictions do apply","restrictions do apply in","do apply in other","apply in other respects","in other respects for","other respects for example","respects for example they","for example they cover","example they cover modification","they cover modification of","cover modification of the","of the file and","the file and distribution","file and distribution when","and distribution when not","distribution when not linked","when not linked into","not linked into a","linked into a combine","into a combine executable","v2 license text here gcc","license text here gcc linking","text here gcc linking exception","here gcc linking exception in","gcc linking exception in addition","linking exception in addition to","exception in addition to the","in addition to the permissions","addition to the permissions in","to the permissions in the","the permissions in the gnu","permissions in the gnu general","in the gnu general public","free software foundation gives you","software foundation gives you unlimited","foundation gives you unlimited permission","you unlimited permission to link","unlimited permission to link the","permission to link the compiled","to link the compiled version","link the compiled version of","the compiled version of this","compiled version of this file","version of this file into","of this file into combinations","this file into combinations with","file into combinations with other","into combinations with other programs","combinations with other programs and","with other programs and to","other programs and to distribute","programs and to distribute those","and to distribute those combinations","to distribute those combinations without","distribute those combinations without any","those combinations without any restriction","combinations without any restriction coming","without any restriction coming from","any restriction coming from the","restriction coming from the use","coming from the use of","the use of this file","use of this file the","of this file the general","this file the general public","file the general public license","the general public license restrictions","general public license restrictions do","public license restrictions do apply","license restrictions do apply in","restrictions do apply in other","do apply in other respects","apply in other respects for","in other respects for example","other respects for example they","respects for example they cover","for example they cover modification","example they cover modification of","they cover modification of the","cover modification of the file","modification of the file and","of the file and distribution","the file and distribution when","file and distribution when not","and distribution when not linked","distribution when not linked into","when not linked into a","not linked into a combine","linked into a combine executable"]},{"licenseTexts":["insert GPL v2 license text here\n\nAutoconf Exception\n\nAs a special exception, the Free Software Foundation gives unlimited permission to copy, distribute and modify the configure scripts that are the output of Autoconf. You need not follow the terms of the GNU General Public License when using or distributing such scripts, even though portions of the text of Autoconf appear in them. The GNU General Public License (GPL) does govern all other use of the material that constitutes the Autoconf program.\n\nCertain portions of the Autoconf source text are designed to be copied (in certain cases, depending on the input) into the output of Autoconf. We call these the \"data\" portions. The rest of the Autoconf source text consists of comments plus executable code that decides which of the data portions to output in any given case. We call these comments and executable code the \"non-data\" portions. Autoconf never copies any of the non-data portions into its output.\n\nThis special exception to the GPL applies to versions of Autoconf released by the Free Software Foundation. When you make and distribute a modified version of Autoconf, you may extend this special exception to the GPL to apply to your modified version as well, *unless* your modified version has the potential to copy into its output some of the text that was the non-data portion of the version that you started with. (In other words, unless your change moves or copies text from the non-data portions to the data portions.) If your modification has such potential, you must delete any notice of this special exception to the GPL from your modified version."],"licenseIds":["GPL-2.0-with-autoconf-exception"],"keywords":["here autoconf exception","autoconf exception as","exception the free","modify the configure","the configure scripts","configure scripts that","scripts that are","that are the","are the output","autoconf you need","follow the terms","public license when","license when using","when using or","using or distributing","or distributing such","distributing such scripts","such scripts even","scripts even though","even though portions","though portions of","text of autoconf","of autoconf appear","autoconf appear in","appear in them","in them the","them the gnu","license gpl does","gpl does govern","does govern all","govern all other","all other use","other use of","the material that","material that constitutes","that constitutes the","constitutes the autoconf","the autoconf program","autoconf program certain","program certain portions","certain portions of","source text are","text are designed","designed to be","to be copied","be copied in","copied in certain","certain cases depending","cases depending on","on the input","the input into","input into the","into the output","of autoconf we","autoconf we call","call these the","these the data","data portions the","portions the rest","source text consists","text consists of","consists of comments","of comments plus","comments plus executable","plus executable code","executable code that","code that decides","that decides which","decides which of","which of the","portions to output","to output in","output in any","in any given","any given case","given case we","case we call","call these comments","these comments and","comments and executable","and executable code","code the non","data portions autoconf","portions autoconf never","autoconf never copies","never copies any","copies any of","data portions into","portions into its","its output this","output this special","the gpl applies","applies to versions","to versions of","versions of autoconf","of autoconf released","autoconf released by","software foundation when","foundation when you","when you make","autoconf you may","extend this special","gpl to apply","to your modified","version as well","as well unless","well unless your","version has the","has the potential","the potential to","potential to copy","to copy into","copy into its","its output some","output some of","the text that","text that was","that was the","was the non","non data portion","data portion of","that you started","you started with","started with in","with in other","other words unless","words unless your","unless your change","your change moves","change moves or","moves or copies","or copies text","copies text from","from the non","portions to the","data portions if","portions if your","your modification has","modification has such","has such potential","such potential you","potential you must","must delete any","delete any notice","any notice of","notice of this","of this special","the gpl from","gpl from your","license text here autoconf","text here autoconf exception","here autoconf exception as","autoconf exception as a","special exception the free","exception the free software","distribute and modify the","and modify the configure","modify the configure scripts","the configure scripts that","configure scripts that are","scripts that are the","that are the output","are the output of","output of autoconf you","of autoconf you need","autoconf you need not","you need not follow","not follow the terms","follow the terms of","general public license when","public license when using","license when using or","when using or distributing","using or distributing such","or distributing such scripts","distributing such scripts even","such scripts even though","scripts even though portions","even though portions of","though portions of the","portions of the text","the text of autoconf","text of autoconf appear","of autoconf appear in","autoconf appear in them","appear in them the","in them the gnu","them the gnu general","public license gpl does","license gpl does govern","gpl does govern all","does govern all other","govern all other use","all other use of","other use of the","use of the material","of the material that","the material that constitutes","material that constitutes the","that constitutes the autoconf"]},{"licenseTexts":["Bison Exception\n\nAs a special exception, you may create a larger work that contains part or all of the Bison parser skeleton and distribute that work under terms of your choice, so long as that work isn't itself a parser generator using the skeleton or a modified version thereof as a parser skeleton. Alternatively, if you modify or redistribute the parser skeleton itself, you may (at your option) remove this special exception, which will cause the skeleton and the resulting Bison output files to be licensed under the GNU General Public License without this special exception.\n\nThis special exception was added by the Free Software Foundation in version 2.2 of Bison."],"licenseIds":["GPL-2.0-with-bison-exception"],"keywords":["bison exception as","special exception you","exception you may","larger work that","that contains part","contains part or","of the bison","the bison parser","bison parser skeleton","parser skeleton and","skeleton and distribute","as that work","that work isn","work isn t","isn t itself","t itself a","itself a parser","a parser generator","parser generator using","generator using the","using the skeleton","the skeleton or","skeleton or a","modified version thereof","thereof as a","as a parser","a parser skeleton","parser skeleton alternatively","skeleton alternatively if","alternatively if you","you modify or","redistribute the parser","the parser skeleton","parser skeleton itself","skeleton itself you","option remove this","remove this special","special exception which","exception which will","which will cause","will cause the","cause the skeleton","the skeleton and","skeleton and the","the resulting bison","resulting bison output","bison output files","output files to","files to be","license without this","without this special","special exception this","exception this special","special exception was","exception was added","software foundation in","foundation in version","in version 2","2 of bison","bison exception as a","a special exception you","special exception you may","exception you may create","a larger work that","larger work that contains","work that contains part","that contains part or","contains part or all","all of the bison","of the bison parser","the bison parser skeleton","bison parser skeleton and","parser skeleton and distribute","skeleton and distribute that","long as that work","as that work isn","that work isn t","work isn t itself","isn t itself a","t itself a parser","itself a parser generator","a parser generator using","parser generator using the","generator using the skeleton","using the skeleton or","the skeleton or a","skeleton or a modified","a modified version thereof","modified version thereof as","version thereof as a","thereof as a parser","as a parser skeleton","a parser skeleton alternatively","parser skeleton alternatively if","skeleton alternatively if you","alternatively if you modify","if you modify or","you modify or redistribute","modify or redistribute the","or redistribute the parser","redistribute the parser skeleton","the parser skeleton itself","parser skeleton itself you","skeleton itself you may","itself you may at","your option remove this","option remove this special","remove this special exception","this special exception which","special exception which will","exception which will cause","which will cause the","will cause the skeleton","cause the skeleton and","the skeleton and the","skeleton and the resulting","and the resulting bison","the resulting bison output","resulting bison output files","bison output files to","output files to be","files to be licensed","to be licensed under","general public license without","public license without this","license without this special","without this special exception","this special exception this","special exception this special","exception this special exception","this special exception was","special exception was added","exception was added by","was added by the","added by the free","free software foundation in","software foundation in version","foundation in version 2","in version 2 2","version 2 2 of","2 2 of bison","bison exception as a special","as a special exception you","a special exception you may","special exception you may create","exception you may create a","create a larger work that","a larger work that contains","larger work that contains part","work that contains part or","that contains part or all","contains part or all of","or all of the bison","all of the bison parser","of the bison parser skeleton","the bison parser skeleton and","bison parser skeleton and distribute","parser skeleton and distribute that","skeleton and distribute that work","choice so long as that","so long as that work","long as that work isn","as that work isn t","that work isn t itself","work isn t itself a","isn t itself a parser","t itself a parser generator","itself a parser generator using","a parser generator using the","parser generator using the skeleton","generator using the skeleton or","using the skeleton or a","the skeleton or a modified","skeleton or a modified version","or a modified version thereof","a modified version thereof as","modified version thereof as a","version thereof as a parser","thereof as a parser skeleton","as a parser skeleton alternatively","a parser skeleton alternatively if","parser skeleton alternatively if you","skeleton alternatively if you modify","alternatively if you modify or","if you modify or redistribute","you modify or redistribute the","modify or redistribute the parser","or redistribute the parser skeleton","redistribute the parser skeleton itself","the parser skeleton itself you","parser skeleton itself you may","skeleton itself you may at","itself you may at your","at your option remove this","your option remove this special","option remove this special exception","remove this special exception which","this special exception which will","special exception which will cause","exception which will cause the"]},{"licenseTexts":["insert GPL v2 license text here\n\nClass Path Exception\n\nLinking this library statically or dynamically with other modules is making a combined work based on this library. Thus, the terms and conditions of the GNU General Public License cover the whole combination.\n\nAs a special exception, the copyright holders of this library give you permission to link this library with independent modules to produce an executable, regardless of the license terms of these independent modules, and to copy and distribute the resulting executable under terms of your choice, provided that you also meet, for each linked independent module, the terms and conditions of the license of that module. An independent module is a module which is not derived from or based on this library. If you modify this library, you may extend this exception to your version of the library, but you are not obligated to do so. If you do not wish to do so, delete this exception statement from your version."],"licenseIds":["GPL-2.0-with-classpath-exception"],"keywords":["text here class","here class path","class path exception","path exception linking","exception linking this","linking this library","this library statically","library statically or","or dynamically with","dynamically with other","with other modules","other modules is","modules is making","is making a","making a combined","this library thus","library thus the","thus the terms","public license cover","license cover the","cover the whole","the whole combination","whole combination as","combination as a","library give you","give you permission","to link this","link this library","this library with","independent modules to","modules to produce","to produce an","produce an executable","an executable regardless","executable regardless of","license terms of","terms of these","of these independent","these independent modules","independent modules and","modules and to","and to copy","resulting executable under","executable under terms","also meet for","meet for each","for each linked","each linked independent","linked independent module","independent module the","license of that","of that module","that module an","module an independent","independent module is","module is a","is a module","a module which","module which is","is not derived","modify this library","this library you","library but you","license text here class","text here class path","here class path exception","class path exception linking","path exception linking this","exception linking this library","linking this library statically","this library statically or","library statically or dynamically","statically or dynamically with","or dynamically with other","dynamically with other modules","with other modules is","other modules is making","modules is making a","is making a combined","making a combined work","a combined work based","on this library thus","this library thus the","library thus the terms","thus the terms and","conditions of the gnu","general public license cover","public license cover the","license cover the whole","cover the whole combination","the whole combination as","whole combination as a","combination as a special","this library give you","library give you permission","give you permission to","you permission to link","permission to link this","to link this library","link this library with","this library with independent","with independent modules to","independent modules to produce","modules to produce an","to produce an executable","produce an executable regardless","an executable regardless of","executable regardless of the","of the license terms","the license terms of","license terms of these","terms of these independent","of these independent modules","these independent modules and","independent modules and to","modules and to copy","and to copy and","distribute the resulting executable","the resulting executable under","resulting executable under terms","executable under terms of","you also meet for","also meet for each","meet for each linked","for each linked independent","each linked independent module","linked independent module the","independent module the terms","the license of that","license of that module","of that module an","that module an independent","module an independent module","an independent module is","independent module is a","module is a module","is a module which","a module which is","module which is not","which is not derived","is not derived from","not derived from or","or based on this","on this library if","this library if you","library if you modify","you modify this library","modify this library you","this library you may","library you may extend","the library but you","library but you are","v2 license text here class","license text here class path","text here class path exception","here class path exception linking","class path exception linking this","path exception linking this library","exception linking this library statically","linking this library statically or","this library statically or dynamically","library statically or dynamically with","statically or dynamically with other","or dynamically with other modules","dynamically with other modules is","with other modules is making","other modules is making a","modules is making a combined","is making a combined work","making a combined work based","a combined work based on","combined work based on this","work based on this library","based on this library thus","on this library thus the","this library thus the terms","library thus the terms and","thus the terms and conditions","and conditions of the gnu","conditions of the gnu general","gnu general public license cover","general public license cover the","public license cover the whole","license cover the whole combination","cover the whole combination as","the whole combination as a","whole combination as a special","combination as a special exception","of this library give you","this library give you permission","library give you permission to","give you permission to link","you permission to link this","permission to link this library","to link this library with","link this library with independent","this library with independent modules","library with independent modules to","with independent modules to produce","independent modules to produce an"]},{"licenseTexts":["insert GPL v2 license text here\n\nFont Exception\n\nAs a special exception, if you create a document which uses this font, and embed this font or unaltered portions of this font into the document, this font does not by itself cause the resulting document to be covered by the GNU General Public License. This exception does not however invalidate any other reasons why the document might be covered by the GNU General Public License. If you modify this font, you may extend this exception to your version of the font, but you are not obligated to do so. If you do not wish to do so, delete this exception statement from your version."],"licenseIds":["GPL-2.0-with-font-exception"],"keywords":["text here font","here font exception","font exception as","exception if you","create a document","a document which","document which uses","which uses this","uses this font","this font and","font and embed","and embed this","embed this font","this font or","font or unaltered","or unaltered portions","unaltered portions of","of this font","this font into","font into the","into the document","the document this","document this font","this font does","font does not","the resulting document","resulting document to","does not however","not however invalidate","however invalidate any","reasons why the","why the document","the document might","document might be","modify this font","this font you","font you may","the font but","font but you","license text here font","text here font exception","here font exception as","font exception as a","special exception if you","exception if you create","you create a document","create a document which","a document which uses","document which uses this","which uses this font","uses this font and","this font and embed","font and embed this","and embed this font","embed this font or","this font or unaltered","font or unaltered portions","or unaltered portions of","unaltered portions of this","portions of this font","of this font into","this font into the","font into the document","into the document this","the document this font","document this font does","this font does not","font does not by","cause the resulting document","the resulting document to","resulting document to be","document to be covered","exception does not however","does not however invalidate","not however invalidate any","however invalidate any other","other reasons why the","reasons why the document","why the document might","the document might be","document might be covered","general public license if","public license if you","you modify this font","modify this font you","this font you may","font you may extend","of the font but","the font but you","font but you are","v2 license text here font","license text here font exception","text here font exception as","here font exception as a","font exception as a special","a special exception if you","special exception if you create","exception if you create a","if you create a document","you create a document which","create a document which uses","a document which uses this","document which uses this font","which uses this font and","uses this font and embed","this font and embed this","font and embed this font","and embed this font or","embed this font or unaltered","this font or unaltered portions","font or unaltered portions of","or unaltered portions of this","unaltered portions of this font","portions of this font into","of this font into the","this font into the document","font into the document this","into the document this font","the document this font does","document this font does not","this font does not by","font does not by itself","itself cause the resulting document","cause the resulting document to","the resulting document to be","resulting document to be covered","document to be covered by","this exception does not however","exception does not however invalidate","does not however invalidate any","not however invalidate any other","however invalidate any other reasons","any other reasons why the","other reasons why the document","reasons why the document might","why the document might be","the document might be covered","document might be covered by","gnu general public license if","general public license if you","public license if you modify","license if you modify this","if you modify this font","you modify this font you","modify this font you may","this font you may extend","font you may extend this","your version of the font","version of the font but","of the font but you","the font but you are","font but you are not"]},{"licenseTexts":["GNU GENERAL PUBLIC LICENSE\n\nVersion 3, 29 June 2007\n\nCopyright © 2007 Free Software Foundation, Inc. \u003chttps://fsf.org/\u003e\n\nEveryone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.\n\nPreamble\n\nThe GNU General Public License is a free, copyleft license for software and other kinds of works.\n\nThe licenses for most software and other practical works are designed to take away your freedom to share and change the works. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users. We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors. You can apply it to your programs, too.\n\nWhen we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things.\n\nTo protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights. Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others.\n\nFor example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights.\n\nDevelopers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it.\n\nFor the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software. For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions.\n\nSome devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so. This is fundamentally incompatible with the aim of protecting users' freedom to change the software. The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable. Therefore, we have designed this version of the GPL to prohibit the practice for those products. If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users.\n\nFinally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary. To prevent this, the GPL assures that patents cannot be used to render the program non-free.\n\nThe precise terms and conditions for copying, distribution and modification follow.\n\nTERMS AND CONDITIONS\n\n   0. Definitions.\n\n   \"This License\" refers to version 3 of the GNU General Public License.\n\n   \"Copyright\" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks.\n\n   \"The Program\" refers to any copyrightable work licensed under this License. Each licensee is addressed as \"you\". \"Licensees\" and \"recipients\" may be individuals or organizations.\n\n   To \"modify\" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy. The resulting work is called a \"modified version\" of the earlier work or a work \"based on\" the earlier work.\n\n   A \"covered work\" means either the unmodified Program or a work based on the Program.\n\n   To \"propagate\" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy. Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well.\n\n   To \"convey\" a work means any kind of propagation that enables other parties to make or receive copies. Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying.\n\n   An interactive user interface displays \"Appropriate Legal Notices\" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License. If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion.\n\n   1. Source Code.\n\n   The \"source code\" for a work means the preferred form of the work for making modifications to it. \"Object code\" means any non-source form of a work.\n\n   A \"Standard Interface\" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language.\n\n   The \"System Libraries\" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form. A \"Major Component\", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it.\n\n   The \"Corresponding Source\" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities. However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work. For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work.\n\n   The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source.\n\n   The Corresponding Source for a work in source code form is that same work.\n\n   2. Basic Permissions.\n\n   All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met. This License explicitly affirms your unlimited permission to run the unmodified Program. The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work. This License acknowledges your rights of fair use or other equivalent, as provided by copyright law.\n\n   You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force. You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright. Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you.\n\n   Conveying under any other circumstances is permitted solely under the conditions stated below. Sublicensing is not allowed; section 10 makes it unnecessary.\n\n   3. Protecting Users' Legal Rights From Anti-Circumvention Law.\n\n   No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures.\n\n   When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures.\n\n   4. Conveying Verbatim Copies.\n\n   You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program.\n\n   You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee.\n\n   5. Conveying Modified Source Versions.\n\n   You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions:\n\n      a) The work must carry prominent notices stating that you modified it, and giving a relevant date.\n\n      b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7. This requirement modifies the requirement in section 4 to \"keep intact all notices\".\n\n      c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy. This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged. This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it.\n\n      d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so.\n\n   A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an \"aggregate\" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit. Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate.\n\n   6. Conveying Non-Source Forms.\n\n   You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways:\n\n      a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange.\n\n      b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge.\n\n      c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source. This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b.\n\n      d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge. You need not require recipients to copy the Corresponding Source along with the object code. If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source. Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements.\n\n      e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d.\n\n   A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work.\n\n   A \"User Product\" is either (1) a \"consumer product\", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling. In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage. For a particular product received by a particular user, \"normally used\" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product. A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product.\n\n   \"Installation Information\" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source. The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made.\n\n   If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information. But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM).\n\n   The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed. Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network.\n\n   Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying.\n\n   7. Additional Terms.\n\n   \"Additional permissions\" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law. If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions.\n\n   When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it. (Additional permissions may be written to require their own removal in certain cases when you modify the work.) You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission.\n\n   Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms:\n\n      a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or\n\n      b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or\n\n      c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or\n\n      d) Limiting the use for publicity purposes of names of licensors or authors of the material; or\n\n      e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or\n\n      f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors.\n\n   All other non-permissive additional terms are considered \"further restrictions\" within the meaning of section 10. If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term. If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying.\n\n   If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms.\n\n   Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way.\n\n   8. Termination.\n\n   You may not propagate or modify a covered work except as expressly provided under this License. Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11).\n\n   However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation.\n\n   Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice.\n\n   Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License. If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10.\n\n   9. Acceptance Not Required for Having Copies.\n\n   You are not required to accept this License in order to receive or run a copy of the Program. Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance. However, nothing other than this License grants you permission to propagate or modify any covered work. These actions infringe copyright if you do not accept this License. Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so.\n\n   10. Automatic Licensing of Downstream Recipients.\n\n   Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License. You are not responsible for enforcing compliance by third parties with this License.\n\n   An \"entity transaction\" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations. If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts.\n\n   You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License. For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it.\n\n   11. Patents.\n\n   A \"contributor\" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based. The work thus licensed is called the contributor's \"contributor version\".\n\n   A contributor's \"essential patent claims\" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version. For purposes of this definition, \"control\" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License.\n\n   Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version.\n\n   In the following three paragraphs, a \"patent license\" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement). To \"grant\" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party.\n\n   If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients. \"Knowingly relying\" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid.\n\n   If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it.\n\n   A patent license is \"discriminatory\" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License. You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007.\n\n   Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law.\n\n   12. No Surrender of Others' Freedom.\n\n   If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all. For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program.\n\n   13. Use with the GNU Affero General Public License.\n\n   Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the resulting work. The terms of this License will continue to apply to the part which is the covered work, but the special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such.\n\n   14. Revised Versions of this License.\n\n   The Free Software Foundation may publish revised and/or new versions of the GNU General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.\n\n   Each version is given a distinguishing version number. If the Program specifies that a certain numbered version of the GNU General Public License \"or any later version\" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of the GNU General Public License, you may choose any version ever published by the Free Software Foundation.\n\n   If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program.\n\n   Later license versions may give you additional or different permissions. However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version.\n\n   15. Disclaimer of Warranty.\n\n   THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM \"AS IS\" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.\n\n   16. Limitation of Liability.\n\n   IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\n   17. Interpretation of Sections 15 and 16.\n\nIf the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee. END OF TERMS AND CONDITIONS\n\nHow to Apply These Terms to Your New Programs\n\nIf you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms.\n\nTo do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the \"copyright\" line and a pointer to where the full notice is found.\n\n\u003cone line to give the program's name and a brief idea of what it does.\u003e\n\nCopyright (C) \u003cyear\u003e \u003cname of author\u003e\n\nThis program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.\n\nThis program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.\n\nYou should have received a copy of the GNU General Public License along with this program. If not, see \u003chttps://www.gnu.org/licenses/\u003e.\n\nAlso add information on how to contact you by electronic and paper mail.\n\nIf the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode:\n\n\u003cprogram\u003e Copyright (C) \u003cyear\u003e \u003cname of author\u003e\n\nThis program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.\n\nThis is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details.\n\nThe hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, your program's commands might be different; for a GUI interface, you would use an \"about box\".\n\nYou should also get your employer (if you work as a programmer) or school, if any, to sign a \"copyright disclaimer\" for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see \u003chttps://www.gnu.org/licenses/\u003e.\n\nThe GNU General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. But first, please read \u003chttps://www.gnu.org/ licenses /why-not-lgpl.html\u003e."],"licenseIds":["GPL-3.0-or-later","GPL-3.0-only","GPL-3.0+","GPL-3.0"],"keywords":["copyright 2007 free","of works the","works the licenses","its users we","users we the","we the free","software foundation use","foundation use the","license for most","for most of","most of our","of our software","our software it","software it applies","it applies also","applies also to","also to any","any other work","other work released","work released this","released this way","this way by","way by its","by its authors","its authors you","authors you can","need to prevent","to prevent others","prevent others from","others from denying","from denying you","denying you these","rights or asking","or asking you","asking you to","the rights therefore","rights therefore you","therefore you have","you have certain","have certain responsibilities","certain responsibilities if","responsibilities if you","modify it responsibilities","it responsibilities to","responsibilities to respect","to respect the","respect the freedom","freedom of others","others for example","must pass on","pass on to","on to the","the recipients the","recipients the same","freedoms that you","you received you","received you must","their rights developers","rights developers that","that use the","gnu gpl protect","gpl protect your","this license giving","license giving you","giving you legal","it for the","for the developers","the developers and","developers and authors","and authors protection","authors protection the","protection the gpl","the gpl clearly","gpl clearly explains","clearly explains that","explains that there","software for both","for both users","both users and","users and authors","and authors sake","authors sake the","sake the gpl","the gpl requires","gpl requires that","requires that modified","modified versions be","versions be marked","marked as changed","as changed so","changed so that","so that their","that their problems","their problems will","problems will not","not be attributed","be attributed erroneously","attributed erroneously to","erroneously to authors","to authors of","authors of previous","previous versions some","versions some devices","some devices are","devices are designed","designed to deny","to deny users","deny users access","users access to","access to install","to install or","install or run","or run modified","run modified versions","the software inside","software inside them","inside them although","them although the","although the manufacturer","the manufacturer can","manufacturer can do","do so this","so this is","this is fundamentally","is fundamentally incompatible","fundamentally incompatible with","with the aim","the aim of","aim of protecting","of protecting users","protecting users freedom","users freedom to","freedom to change","software the systematic","the systematic pattern","systematic pattern of","pattern of such","of such abuse","such abuse occurs","abuse occurs in","occurs in the","in the area","the area of","area of products","of products for","products for individuals","for individuals to","individuals to use","to use which","which is precisely","is precisely where","precisely where it","it is most","is most unacceptable","most unacceptable therefore","unacceptable therefore we","therefore we have","designed this version","gpl to prohibit","to prohibit the","prohibit the practice","the practice for","practice for those","for those products","those products if","products if such","if such problems","such problems arise","problems arise substantially","arise substantially in","substantially in other","in other domains","other domains we","domains we stand","we stand ready","stand ready to","ready to extend","to extend this","extend this provision","this provision to","provision to those","to those domains","those domains in","domains in future","the gpl as","gpl as needed","needed to protect","freedom of users","of users finally","users finally every","finally every program","every program is","software patents states","patents states should","states should not","should not allow","not allow patents","allow patents to","patents to restrict","to restrict development"]},{"licenseTexts":["﻿insert GPL v3 text here GCC RUNTIME LIBRARY EXCEPTION\n\nVersion 3.1, 31 March 2009\n\nGeneral information: http://www.gnu.org/licenses/gcc-exception.html\n\nCopyright (C) 2009 Free Software Foundation, Inc. \u003chttp://fsf.org/\u003e\n\nEveryone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.\n\nThis GCC Runtime Library Exception (\"Exception\") is an additional permission under section 7 of the GNU General Public License, version 3 (\"GPLv3\"). It applies to a given file (the \"Runtime Library\") that bears a notice placed by the copyright holder of the file stating that the file is governed by GPLv3 along with this Exception.\n\nWhen you use GCC to compile a program, GCC may combine portions of certain GCC header files and runtime libraries with the compiled program. The purpose of this Exception is to allow compilation of non-GPL (including proprietary) programs to use, in this way, the header files and runtime libraries covered by this Exception.\n\n   0. Definitions.\n\n   A file is an \"Independent Module\" if it either requires the Runtime Library for execution after a Compilation Process, or makes use of an interface provided by the Runtime Library, but is not otherwise based on the Runtime Library.\n\n   \"GCC\" means a version of the GNU Compiler Collection, with or without modifications, governed by version 3 (or a specified later version) of the GNU General Public License (GPL) with the option of using any subsequent versions published by the FSF.\n\n   \"GPL-compatible Software\" is software whose conditions of propagation, modification and use would permit combination with GCC in accord with the license of GCC.\n\n   \"Target Code\" refers to output from any compiler for a real or virtual target processor architecture, in executable form or suitable for input to an assembler, loader, linker and/or execution phase. Notwithstanding that, Target Code does not include data in any format that is used as a compiler intermediate representation, or used for producing a compiler intermediate representation.\n\n   The \"Compilation Process\" transforms code entirely represented in non-intermediate languages designed for human-written code, and/or in Java Virtual Machine byte code, into Target Code. Thus, for example, use of source code generators and preprocessors need not be considered part of the Compilation Process, since the Compilation Process can be understood as starting with the output of the generators or preprocessors.\n\n   A Compilation Process is \"Eligible\" if it is done using GCC, alone or with other GPL-compatible software, or if it is done without using any work based on GCC. For example, using non-GPL-compatible Software to optimize any GCC intermediate representations would not qualify as an Eligible Compilation Process.\n\n   1. Grant of Additional Permission.\n\n   You have permission to propagate a work of Target Code formed by combining the Runtime Library with Independent Modules, even if such propagation would otherwise violate the terms of GPLv3, provided that all Target Code was generated by Eligible Compilation Processes. You may then convey such a combination under terms of your choice, consistent with the licensing of the Independent Modules.\n\n   2. No Weakening of GCC Copyleft.\n\nThe availability of this Exception does not imply any general presumption that third-party software is unaffected by the copyleft requirements of the license of GCC."],"licenseIds":["GPL-3.0-with-GCC-exception"],"keywords":["here gcc runtime","library exception version","3 1 31","1 31 march","31 march 2009","march 2009 general","2009 general information","general information http","information http www","org licenses gcc","licenses gcc exception","gcc exception html","exception html copyright","html copyright c","c 2009 free","allowed this gcc","this gcc runtime","library exception exception","exception exception is","given file the","file the runtime","runtime library that","library that bears","this exception when","exception when you","you use gcc","use gcc to","gcc to compile","to compile a","compile a program","a program gcc","program gcc may","gcc may combine","may combine portions","combine portions of","portions of certain","of certain gcc","certain gcc header","gcc header files","runtime libraries with","libraries with the","with the compiled","the compiled program","compiled program the","program the purpose","to allow compilation","allow compilation of","compilation of non","of non gpl","non gpl including","gpl including proprietary","including proprietary programs","proprietary programs to","use in this","this way the","way the header","the header files","runtime libraries covered","libraries covered by","by this exception","this exception 0","exception 0 definitions","definitions a file","file is an","is an independent","independent module if","module if it","if it either","it either requires","either requires the","requires the runtime","runtime library for","library for execution","for execution after","execution after a","after a compilation","compilation process or","process or makes","or makes use","by the runtime","runtime library but","on the runtime","runtime library gcc","library gcc means","gcc means a","the gnu compiler","gnu compiler collection","compiler collection with","collection with or","without modifications governed","modifications governed by","3 or a","or a specified","a specified later","specified later version","license gpl with","gpl with the","with the option","option of using","of using any","using any subsequent","any subsequent versions","subsequent versions published","versions published by","by the fsf","the fsf gpl","fsf gpl compatible","compatible software is","software is software","is software whose","software whose conditions","whose conditions of","conditions of propagation","of propagation modification","propagation modification and","modification and use","and use would","use would permit","would permit combination","permit combination with","combination with gcc","with gcc in","gcc in accord","accord with the","of gcc target","gcc target code","target code refers","refers to output","to output from","output from any","from any compiler","any compiler for","compiler for a","for a real","a real or","real or virtual","or virtual target","virtual target processor","target processor architecture","processor architecture in","architecture in executable","executable form or","form or suitable","or suitable for","input to an","to an assembler","an assembler loader","assembler loader linker","loader linker and","linker and or","and or execution","or execution phase","execution phase notwithstanding","phase notwithstanding that","notwithstanding that target","that target code","target code does","not include data","include data in","data in any","in any format","any format that","is used as","as a compiler","intermediate representation or","representation or used","or used for","used for producing","for producing a","producing a compiler","intermediate representation the","representation the compilation","compilation process transforms","process transforms code","transforms code entirely","code entirely represented","entirely represented in","represented in non","in non intermediate","non intermediate languages","intermediate languages designed","languages designed for","for human written","human written code","written code and","or in java","in java virtual","java virtual machine","virtual machine byte","machine byte code","byte code into","code into target","into target code","target code thus","code thus for","thus for example","for example use","example use of","use of source","source code generators"]},{"licenseTexts":["insert GPL v3 text here\n\nAUTOCONF CONFIGURE SCRIPT EXCEPTION\n\nVersion 3.0, 18 August 2009\n\nCopyright © 2009 Free Software Foundation, Inc. \u003ehttp://fsf.org/\u003c\n\nEveryone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.\n\nThis Exception is an additional permission under section 7 of the GNU General Public License, version 3 (\"GPLv3\"). It applies to a given file that bears a notice placed by the copyright holder of the file stating that the file is governed by GPLv3 along with this Exception.\n\nThe purpose of this Exception is to allow distribution of Autoconf's typical output under terms of the recipient's choice (including proprietary).\n\n   0. Definitions.\n\n   \"Covered Code\" is the source or object code of a version of Autoconf that is a covered work under this License.\n\n   \"Normally Copied Code\" for a version of Autoconf means all parts of its Covered Code which that version can copy from its code (i.e., not from its input file) into its minimally verbose, non-debugging and non-tracing output.\n\n   \"Ineligible Code\" is Covered Code that is not Normally Copied Code.\n\n   1. Grant of Additional Permission.\n\n   You have permission to propagate output of Autoconf, even if such propagation would otherwise violate the terms of GPLv3. However, if by modifying Autoconf you cause any Ineligible Code of the version you received to become Normally Copied Code of your modified version, then you void this Exception for the resulting covered work. If you convey that resulting covered work, you must remove this Exception in accordance with the second paragraph of Section 7 of GPLv3.\n\n   2. No Weakening of Autoconf Copyleft.\n\n   The availability of this Exception does not imply any general presumption that third-party software is unaffected by the copyleft requirements of the license of Autoconf."],"licenseIds":["GPL-3.0-with-autoconf-exception"],"keywords":["here autoconf configure","autoconf configure script","configure script exception","script exception version","3 0 18","0 18 august","18 august 2009","august 2009 copyright","2009 copyright 2009","copyright 2009 free","allowed this exception","given file that","file that bears","this exception the","exception the purpose","to allow distribution","allow distribution of","distribution of autoconf","of autoconf s","autoconf s typical","s typical output","typical output under","output under terms","recipient s choice","s choice including","choice including proprietary","including proprietary 0","proprietary 0 definitions","0 definitions covered","definitions covered code","is the source","of autoconf that","autoconf that is","is a covered","this license normally","license normally copied","copied code for","of autoconf means","autoconf means all","means all parts","parts of its","of its covered","its covered code","code which that","which that version","that version can","version can copy","can copy from","copy from its","from its code","its code i","code i e","e not from","not from its","from its input","its input file","input file into","file into its","into its minimally","its minimally verbose","minimally verbose non","verbose non debugging","non debugging and","debugging and non","and non tracing","non tracing output","tracing output ineligible","output ineligible code","ineligible code is","code is covered","is covered code","is not normally","not normally copied","copied code 1","code 1 grant","to propagate output","propagate output of","of autoconf even","autoconf even if","of gplv3 however","gplv3 however if","however if by","if by modifying","by modifying autoconf","modifying autoconf you","autoconf you cause","you cause any","cause any ineligible","any ineligible code","ineligible code of","you received to","received to become","to become normally","become normally copied","copied code of","modified version then","version then you","then you void","you void this","void this exception","this exception for","exception for the","for the resulting","you convey that","convey that resulting","that resulting covered","must remove this","remove this exception","this exception in","exception in accordance","with the second","the second paragraph","second paragraph of","7 of gplv3","of gplv3 2","gplv3 2 no","weakening of autoconf","of autoconf copyleft","autoconf copyleft the","license of autoconf","v3 text here autoconf","text here autoconf configure","here autoconf configure script","autoconf configure script exception","configure script exception version","script exception version 3","exception version 3 0","version 3 0 18","3 0 18 august","0 18 august 2009","18 august 2009 copyright","august 2009 copyright 2009","2009 copyright 2009 free","copyright 2009 free software","not allowed this exception","allowed this exception is","this exception is an","a given file that","given file that bears","file that bears a","with this exception the","this exception the purpose","exception the purpose of","is to allow distribution","to allow distribution of","allow distribution of autoconf","distribution of autoconf s","of autoconf s typical","autoconf s typical output","s typical output under","typical output under terms","output under terms of","under terms of the","terms of the recipient","the recipient s choice","recipient s choice including","s choice including proprietary","choice including proprietary 0","including proprietary 0 definitions","proprietary 0 definitions covered","0 definitions covered code","definitions covered code is","covered code is the","code is the source","is the source or","the source or object","or object code of","object code of a","code of a version","of a version of","version of autoconf that","of autoconf that is","autoconf that is a","that is a covered","is a covered work","covered work under this","under this license normally","this license normally copied","license normally copied code","normally copied code for","copied code for a","code for a version","version of autoconf means","of autoconf means all","autoconf means all parts","means all parts of","all parts of its","parts of its covered","of its covered code","its covered code which","covered code which that","code which that version","which that version can","that version can copy","version can copy from","can copy from its","copy from its code","from its code i","its code i e","code i e not"]},{"licenseTexts":["Allegro 4 (the giftware license)\n\nAllegro is gift-ware. It was created by a number of people working in cooperation, and is given to you freely as a gift. You may use, modify, redistribute, and generally hack it about in any way you like, and you do not have to give us anything in return.\n\nHowever, if you like this product you are encouraged to thank us by making a return gift to the Allegro community. This could be by writing an add-on package, providing a useful bug report, making an improvement to the library, or perhaps just releasing the sources of your program so that other people can learn from them. If you redistribute parts of this code or make a game using it, it would be nice if you mentioned Allegro somewhere in the credits, but you are not required to do this. We trust you not to abuse our generosity.\n\nBy Shawn Hargreaves, 18 October 1998.\n\nDISCLAIMER: THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE."],"licenseIds":["Giftware"],"keywords":["allegro 4 the","4 the giftware","the giftware license","giftware license allegro","license allegro is","allegro is gift","is gift ware","gift ware it","ware it was","it was created","by a number","of people working","people working in","working in cooperation","in cooperation and","cooperation and is","and is given","given to you","to you freely","you freely as","freely as a","as a gift","a gift you","gift you may","use modify redistribute","redistribute and generally","and generally hack","generally hack it","hack it about","it about in","about in any","way you like","you like and","like and you","have to give","to give us","give us anything","us anything in","anything in return","in return however","return however if","you like this","like this product","this product you","encouraged to thank","to thank us","thank us by","us by making","by making a","making a return","a return gift","return gift to","gift to the","to the allegro","the allegro community","allegro community this","community this could","could be by","be by writing","by writing an","writing an add","an add on","add on package","on package providing","package providing a","providing a useful","a useful bug","useful bug report","bug report making","report making an","making an improvement","an improvement to","library or perhaps","or perhaps just","perhaps just releasing","just releasing the","releasing the sources","the sources of","sources of your","your program so","so that other","that other people","other people can","people can learn","can learn from","learn from them","from them if","you redistribute parts","redistribute parts of","this code or","code or make","make a game","a game using","game using it","using it it","it it would","it would be","would be nice","be nice if","nice if you","if you mentioned","you mentioned allegro","mentioned allegro somewhere","allegro somewhere in","in the credits","the credits but","credits but you","required to do","do this we","this we trust","we trust you","trust you not","you not to","not to abuse","to abuse our","abuse our generosity","our generosity by","generosity by shawn","by shawn hargreaves","shawn hargreaves 18","hargreaves 18 october","18 october 1998","october 1998 disclaimer","1998 disclaimer the","allegro 4 the giftware","4 the giftware license","the giftware license allegro","giftware license allegro is","license allegro is gift","allegro is gift ware","is gift ware it","gift ware it was","ware it was created","it was created by","was created by a","created by a number","by a number of","a number of people","number of people working","of people working in","people working in cooperation","working in cooperation and","in cooperation and is","cooperation and is given","and is given to","is given to you","given to you freely","to you freely as","you freely as a","freely as a gift","as a gift you","a gift you may","gift you may use","may use modify redistribute","use modify redistribute and","modify redistribute and generally","redistribute and generally hack","and generally hack it","generally hack it about","hack it about in","it about in any","about in any way","any way you like","way you like and","you like and you","like and you do","not have to give","have to give us","to give us anything","give us anything in","us anything in return","anything in return however","in return however if","return however if you","however if you like","if you like this","you like this product","like this product you","this product you are","product you are encouraged","are encouraged to thank","encouraged to thank us","to thank us by","thank us by making","us by making a","by making a return","making a return gift","a return gift to","return gift to the","gift to the allegro","to the allegro community","the allegro community this","allegro community this could","community this could be","this could be by","could be by writing","be by writing an","by writing an add","writing an add on","an add on package"]},{"licenseTexts":["3DFX GLIDE Source Code General Public License\n\n   1. PREAMBLE\n\n   This license is for software that provides a 3D graphics application program interface (API).The license is intended to offer terms similar to some standard General Public Licenses designed to foster open standards and unrestricted accessibility to source code. Some of these licenses require that, as a condition of the license of the software, any derivative works (that is, new software which is a work containing the original program or a portion of it) must be available for general use, without restriction other than for a minor transfer fee, and that the source code for such derivative works must likewise be made available. The only restriction is that such derivative works must be subject to the same General Public License terms as the original work.\n\n   This 3dfx GLIDE Source Code General Public License differs from the standard licenses of this type in that it does not require the entire derivative work to be made available under the terms of this license nor is the recipient required to make available the source code for the entire derivative work. Rather, the license is limited to only the identifiable portion of the derivative work that is derived from the licensed software. The precise terms and conditions for copying, distribution and modification follow.\n\n   2. DEFINITIONS\n\n      2.1 This License applies to any program (or other \"work\") which contains a notice placed by the copyright holder saying it may be distributed under the terms of this 3dfx GLIDE Source Code General Public License.\n\n      2.2 The term \"Program\" as used in this Agreement refers to 3DFX's GLIDE source code and object code and any Derivative Work.\n\n      2.3 \"Derivative Work\" means, for the purpose of the License, that portion of any work that contains the Program or the identifiable portion of a work that is derived from the Program, either verbatim or with modifications and/or translated into another language, and that performs 3D graphics API operations. It does not include any other portions of a work.\n\n      2.4 \"Modifications of the Program\" means any work, which includes a Derivative Work, and includes the whole of such work.\n\n      2.5 \"License\" means this 3dfx GLIDE Source Code General Public License.\n\n      2.6 The \"Source Code\" for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, any associated interface definition files, and the scripts used to control compilation and installation of the executable work.\n\n      2.7 \"3dfx\" means 3dfx Interactive, Inc.\n\n   3. LICENSED ACTIVITIES\n\n      3.1 COPYING - You may copy and distribute verbatim copies of the Program's Source Code as you receive it, in any medium, subject to the provision of section 3.3 and provided also that:\n\n         (a) you conspicuously and appropriately publish on each copy an appropriate copyright notice (3dfx Interactive, Inc. 1999), a notice that recipients who wish to copy, distribute or modify the Program can only do so subject to this License, and a disclaimer of warranty as set forth in section 5;\n\n         (b) keep intact all the notices that refer to this License and to the absence of any warranty; and\n\n         (c) do not make any use of the GLIDE trademark without the prior written permission of 3dfx, and\n\n         (d) give all recipients of the Program a copy of this License along with the Program or instructions on how to easily receive a copy of this License.\n\n      3.2 MODIFICATION OF THE PROGRAM/DERIVATIVE WORKS - You may modify your copy or copies of the Program or any portion of it, and copy and distribute such modifications subject to the provisions of section 3.3 and provided that you also meet all of the following conditions:\n\n         (a) you conspicuously and appropriately publish on each copy of a Derivative Work an appropriate copyright notice, a notice that recipients who wish to copy, distribute or modify the Derivative Work can only do so subject to this License, and a disclaimer of warranty as set forth in section 5;\n\n         (b) keep intact all the notices that refer to this License and to the absence of any warranty; and (c) give all recipients of the Derivative Work a copy of this License along with the Derivative Work or instructions on how to easily receive a copy of this License.\n\n         (d) You must cause the modified files of the Derivative Work to carry prominent notices stating that you changed the files and the date of any change.\n\n         (e) You must cause any Derivative Work that you distribute or publish to be licensed at no charge to all third parties under the terms of this License.\n\n         (f) You do not make any use of the GLIDE trademark without the prior written permission of 3dfx.\n\n         (g) If the Derivative Work normally reads commands interactively when run, you must cause it, when started running for such interactive use, to print or display an announcement as follows:\n\n         \"COPYRIGHT 3DFX INTERACTIVE, INC. 1999, ALL RIGHTS RESERVED THIS SOFTWARE IS FREE AND PROVIDED \"AS IS,\" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED. THERE IS NO RIGHT TO USE THE GLIDE TRADEMARK WITHOUT PRIOR WRITTEN PERMISSION OF 3DFX INTERACTIVE, INC. SEE THE 3DFX GLIDE GENERAL PUBLIC LICENSE FOR A FULL TEXT OF THE DISTRIBUTION AND NON-WARRANTY PROVISIONS (REQUEST COPY FROM INFO@3DFX.COM).\"\n\n         (h) The requirements of this section 3.2 do not apply to the modified work as a whole but only to the Derivative Work. It is not the intent of this License to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of Derivative Works.\n\n      3.3 DISTRIBUTION\n\n         (a) All copies of the Program or Derivative Works which are distributed must include in the file headers the following language verbatim:\n\n         \"THIS SOFTWARE IS SUBJECT TO COPYRIGHT PROTECTION AND IS OFFERED ONLY PURSUANT TO THE 3DFX GLIDE GENERAL PUBLIC LICENSE. THERE IS NO RIGHT TO USE THE GLIDE TRADEMARK WITHOUT PRIOR WRITTEN PERMISSION OF 3DFX INTERACTIVE, INC. A COPY OF THIS LICENSE MAY BE OBTAINED FROM THE DISTRIBUTOR OR BY CONTACTING 3DFX INTERACTIVE INC (info@3dfx.com). THIS PROGRAM. IS PROVIDED \"AS IS\" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED. SEE THE 3DFX GLIDE GENERAL PUBLIC LICENSE FOR A FULL TEXT OF THE NON-WARRANTY PROVISIONS.\n\n         USE, DUPLICATION OR DISCLOSURE BY THE GOVERNMENT IS SUBJECT TO RESTRICTIONS AS SET FORTH IN SUBDIVISION (C)(1)(II) OF THE RIGHTS IN TECHNICAL DATA AND COMPUTER SOFTWARE CLAUSE AT DFARS 252.227-7013, AND/OR IN SIMILAR OR SUCCESSOR CLAUSES IN THE FAR, DOD OR NASA FAR SUPPLEMENT. UNPUBLISHED RIGHTS RESERVED UNDER THE COPYRIGHT LAWS OF THE UNITED STATES.\n\n         COPYRIGHT 3DFX INTERACTIVE, INC. 1999, ALL RIGHTS RESERVED\"\n\n         (b) You may distribute the Program or a Derivative Work in object code or executable form under the terms of Sections 3.1 and 3.2 provided that you also do one of the following:\n\n            (1) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 3.1 and 3.2; or,\n\n            (2) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 3.1 and 3.2 on a medium customarily used for software interchange; or,\n\n            (3) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection 3.3(b)(2) above.)\n\n         (c) The source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable code.\n\n         (d) If distribution of executable code or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code.\n\n         (e) Each time you redistribute the Program or any Derivative Work, the recipient automatically receives a license from 3dfx and successor licensors to copy, distribute or modify the Program and Derivative Works subject to the terms and conditions of the License. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License.\n\n         (f) You may not make any use of the GLIDE trademark without the prior written permission of 3dfx.\n\n         (g) You may not copy, modify, sublicense, or distribute the Program or any Derivative Works except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program or any Derivative Works is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance.\n\n   4. MISCELLANEOUS\n\n      4.1 Acceptance of this License is voluntary. By using, modifying or distributing the Program or any Derivative Work, you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. Nothing else grants you permission to modify or distribute the Program or Derivative Works and doing so without acceptance of this License is in violation of the U.S. and international copyright laws.\n\n      4.2 If the distribution and/or use of the Program or Derivative Works is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License.\n\n      4.3 This License is to be construed according to the laws of the State of California and you consent to personal jurisdiction in the State of California in the event it is necessary to enforce the provisions of this License.\n\n   5. NO WARRANTIES\n\n      5.1 TO THE EXTENT PERMITTED BY APPLICABLE LAW, THERE IS NO WARRANTY FOR THE PROGRAM. OR DERIVATIVE WORKS THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM AND ANY DERIVATIVE WORKS\"AS IS\" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM AND ANY DERIVATIVE WORK IS WITH YOU. SHOULD THE PROGRAM OR ANY DERIVATIVE WORK PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.\n\n      5.2 IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW WILL 3DFX INTERACTIVE, INC., OR ANY OTHER COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM OR DERIVATIVE WORKS AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM OR DERIVATIVE WORKS (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM OR DERIVATIVE WORKS TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES."],"licenseIds":["Glide"],"keywords":["license 1 preamble","1 preamble this","is for software","software that provides","that provides a","provides a 3d","a 3d graphics","3d graphics application","graphics application program","application program interface","program interface api","interface api the","api the license","intended to offer","to offer terms","offer terms similar","terms similar to","similar to some","to some standard","some standard general","standard general public","public licenses designed","licenses designed to","designed to foster","to foster open","foster open standards","open standards and","standards and unrestricted","and unrestricted accessibility","unrestricted accessibility to","accessibility to source","source code some","code some of","of these licenses","these licenses require","licenses require that","require that as","that as a","a condition of","condition of the","software any derivative","works that is","that is new","is new software","new software which","of it must","available for general","for general use","general use without","use without restriction","without restriction other","restriction other than","than for a","for a minor","a minor transfer","minor transfer fee","transfer fee and","fee and that","code for such","for such derivative","works must likewise","must likewise be","likewise be made","available the only","the only restriction","only restriction is","restriction is that","is that such","that such derivative","works must be","same general public","terms as the","work this 3dfx","public license differs","the standard licenses","standard licenses of","licenses of this","of this type","this type in","type in that","require the entire","this license nor","license nor is","is the recipient","the recipient required","recipient required to","required to make","derivative work rather","work rather the","rather the license","license is limited","limited to only","only the identifiable","licensed software the","software the precise","modification follow 2","follow 2 definitions","2 definitions 2","definitions 2 1","of this 3dfx","2 the term","the term program","term program as","program as used","this agreement refers","agreement refers to","refers to 3dfx","to 3dfx s","3dfx s glide","s glide source","work 2 3","2 3 derivative","3 derivative work","work means for","means for the","license that portion","that portion of","portion of any","or the identifiable","portion of a","program either verbatim","another language and","language and that","and that performs","that performs 3d","performs 3d graphics","3d graphics api","graphics api operations","api operations it","operations it does","include any other","any other portions","other portions of","portions of a","a work 2","4 modifications of","program means any","work which includes","includes a derivative","derivative work and","work and includes","and includes the","includes the whole","whole of such","such work 2","work 2 5","2 5 license","5 license means","means this 3dfx","2 6 the","6 the source","it contains any","contains any associated","and the scripts","executable work 2","work 2 7","2 7 3dfx","7 3dfx means","3dfx means 3dfx","means 3dfx interactive","interactive inc 3","inc 3 licensed","3 licensed activities","licensed activities 3","activities 3 1","3 1 copying","1 copying you","to the provision","provision of section","and provided also","provided also that","also that a","copyright notice 3dfx","notice 3dfx interactive","inc 1999 a","1999 a notice","the program can","program can only","and c do","of 3dfx and","3dfx and d","and d give","d give all","license 3 2","3 2 modification","2 modification of","the program derivative","program derivative works","such modifications subject","modifications subject to","derivative work an","work an appropriate","notice a notice","modify the derivative","derivative work can","and c give","c give all","work or instructions","modified files of","any change e"]},{"licenseTexts":["The source code in this package is copyright 1999-2010 by Andrew Plotkin.\n\nYou may copy and distribute it freely, by any means and under any conditions, as long as the code and documentation is not changed. You may also incorporate this code into your own program and distribute that, or modify this code and use and distribute the modified version, as long as you retain a notice in your program or documentation which mentions my name and the URL shown above."],"licenseIds":["Glulxe"],"keywords":["code in this","package is copyright","is copyright 1999","copyright 1999 2010","1999 2010 by","2010 by andrew","by andrew plotkin","andrew plotkin you","plotkin you may","distribute it freely","it freely by","freely by any","means and under","under any conditions","any conditions as","conditions as long","as the code","is not changed","not changed you","changed you may","may also incorporate","also incorporate this","incorporate this code","this code into","code into your","into your own","your own program","own program and","distribute that or","that or modify","modify this code","this code and","and use and","version as long","you retain a","retain a notice","notice in your","your program or","program or documentation","or documentation which","documentation which mentions","which mentions my","mentions my name","my name and","and the url","the url shown","url shown above","source code in this","code in this package","in this package is","this package is copyright","package is copyright 1999","is copyright 1999 2010","copyright 1999 2010 by","1999 2010 by andrew","2010 by andrew plotkin","by andrew plotkin you","andrew plotkin you may","plotkin you may copy","and distribute it freely","distribute it freely by","it freely by any","freely by any means","any means and under","means and under any","and under any conditions","under any conditions as","any conditions as long","conditions as long as","long as the code","as the code and","the code and documentation","and documentation is not","documentation is not changed","is not changed you","not changed you may","changed you may also","you may also incorporate","may also incorporate this","also incorporate this code","incorporate this code into","this code into your","code into your own","into your own program","your own program and","own program and distribute","program and distribute that","and distribute that or","distribute that or modify","that or modify this","or modify this code","modify this code and","this code and use","code and use and","and use and distribute","modified version as long","version as long as","as you retain a","you retain a notice","retain a notice in","a notice in your","notice in your program","in your program or","your program or documentation","program or documentation which","or documentation which mentions","documentation which mentions my","which mentions my name","mentions my name and","my name and the","name and the url","and the url shown","the url shown above","the source code in this","source code in this package","code in this package is","in this package is copyright","this package is copyright 1999","package is copyright 1999 2010","is copyright 1999 2010 by","copyright 1999 2010 by andrew","1999 2010 by andrew plotkin","2010 by andrew plotkin you","by andrew plotkin you may","andrew plotkin you may copy","plotkin you may copy and","may copy and distribute it","copy and distribute it freely","and distribute it freely by","distribute it freely by any","it freely by any means","freely by any means and","by any means and under","any means and under any","means and under any conditions","and under any conditions as","under any conditions as long","any conditions as long as","conditions as long as the","as long as the code","long as the code and","as the code and documentation","the code and documentation is","code and documentation is not","and documentation is not changed","documentation is not changed you","is not changed you may","not changed you may also","changed you may also incorporate","you may also incorporate this","may also incorporate this code","also incorporate this code into","incorporate this code into your","this code into your own","code into your own program","into your own program and","your own program and distribute","own program and distribute that","program and distribute that or","and distribute that or modify","distribute that or modify this","that or modify this code","or modify this code and","modify this code and use","this code and use and","code and use and distribute","and use and distribute the","use and distribute the modified","and distribute the modified version","distribute the modified version as","the modified version as long","modified version as long as","version as long as you","long as you retain a","as you retain a notice","you retain a notice in","retain a notice in your","a notice in your program","notice in your program or","in your program or documentation","your program or documentation which","program or documentation which mentions","or documentation which mentions my","documentation which mentions my name","which mentions my name and","mentions my name and the","my name and the url","name and the url shown","and the url shown above"]},{"licenseTexts":["\u003ccopyright notice\u003e\n\nPermission to use, copy, modify, distribute, and sell this software and its documentation for any purpose is hereby granted without fee, provided that the above copyright notice appears in all copies, and that both that the copyright notice and this permission notice appear in supporting documentation, and that the name of \u003ccopyright holder\u003e \u003cor related entities\u003e not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission . \u003ccopyright holder\u003e makes no representations about the suitability of this software for any purpose. It is provided \"as is\" without express or implied warranty. \u003ccopyright holder\u003e DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS . IN NO EVENT SHALL \u003ccopyright holder\u003e BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE."],"licenseIds":["HPND-sell-variant"],"keywords":null},{"licenseTexts":["Historical Permission Notice and Disclaimer \u003ccopyright notice\u003e\n\nPermission to use, copy, modify and distribute this software and its documentation for any purpose and without fee is hereby granted, provided that the above copyright notice appear in all copies, and that both that the copyright notice and this permission notice appear in supporting documentation , and that the name of \u003ccopyright holder\u003e \u003cor related entities\u003e not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission . \u003ccopyright holder\u003e makes no representations about the suitability of this software for any purpose. It is provided \"as is\" without express or implied warranty. \u003ccopyright holder\u003e DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS . IN NO EVENT SHALL \u003ccopyright holder\u003e BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE."],"licenseIds":["HPND"],"keywords":["historical permission notice","disclaimer copyright notice","historical permission notice and","permission notice and disclaimer","notice and disclaimer copyright","and disclaimer copyright notice","disclaimer copyright notice permission","historical permission notice and disclaimer","permission notice and disclaimer copyright","notice and disclaimer copyright notice","and disclaimer copyright notice permission","disclaimer copyright notice permission to"]},{"licenseTexts":["Code derived from the document \"Report on the Programming Language\n\nHaskell 2010\", is distributed under the following license:\n\nCopyright (c) 2010 Simon Marlow\n\nThe authors intend this Report to belong to the entire Haskell community, and so we grant permission to copy and distribute it for any purpose, provided that it is reproduced in its entirety, including this Notice. Modified versions of this Report may also be copied and distributed for any purpose, provided that the modified version is clearly presented as such, and that it does not claim to be a definition of the Haskell 2010 Language."],"licenseIds":["HaskellReport"],"keywords":["the document report","document report on","report on the","on the programming","the programming language","programming language haskell","language haskell 2010","haskell 2010 is","2010 is distributed","following license copyright","c 2010 simon","2010 simon marlow","simon marlow the","marlow the authors","the authors intend","authors intend this","intend this report","this report to","report to belong","to belong to","the entire haskell","entire haskell community","haskell community and","community and so","and so we","so we grant","we grant permission","distribute it for","it is reproduced","is reproduced in","reproduced in its","its entirety including","entirety including this","including this notice","this notice modified","notice modified versions","of this report","this report may","report may also","also be copied","version is clearly","is clearly presented","clearly presented as","presented as such","such and that","does not claim","not claim to","claim to be","be a definition","definition of the","of the haskell","the haskell 2010","haskell 2010 language","derived from the document","from the document report","the document report on","document report on the","report on the programming","on the programming language","the programming language haskell","programming language haskell 2010","language haskell 2010 is","haskell 2010 is distributed","2010 is distributed under","distributed under the following","the following license copyright","following license copyright c","license copyright c 2010","copyright c 2010 simon","c 2010 simon marlow","2010 simon marlow the","simon marlow the authors","marlow the authors intend","the authors intend this","authors intend this report","intend this report to","this report to belong","report to belong to","to belong to the","belong to the entire","to the entire haskell","the entire haskell community","entire haskell community and","haskell community and so","community and so we","and so we grant","so we grant permission","we grant permission to","grant permission to copy","and distribute it for","distribute it for any","purpose provided that it","that it is reproduced","it is reproduced in","is reproduced in its","reproduced in its entirety","in its entirety including","its entirety including this","entirety including this notice","including this notice modified","this notice modified versions","notice modified versions of","versions of this report","of this report may","this report may also","report may also be","may also be copied","also be copied and","be copied and distributed","purpose provided that the","provided that the modified","that the modified version","modified version is clearly","version is clearly presented","is clearly presented as","clearly presented as such","presented as such and","as such and that","such and that it","and that it does","it does not claim","does not claim to","not claim to be","claim to be a","to be a definition","be a definition of","a definition of the","definition of the haskell","of the haskell 2010","the haskell 2010 language","code derived from the document","derived from the document report","from the document report on","the document report on the","document report on the programming","report on the programming language","on the programming language haskell","the programming language haskell 2010","programming language haskell 2010 is","language haskell 2010 is distributed","haskell 2010 is distributed under","2010 is distributed under the","is distributed under the following","distributed under the following license","under the following license copyright","the following license copyright c","following license copyright c 2010","license copyright c 2010 simon","copyright c 2010 simon marlow","c 2010 simon marlow the","2010 simon marlow the authors","simon marlow the authors intend","marlow the authors intend this","the authors intend this report","authors intend this report to","intend this report to belong","this report to belong to","report to belong to the","to belong to the entire","belong to the entire haskell","to the entire haskell community","the entire haskell community and","entire haskell community and so","haskell community and so we","community and so we grant","and so we grant permission","so we grant permission to","we grant permission to copy","grant permission to copy and","to copy and distribute it","copy and distribute it for","and distribute it for any","distribute it for any purpose","it for any purpose provided","any purpose provided that it","purpose provided that it is","provided that it is reproduced","that it is reproduced in","it is reproduced in its","is reproduced in its entirety","reproduced in its entirety including","in its entirety including this","its entirety including this notice","entirety including this notice modified","including this notice modified versions","this notice modified versions of","notice modified versions of this","modified versions of this report","versions of this report may","of this report may also","this report may also be","report may also be copied","may also be copied and","also be copied and distributed","be copied and distributed for","distributed for any purpose provided","any purpose provided that the","purpose provided that the modified","provided that the modified version","that the modified version is"]},{"licenseTexts":["[SOFTWARE NAME] Copyright (C) (YEAR) (COPYRIGHT HOLDER(S)/AUTHOR(S) (\"Licensor\") Hippocratic License Version Number: 2.1.\n\nPurpose. The purpose of this License is for the Licensor named above to permit the Licensee (as defined below) broad permission, if consistent with Human Rights Laws and Human Rights Principles (as each is defined below), to use and work with the Software (as defined below) within the full scope of Licensor's copyright and patent rights, if any, in the Software, while ensuring attribution and protecting the Licensor from liability.\n\nPermission and Conditions. The Licensor grants permission by this license (\"License\"), free of charge, to the extent of Licensor's rights under applicable copyright and patent law, to any person or entity (the \"Licensee\") obtaining a copy of this software and associated documentation files (the \"Software\"), to do everything with the Software that would otherwise infringe (i) the Licensor's copyright in the Software or (ii) any patent claims to the Software that the Licensor can license or becomes able to license, subject to all of the following terms and conditions:\n\n   * Acceptance. This License is automatically offered to every person and entity subject to its terms and conditions. Licensee accepts this License and agrees to its terms and conditions by taking any action with the Software that, absent this License, would infringe any intellectual property right held by Licensor.\n\n   * Notice. Licensee must ensure that everyone who gets a copy of any part of this Software from Licensee, with or without changes, also receives the License and the above copyright notice (and if included by the Licensor, patent, trademark and attribution notice). Licensee must cause any modified versions of the Software to carry prominent notices stating that Licensee changed the Software. For clarity, although Licensee is free to create modifications of the Software and distribute only the modified portion created by Licensee with additional or different terms, the portion of the Software not modified must be distributed pursuant to this License. If anyone notifies Licensee in writing that Licensee has not complied with this Notice section, Licensee can keep this License by taking all practical steps to comply within 30 days after the notice. If Licensee does not do so, Licensee's License (and all rights licensed hereunder) shall end immediately.\n\n   * Compliance with Human Rights Principles and Human Rights Laws.\n\n      1. Human Rights Principles.\n\n         (a) Licensee is advised to consult the articles of the United Nations Universal Declaration of Human Rights and the United Nations Global Compact that define recognized principles of international human rights (the \"Human Rights Principles\"). Licensee shall use the Software in a manner consistent with Human Rights Principles.\n\n         (b) Unless the Licensor and Licensee agree otherwise, any dispute, controversy, or claim arising out of or relating to (i) Section 1(a) regarding Human Rights Principles, including the breach of Section 1(a), termination of this License for breach of the Human Rights Principles, or invalidity of Section 1(a) or (ii) a determination of whether any Law is consistent or in conflict with Human Rights Principles pursuant to Section 2, below, shall be settled by arbitration in accordance with the Hague Rules on Business and Human Rights Arbitration (the \"Rules\"); provided, however, that Licensee may elect not to participate in such arbitration, in which event this License (and all rights licensed hereunder) shall end immediately. The number of arbitrators shall be one unless the Rules require otherwise.\n\n         Unless both the Licensor and Licensee agree to the contrary: (1) All documents and information concerning the arbitration shall be public and may be disclosed by any party; (2) The repository referred to under Article 43 of the Rules shall make available to the public in a timely manner all documents concerning the arbitration which are communicated to it, including all submissions of the parties, all evidence admitted into the record of the proceedings, all transcripts or other recordings of hearings and all orders, decisions and awards of the arbitral tribunal, subject only to the arbitral tribunal's powers to take such measures as may be necessary to safeguard the integrity of the arbitral process pursuant to Articles 18, 33, 41 and 42 of the Rules; and (3) Article 26(6) of the Rules shall not apply.\n\n      2. Human Rights Laws. The Software shall not be used by any person or entity for any systems, activities, or other uses that violate any Human Rights Laws. \"Human Rights Laws\" means any applicable laws, regulations, or rules (collectively, \"Laws\") that protect human, civil, labor, privacy, political, environmental, security, economic, due process, or similar rights; provided, however, that such Laws are consistent and not in conflict with Human Rights Principles (a dispute over the consistency or a conflict between Laws and Human Rights Principles shall be determined by arbitration as stated above). Where the Human Rights Laws of more than one jurisdiction are applicable or in conflict with respect to the use of the Software, the Human Rights Laws that are most protective of the individuals or groups harmed shall apply.\n\n      3. Indemnity. Licensee shall hold harmless and indemnify Licensor (and any other contributor) against all losses, damages, liabilities, deficiencies, claims, actions, judgments, settlements, interest, awards, penalties, fines, costs, or expenses of whatever kind, including Licensor's reasonable attorneys' fees, arising out of or relating to Licensee's use of the Software in violation of Human Rights Laws or Human Rights Principles.\n\n   * Failure to Comply. Any failure of Licensee to act according to the terms and conditions of this License is both a breach of the License and an infringement of the intellectual property rights of the Licensor (subject to exceptions under Laws, e.g., fair use). In the event of a breach or infringement, the terms and conditions of this License may be enforced by Licensor under the Laws of any jurisdiction to which Licensee is subject. Licensee also agrees that the Licensor may enforce the terms and conditions of this License against Licensee through specific performance (or similar remedy under Laws) to the extent permitted by Laws. For clarity, except in the event of a breach of this License, infringement, or as otherwise stated in this License, Licensor may not terminate this License with Licensee.\n\n   * Enforceability and Interpretation. If any term or provision of this License is determined to be invalid, illegal, or unenforceable by a court of competent jurisdiction, then such invalidity, illegality, or unenforceability shall not affect any other term or provision of this License or invalidate or render unenforceable such term or provision in any other jurisdiction; provided, however, subject to a court modification pursuant to the immediately following sentence, if any term or provision of this License pertaining to Human Rights Laws or Human Rights Principles is deemed invalid, illegal, or unenforceable against Licensee by a court of competent jurisdiction, all rights in the Software granted to Licensee shall be deemed null and void as between Licensor and Licensee. Upon a determination that any term or provision is invalid, illegal, or unenforceable, to the extent permitted by Laws, the court may modify this License to affect the original purpose that the Software be used in compliance with Human Rights Principles and Human Rights Laws as closely as possible. The language in this License shall be interpreted as to its fair meaning and not strictly for or against any party.\n\n   * Disclaimer. TO THE FULL EXTENT ALLOWED BY LAW, THIS SOFTWARE COMES \"AS IS,\" WITHOUT ANY WARRANTY, EXPRESS OR IMPLIED, AND LICENSOR AND ANY OTHER CONTRIBUTOR SHALL NOT BE LIABLE TO ANYONE FOR ANY DAMAGES OR OTHER LIABILITY ARISING FROM, OUT OF, OR IN CONNECTION WITH THE SOFTWARE OR THIS LICENSE, UNDER ANY KIND OF LEGAL CLAIM.\n\nThis Hippocratic License is an Ethical Source license (https://ethicalsource.dev) and is offered for use by licensors and licensees at their own risk, on an \"AS IS\" basis, and with no warranties express or implied, to the maximum extent permitted by Laws."],"licenseIds":["Hippocratic-2.1"],"keywords":["software name copyright","name copyright c","year copyright holder","holder s author","s author s","author s licensor","s licensor hippocratic","licensor hippocratic license","hippocratic license version","2 1 purpose","1 purpose the","is for the","for the licensor","the licensor named","licensor named above","named above to","above to permit","permit the licensee","licensee as defined","defined below broad","below broad permission","broad permission if","permission if consistent","if consistent with","rights laws and","rights principles as","principles as each","as each is","each is defined","is defined below","below to use","use and work","and work with","defined below within","below within the","within the full","the full scope","full scope of","scope of licensor","patent rights if","any in the","the software while","software while ensuring","while ensuring attribution","ensuring attribution and","attribution and protecting","and protecting the","protecting the licensor","licensor from liability","from liability permission","liability permission and","permission and conditions","conditions the licensor","licensor grants permission","grants permission by","permission by this","license license free","license free of","licensor s rights","and patent law","patent law to","law to any","or entity the","entity the licensee","the licensee obtaining","everything with the","otherwise infringe i","infringe i the","i the licensor","ii any patent","claims to the","to license subject","and conditions acceptance","conditions acceptance this","person and entity","and entity subject","entity subject to","subject to its","and conditions licensee","conditions licensee accepts","licensee accepts this","accepts this license","license and agrees","agrees to its","software that absent","by licensor notice","licensor notice licensee","licensee must ensure","software from licensee","from licensee with","licensee with or","changes also receives","also receives the","receives the license","notice and if","and if included","if included by","the licensor patent","licensor patent trademark","and attribution notice","attribution notice licensee","software to carry","stating that licensee","that licensee changed","licensee changed the","changed the software","software for clarity","for clarity although","clarity although licensee","although licensee is","licensee is free","free to create","to create modifications","create modifications of","and distribute only","distribute only the","the modified portion","modified portion created","portion created by","created by licensee","by licensee with","licensee with additional","with additional or","different terms the","terms the portion","the portion of","software not modified","not modified must","modified must be","license if anyone","anyone notifies licensee","notifies licensee in","licensee in writing","writing that licensee","that licensee has","has not complied","complied with this","with this notice","this notice section","notice section licensee","section licensee can","licensee can keep","can keep this","keep this license","notice if licensee","if licensee does","licensee does not","does not do","do so licensee","so licensee s","licensee s license","end immediately compliance","immediately compliance with","rights laws 1","laws 1 human","1 human rights","principles a licensee","a licensee is","licensee is advised","is advised to","advised to consult","to consult the","consult the articles","the articles of","articles of the","united nations universal","nations universal declaration","universal declaration of","declaration of human","human rights and","united nations global","nations global compact","global compact that","compact that define","that define recognized","define recognized principles","recognized principles of","principles of international","of international human","international human rights","human rights the","rights the human","rights principles licensee","principles licensee shall","licensee shall use","rights principles b","principles b unless","b unless the","licensee agree otherwise","agree otherwise any","otherwise any dispute","relating to i","to i section","i section 1","1 a regarding","a regarding human","regarding human rights","rights principles including","principles including the","including the breach"]},{"licenseTexts":["This source code has been made available to you by IBM on an AS-IS basis. Anyone receiving this source is licensed under IBM copyrights to use it in any way he or she deems fit, including copying it, modifying it, compiling it, and redistributing it either with or without modifications. No license under IBM patents or patent applications is to be implied by the copyright license.\n\nAny user of this software should understand that IBM cannot provide technical support for this software and will not be responsible for any consequences resulting from the use of this software.\n\nAny person who transfers this source code or any derivative work must include the IBM copyright notice, this paragraph, and the preceding two paragraphs in the transferred software.\n\nCOPYRIGHT I B M CORPORATION 2002\n\nLICENSED MATERIAL - PROGRAM PROPERTY OF I B M"],"licenseIds":["IBM-pibs"],"keywords":["you by ibm","by ibm on","ibm on an","is basis anyone","basis anyone receiving","anyone receiving this","receiving this source","this source is","source is licensed","licensed under ibm","under ibm copyrights","ibm copyrights to","copyrights to use","any way he","way he or","or she deems","she deems fit","deems fit including","fit including copying","including copying it","copying it modifying","it modifying it","modifying it compiling","it compiling it","compiling it and","it and redistributing","and redistributing it","redistributing it either","it either with","without modifications no","modifications no license","no license under","license under ibm","under ibm patents","ibm patents or","patent applications is","applications is to","to be implied","be implied by","implied by the","copyright license any","license any user","any user of","user of this","software should understand","should understand that","understand that ibm","that ibm cannot","ibm cannot provide","cannot provide technical","technical support for","not be responsible","for any consequences","any consequences resulting","consequences resulting from","this software any","software any person","person who transfers","who transfers this","transfers this source","include the ibm","the ibm copyright","ibm copyright notice","notice this paragraph","and the preceding","the preceding two","preceding two paragraphs","two paragraphs in","paragraphs in the","in the transferred","the transferred software","transferred software copyright","software copyright i","copyright i b","b m corporation","m corporation 2002","corporation 2002 licensed","2002 licensed material","licensed material program","material program property","program property of","property of i","of i b","this source code has","code has been made","to you by ibm","you by ibm on","by ibm on an","ibm on an as","as is basis anyone","is basis anyone receiving","basis anyone receiving this","anyone receiving this source","receiving this source is","this source is licensed","source is licensed under","is licensed under ibm","licensed under ibm copyrights","under ibm copyrights to","ibm copyrights to use","copyrights to use it","it in any way","in any way he","any way he or","way he or she","he or she deems","or she deems fit","she deems fit including","deems fit including copying","fit including copying it","including copying it modifying","copying it modifying it","it modifying it compiling","modifying it compiling it","it compiling it and","compiling it and redistributing","it and redistributing it","and redistributing it either","redistributing it either with","it either with or","or without modifications no","without modifications no license","modifications no license under","no license under ibm","license under ibm patents","under ibm patents or","ibm patents or patent","or patent applications is","patent applications is to","applications is to be","is to be implied","to be implied by","be implied by the","implied by the copyright","by the copyright license","the copyright license any","copyright license any user","license any user of","any user of this","user of this software","this software should understand","software should understand that","should understand that ibm","understand that ibm cannot","that ibm cannot provide","ibm cannot provide technical","cannot provide technical support","provide technical support for","technical support for this","support for this software","this software and will","software and will not","will not be responsible","not be responsible for","responsible for any consequences","for any consequences resulting","any consequences resulting from","consequences resulting from the","of this software any","this software any person","software any person who","any person who transfers","person who transfers this","who transfers this source","transfers this source code","must include the ibm","include the ibm copyright","the ibm copyright notice","ibm copyright notice this","copyright notice this paragraph","notice this paragraph and","paragraph and the preceding","and the preceding two","the preceding two paragraphs","preceding two paragraphs in","two paragraphs in the","paragraphs in the transferred","in the transferred software","the transferred software copyright","transferred software copyright i","software copyright i b","copyright i b m","i b m corporation","b m corporation 2002","m corporation 2002 licensed","corporation 2002 licensed material","2002 licensed material program","licensed material program property","material program property of","program property of i","property of i b","of i b m","this source code has been","source code has been made","code has been made available","been made available to you","available to you by ibm","to you by ibm on","you by ibm on an","by ibm on an as"]},{"licenseTexts":["ICU License - ICU 1.8.1 and later\n\nCOPYRIGHT AND PERMISSION NOTICE Copyright (c) 1995-2014 International Business Machines Corporation and others\n\nAll rights reserved.\n\nPermission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the \"Software\"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, provided that the above copyright notice(s) and this permission notice appear in all copies of the Software and that both the above copyright notice(s) and this permission notice appear in supporting documentation.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.\n\nExcept as contained in this notice, the name of a copyright holder shall not be used in advertising or otherwise to promote the sale, use or other dealings in this Software without prior written authorization of the copyright holder."],"licenseIds":["ICU"],"keywords":["icu license icu","license icu 1","icu 1 8","1 and later","and later copyright","later copyright and","c 1995 2014","1995 2014 international","2014 international business","software and that","both the above","supporting documentation the","this software except","icu license icu 1","license icu 1 8","icu 1 8 1","1 8 1 and","8 1 and later","1 and later copyright","and later copyright and","later copyright and permission","notice copyright c 1995","copyright c 1995 2014","c 1995 2014 international","1995 2014 international business","2014 international business machines","so provided that the","the software and that","software and that both","that both the above","both the above copyright","in supporting documentation the","supporting documentation the software","documentation the software is","of this software except","this software except as","icu license icu 1 8","license icu 1 8 1","icu 1 8 1 and","1 8 1 and later","8 1 and later copyright","1 and later copyright and","and later copyright and permission","later copyright and permission notice","permission notice copyright c 1995","notice copyright c 1995 2014","copyright c 1995 2014 international","c 1995 2014 international business","1995 2014 international business machines","2014 international business machines corporation","others all rights reserved permission","do so provided that the","so provided that the above","of the software and that","the software and that both","software and that both the","and that both the above","that both the above copyright","both the above copyright notice","appear in supporting documentation the","in supporting documentation the software","supporting documentation the software is","documentation the software is provided","performance of this software except","of this software except as","this software except as contained"]},{"licenseTexts":["Independent JPEG Group License LEGAL ISSUES\n\nIn plain English:\n\n   1. We don't promise that this software works. (But if you find any bugs, please let us know!)\n\n   2. You can use this software for whatever you want. You don't have to pay us.\n\n   3. You may not pretend that you wrote this software. If you use it in a program, you must acknowledge somewhere in your documentation that you've used the IJG code.\n\nIn legalese:\n\nThe authors make NO WARRANTY or representation, either express or implied, with respect to this software, its quality, accuracy, merchantability, or fitness for a particular purpose. This software is provided \"AS IS\", and you, its user, assume the entire risk as to its quality and accuracy.\n\nThis software is copyright (C) 1991-1998, Thomas G. Lane. All Rights Reserved except as specified below.\n\nPermission is hereby granted to use, copy, modify, and distribute this software (or portions thereof) for any purpose, without fee, subject to these conditions:\n\n   (1) If any part of the source code for this software is distributed, then this README file must be included, with this copyright and no-warranty notice unaltered; and any additions, deletions, or changes to the original files must be clearly indicated in accompanying documentation.\n\n   (2) If only executable code is distributed, then the accompanying documentation must state that \"this software is based in part on the work of the Independent JPEG Group\".\n\n   (3) Permission for use of this software is granted only if the user accepts full responsibility for any undesirable consequences; the authors accept NO LIABILITY for damages of any kind.\n\nThese conditions apply to any software derived from or based on the IJG code, not just to the unmodified library. If you use our work, you ought to acknowledge us.\n\nPermission is NOT granted for the use of any IJG author's name or company name in advertising or publicity relating to this software or products derived from it. This software may be referred to only as \"the Independent JPEG Group's software\".\n\nWe specifically permit and encourage the use of this software as the basis of commercial products, provided that all warranty or liability claims are assumed by the product vendor.\n\nansi2knr.c is included in this distribution by permission of L. Peter Deutsch, sole proprietor of its copyright holder, Aladdin Enterprises of Menlo Park, CA. ansi2knr.c is NOT covered by the above copyright and conditions, but instead by the usual distribution terms of the Free Software Foundation; principally, that you must include source code if you redistribute it. (See the file ansi2knr.c for full details.) However, since ansi2knr.c is not needed as part of any program generated from the IJG code, this does not limit you more than the foregoing paragraphs do.\n\nThe Unix configuration script \"configure\" was produced with GNU Autoconf. It is copyright by the Free Software Foundation but is freely distributable. The same holds for its supporting scripts (config.guess, config.sub, ltconfig, ltmain.sh). Another support script, install-sh, is copyright by M.I.T. but is also freely distributable.\n\nIt appears that the arithmetic coding option of the JPEG spec is covered by patents owned by IBM, AT\u0026T, and Mitsubishi. Hence arithmetic coding cannot legally be used without obtaining one or more licenses. For this reason, support for arithmetic coding has been removed from the free JPEG software. (Since arithmetic coding provides only a marginal gain over the unpatented Huffman mode, it is unlikely that very many implementations will support it.) So far as we are aware, there are no patent restrictions on the remaining code.\n\nThe IJG distribution formerly included code to read and write GIF files. To avoid entanglement with the Unisys LZW patent, GIF reading support has been removed altogether, and the GIF writer has been simplified to produce \"uncompressed GIFs\". This technique does not use the LZW algorithm; the resulting GIF files are larger than usual, but are readable by all standard GIF decoders.\n\nWe are required to state that\n\n\"The Graphics Interchange Format(c) is the Copyright property of CompuServe Incorporated. GIF(sm) is a Service Mark property of CompuServe Incorporated.\""],"licenseIds":["IJG"],"keywords":["jpeg group license","group license legal","license legal issues","legal issues in","issues in plain","plain english 1","english 1 we","1 we don","software works but","works but if","but if you","you find any","find any bugs","any bugs please","bugs please let","us know 2","know 2 you","2 you can","want you don","have to pay","pay us 3","us 3 you","that you ve","you ve used","ve used the","used the ijg","ijg code in","code in legalese","in legalese the","legalese the authors","the authors make","authors make no","make no warranty","warranty or representation","or representation either","representation either express","implied with respect","software its quality","its quality accuracy","quality accuracy merchantability","accuracy merchantability or","particular purpose this","purpose this software","and you its","you its user","its user assume","user assume the","assume the entire","to its quality","its quality and","quality and accuracy","and accuracy this","accuracy this software","c 1991 1998","1991 1998 thomas","1998 thomas g","thomas g lane","g lane all","lane all rights","specified below permission","portions thereof for","to these conditions","these conditions 1","conditions 1 if","distributed then this","then this readme","this readme file","readme file must","with this copyright","copyright and no","and no warranty","no warranty notice","warranty notice unaltered","notice unaltered and","unaltered and any","and any additions","accompanying documentation 2","documentation 2 if","2 if only","if only executable","only executable code","executable code is","distributed then the","then the accompanying","the accompanying documentation","accompanying documentation must","documentation must state","must state that","state that this","jpeg group 3","group 3 permission","3 permission for","the user accepts","user accepts full","accepts full responsibility","full responsibility for","responsibility for any","for any undesirable","any undesirable consequences","undesirable consequences the","consequences the authors","the authors accept","authors accept no","accept no liability","kind these conditions","on the ijg","ijg code not","not just to","just to the","to the unmodified","the unmodified library","unmodified library if","work you ought","you ought to","ought to acknowledge","to acknowledge us","acknowledge us permission","us permission is","is not granted","not granted for","for the use","of any ijg","any ijg author","ijg author s","author s name","s name or","name or company","or company name","company name in","name in advertising","from it this","it this software","may be referred","referred to only","to only as","only as the","as the independent","jpeg group s","group s software","s software we","software we specifically","software as the","basis of commercial","of commercial products","commercial products provided","products provided that","that all warranty","all warranty or","warranty or liability","or liability claims","liability claims are","claims are assumed","are assumed by","assumed by the","by the product","the product vendor","product vendor ansi2knr","vendor ansi2knr c","c is included","this distribution by","distribution by permission","by permission of","permission of l","of l peter","l peter deutsch","peter deutsch sole","deutsch sole proprietor","sole proprietor of","proprietor of its","copyright holder aladdin","holder aladdin enterprises","aladdin enterprises of","enterprises of menlo","of menlo park","park ca ansi2knr","ca ansi2knr c","by the above","copyright and conditions","and conditions but","conditions but instead","but instead by","instead by the","by the usual","the usual distribution","usual distribution terms","software foundation principally","foundation principally that","principally that you","must include source","you redistribute it","redistribute it see","it see the","the file ansi2knr","file ansi2knr c","ansi2knr c for","c for full","for full details","full details however","details however since","however since ansi2knr"]},{"licenseTexts":["IPA Font License Agreement v1.0\n\nThe Licensor provides the Licensed Program (as defined in Article 1 below) under the terms of this license agreement (\"Agreement\"). Any use, reproduction or distribution of the Licensed Program, or any exercise of rights under this Agreement by a Recipient (as defined in Article 1 below) constitutes the Recipient's acceptance of this Agreement.\n\nArticle 1 (Definitions)\n\n   1. \"Digital Font Program\" shall mean a computer program containing, or used to render or display fonts.\n\n   2. \"Licensed Program\" shall mean a Digital Font Program licensed by the Licensor under this Agreement.\n\n   3. \"Derived Program\" shall mean a Digital Font Program created as a result of a modification, addition, deletion, replacement or any other adaptation to or of a part or all of the Licensed Program, and includes a case where a Digital Font Program newly created by retrieving font information from a part or all of the Licensed Program or Embedded Fonts from a Digital Document File with or without modification of the retrieved font information.\n\n   4. \"Digital Content\" shall mean products provided to end users in the form of digital data, including video content, motion and/or still pictures, TV programs or other broadcasting content and products consisting of character text, pictures, photographic images, graphic symbols and/or the like.\n\n   5. \"Digital Document File\" shall mean a PDF file or other Digital Content created by various software programs in which a part or all of the Licensed Program becomes embedded or contained in the file for the display of the font (\"Embedded Fonts\"). Embedded Fonts are used only in the display of characters in the particular Digital Document File within which they are embedded, and shall be distinguished from those in any Digital Font Program, which may be used for display of characters outside that particular Digital Document File.\n\n   6. \"Computer\" shall include a server in this Agreement.\n\n   7. \"Reproduction and Other Exploitation\" shall mean reproduction, transfer, distribution, lease, public transmission, presentation, exhibition, adaptation and any other exploitation.\n\n   8. \"Recipient\" shall mean anyone who receives the Licensed Program under this Agreement, including one that receives the Licensed Program from a Recipient.\n\nArticle 2 (Grant of License)\n\nThe Licensor grants to the Recipient a license to use the Licensed Program in any and all countries in accordance with each of the provisions set forth in this Agreement. However, any and all rights underlying in the Licensed Program shall be held by the Licensor. In no sense is this Agreement intended to transfer any right relating to the Licensed Program held by the Licensor except as specifically set forth herein or any right relating to any trademark, trade name, or service mark to the Recipient.\n\n   1. The Recipient may install the Licensed Program on any number of Computers and use the same in accordance with the provisions set forth in this Agreement.\n\n   2. The Recipient may use the Licensed Program, with or without modification in printed materials or in Digital Content as an expression of character texts or the like.\n\n   3. The Recipient may conduct Reproduction and Other Exploitation of the printed materials and Digital Content created in accordance with the preceding Paragraph, for commercial or non-commercial purposes and in any form of media including but not limited to broadcasting, communication and various recording media.\n\n   4. If any Recipient extracts Embedded Fonts from a Digital Document File to create a Derived Program, such Derived Program shall be subject to the terms of this agreement.\n\n   5. If any Recipient performs Reproduction or Other Exploitation of a Digital Document File in which Embedded Fonts of the Licensed Program are used only for rendering the Digital Content within such Digital Document File then such Recipient shall have no further obligations under this Agreement in relation to such actions.\n\n   6. The Recipient may reproduce the Licensed Program as is without modification and transfer such copies, publicly transmit or otherwise redistribute the Licensed Program to a third party for commercial or non-commercial purposes (\"Redistribute\"), in accordance with the provisions set forth in Article 3 Paragraph 2.\n\n   7. The Recipient may create, use, reproduce and/or Redistribute a Derived Program under the terms stated above for the Licensed Program: provided, that the Recipient shall follow the provisions set forth in Article 3 Paragraph 1 when Redistributing the Derived Program.\n\nArticle 3 (Restriction)\n\nThe license granted in the preceding Article shall be subject to the following restrictions:\n\n   1. If a Derived Program is Redistributed pursuant to Paragraph 4 and 7 of the preceding Article, the following conditions must be met :\n\n      (1) The following must be also Redistributed together with the Derived Program, or be made available online or by means of mailing mechanisms in exchange for a cost which does not exceed the total costs of postage, storage medium and handling fees:\n\n         (a) a copy of the Derived Program; and\n\n         (b) any additional file created by the font developing program in the course of creating the Derived Program that can be used for further modification of the Derived Program, if any.\n\n      (2) It is required to also Redistribute means to enable recipients of the Derived Program to replace the Derived Program with the Licensed Program first released under this License (the \"Original Program\"). Such means may be to provide a difference file from the Original Program, or instructions setting out a method to replace the Derived Program with the Original Program.\n\n      (3) The Recipient must license the Derived Program under the terms and conditions of this Agreement.\n\n      (4) No one may use or include the name of the Licensed Program as a program name, font name or file name of the Derived Program.\n\n      (5) Any material to be made available online or by means of mailing a medium to satisfy the requirements of this paragraph may be provided, verbatim, by any party wishing to do so.\n\n   2. If the Recipient Redistributes the Licensed Program pursuant to Paragraph 6 of the preceding Article, the Recipient shall meet all of the following conditions:\n\n      (1) The Recipient may not change the name of the Licensed Program.\n\n      (2) The Recipient may not alter or otherwise modify the Licensed Program.\n\n      (3) The Recipient must attach a copy of this Agreement to the Licensed Program.\n\n   3. THIS LICENSED PROGRAM IS PROVIDED BY THE LICENSOR \"AS IS\" AND ANY EXPRESSED OR IMPLIED WARRANTY AS TO THE LICENSED PROGRAM OR ANY DERIVED PROGRAM, INCLUDING, BUT NOT LIMITED TO, WARRANTIES OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE, ARE DISCLAIMED. IN NO EVENT SHALL THE LICENSOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXTENDED, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO; PROCUREMENT OF SUBSTITUTED GOODS OR SERVICE; DAMAGES ARISING FROM SYSTEM FAILURE; LOSS OR CORRUPTION OF EXISTING DATA OR PROGRAM; LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE INSTALLATION, USE, THE REPRODUCTION OR OTHER EXPLOITATION OF THE LICENSED PROGRAM OR ANY DERIVED PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\n   4. The Licensor is under no obligation to respond to any technical questions or inquiries, or provide any other user support in connection with the installation, use or the Reproduction and Other Exploitation of the Licensed Program or Derived Programs thereof.\n\nArticle 4 (Termination of Agreement)\n\n   1. The term of this Agreement shall begin from the time of receipt of the Licensed Program by the Recipient and shall continue as long as the Recipient retains any such Licensed Program in any way.\n\n   2. Notwithstanding the provision set forth in the preceding Paragraph, in the event of the breach of any of the provisions set forth in this Agreement by the Recipient, this Agreement shall automatically terminate without any notice. In the case of such termination, the Recipient may not use or conduct Reproduction and Other Exploitation of the Licensed Program or a Derived Program: provided that such termination shall not affect any rights of any other Recipient receiving the Licensed Program or the Derived Program from such Recipient who breached this Agreement.\n\nArticle 5 (Governing Law)\n\n   1. IPA may publish revised and/or new versions of this License. In such an event, the Recipient may select either this Agreement or any subsequent version of the Agreement in using, conducting the Reproduction and Other Exploitation of, or Redistributing the Licensed Program or a Derived Program. Other matters not specified above shall be subject to the Copyright Law of Japan and other related laws and regulations of Japan.\n\n   2. This Agreement shall be construed under the laws of Japan."],"licenseIds":["IPA"],"keywords":["ipa font license","font license agreement","license agreement v1","v1 0 the","0 the licensor","provides the licensed","1 below under","below under the","agreement agreement any","or any exercise","agreement by a","recipient as defined","1 below constitutes","below constitutes the","agreement article 1","definitions 1 digital","1 digital font","font program shall","mean a computer","computer program containing","program containing or","containing or used","to render or","render or display","or display fonts","display fonts 2","fonts 2 licensed","2 licensed program","font program licensed","program licensed by","agreement 3 derived","3 derived program","font program created","program created as","created as a","of a modification","a modification addition","modification addition deletion","addition deletion replacement","deletion replacement or","replacement or any","any other adaptation","other adaptation to","adaptation to or","to or of","of a part","licensed program and","program and includes","and includes a","includes a case","a case where","case where a","where a digital","font program newly","program newly created","newly created by","created by retrieving","by retrieving font","retrieving font information","font information from","information from a","from a part","program or embedded","or embedded fonts","document file with","of the retrieved","the retrieved font","retrieved font information","font information 4","information 4 digital","4 digital content","digital content shall","content shall mean","shall mean products","mean products provided","products provided to","provided to end","end users in","users in the","form of digital","of digital data","digital data including","data including video","including video content","video content motion","content motion and","motion and or","and or still","or still pictures","still pictures tv","pictures tv programs","tv programs or","or other broadcasting","other broadcasting content","broadcasting content and","content and products","and products consisting","products consisting of","consisting of character","of character text","character text pictures","text pictures photographic","pictures photographic images","photographic images graphic","images graphic symbols","graphic symbols and","symbols and or","the like 5","like 5 digital","5 digital document","document file shall","file shall mean","mean a pdf","a pdf file","pdf file or","or other digital","other digital content","content created by","created by various","by various software","various software programs","software programs in","programs in which","in which a","which a part","licensed program becomes","program becomes embedded","becomes embedded or","embedded or contained","the file for","for the display","the font embedded","font embedded fonts","embedded fonts embedded","fonts embedded fonts","embedded fonts are","fonts are used","used only in","in the display","of characters in","characters in the","in the particular","the particular digital","document file within","file within which","within which they","which they are","they are embedded","are embedded and","embedded and shall","shall be distinguished","be distinguished from","distinguished from those","those in any","in any digital","any digital font","font program which","program which may","used for display","for display of","of characters outside","characters outside that","outside that particular","that particular digital","document file 6","file 6 computer","6 computer shall","computer shall include","include a server","a server in","server in this","agreement 7 reproduction","7 reproduction and","other exploitation shall","exploitation shall mean","mean reproduction transfer","reproduction transfer distribution","transfer distribution lease","distribution lease public","lease public transmission","public transmission presentation","transmission presentation exhibition","presentation exhibition adaptation","exhibition adaptation and","adaptation and any","any other exploitation","other exploitation 8","exploitation 8 recipient","8 recipient shall","recipient shall mean","shall mean anyone","mean anyone who","licensed program under","agreement including one","including one that","one that receives","that receives the","licensed program from","program from a","from a recipient"]},{"licenseTexts":["IBM Public License Version 1.0\n\nTHE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS IBM\n\nPUBLIC LICENSE (\"AGREEMENT\"). ANY USE, REPRODUCTION OR DISTRIBUTION\n\nOF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.\n\n   1. DEFINITIONS\n\n   \"Contribution\" means:\n\n      a. in the case of International Business Machines Corporation (\"IBM\"), the Original Program, and\n\n      b. in the case of each Contributor,\n\n         i. changes to the Program, and\n\n         ii. additions to the Program; where such changes and/or additions to the Program originate from and are distributed by that particular Contributor. A Contribution 'originates' from a Contributor if it was added to the Program by such Contributor itself or anyone acting on such Contributor's behalf. Contributions do not include additions to the Program which:\n\n            (i) are separate modules of software distributed in conjunction with\n\n            the Program under their own license agreement, and (ii) are not\n\n            derivative works of the Program.\n\n   \"Contributor\" means IBM and any other entity that distributes the Program.\n\n   \"Licensed Patents \" mean patent claims licensable by a Contributor which are necessarily infringed by the use or sale of its Contribution alone or when combined with the Program.\n\n   \"Original Program\" means the original version of the software accompanying this Agreement as released by IBM, including source code, object code and documentation, if any.\n\n   \"Program\" means the Original Program and Contributions.\n\n   \"Recipient\" means anyone who receives the Program under this Agreement, including all Contributors.\n\n   2. GRANT OF RIGHTS\n\n      a. Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide, royalty-free copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, distribute and sublicense the Contribution of such Contributor, if any, and such derivative works, in source code and object code form.\n\n      b. Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide, royalty-free patent license under Licensed Patents to make, use, sell, offer to sell, import and otherwise transfer the Contribution of such Contributor, if any, in source code and object code form. This patent license shall apply to the combination of the Contribution and the Program if, at the time the Contribution is added by the Contributor, such addition of the Contribution causes such combination to be covered by the Licensed Patents. The patent license shall not apply to any other combinations which include the Contribution. No hardware per se is licensed hereunder.\n\n      c. Recipient understands that although each Contributor grants the\n\n      licenses to its Contributions set forth herein, no assurances are\n\n      provided by any Contributor that the Program does not infringe the\n\n      patent or other intellectual property rights of any other entity.\n\n      Each Contributor disclaims any liability to Recipient for claims\n\n      brought by any other entity based on infringement of intellectual\n\n      property rights or otherwise. As a condition to exercising the\n\n      rights and licenses granted hereunder, each Recipient hereby assumes\n\n      sole responsibility to secure any other intellectual property rights\n\n      needed, if any. For example, if a third party patent license is\n\n      required to allow Recipient to distribute the Program, it is\n\n      Recipient's responsibility to acquire that license before\n\n      distributing the Program.\n\n      d. Each Contributor represents that to its knowledge it has\n\n      sufficient copyright rights in its Contribution, if any, to grant the\n\n      copyright license set forth in this Agreement.\n\n   3. REQUIREMENTS\n\n   A Contributor may choose to distribute the Program in object code form under its own license agreement, provided that:\n\n      a. it complies with the terms and conditions of this Agreement; and\n\n      b. its license agreement:\n\n         i. effectively disclaims on behalf of all Contributors all warranties and conditions, express and implied, including warranties or conditions of title and non-infringement, and implied warranties or conditions of merchantability and fitness for a particular purpose;\n\n         ii. effectively excludes on behalf of all Contributors all liability for damages, including direct, indirect, special, incidental and consequential damages, such as lost profits;\n\n         iii. states that any provisions which differ from this Agreement are offered by that Contributor alone and not by any other party; and\n\n         iv. states that source code for the Program is available from such Contributor, and informs licensees how to obtain it in a reasonable manner on or through a medium customarily used for software exchange.\n\n   When the Program is made available in source code form:\n\n      a. it must be made available under this Agreement; and\n\n      b. a copy of this Agreement must be included with each copy of the Program.\n\n   Each Contributor must include the following in a conspicuous location in the Program:\n\n   Copyright (C) 1996, 1999 International Business Machines Corporation and others. All Rights Reserved.\n\n   In addition, each Contributor must identify itself as the originator of its Contribution, if any, in a manner that reasonably allows subsequent Recipients to identify the originator of the Contribution.\n\n   4. COMMERCIAL DISTRIBUTION\n\n   Commercial distributors of software may accept certain responsibilities with respect to end users, business partners and the like. While this license is intended to facilitate the commercial use of the Program, the Contributor who includes the Program in a commercial product offering should do so in a manner which does not create potential liability for other Contributors. Therefore, if a Contributor includes the Program in a commercial product offering, such Contributor (\"Commercial Contributor\") hereby agrees to defend and indemnify every other Contributor (\"Indemnified Contributor\") against any losses, damages and costs (collectively \"Losses\") arising from claims, lawsuits and other legal actions brought by a third party against the Indemnified Contributor to the extent caused by the acts or omissions of such Commercial Contributor in connection with its distribution of the Program in a commercial product offering. The obligations in this section do not apply to any claims or Losses relating to any actual or alleged intellectual property infringement. In order to qualify, an Indemnified Contributor must: a) promptly notify the Commercial Contributor in writing of such claim, and b) allow the Commercial Contributor to control, and cooperate with the Commercial Contributor in, the defense and any related settlement negotiations. The Indemnified Contributor may participate in any such claim at its own expense.\n\n   For example, a Contributor might include the Program in a commercial product offering, Product X. That Contributor is then a Commercial Contributor. If that Commercial Contributor then makes performance claims, or offers warranties related to Product X, those performance claims and warranties are such Commercial Contributor's responsibility alone. Under this section, the Commercial Contributor would have to defend claims against the other Contributors related to those performance claims and warranties, and if a court requires any other Contributor to pay any damages as a result, the Commercial Contributor must pay those damages.\n\n   5. NO WARRANTY\n\n   EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED ON AN \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely responsible for determining the appropriateness of using and distributing the Program and assumes all risks associated with its exercise of rights under this Agreement, including but not limited to the risks and costs of program errors, compliance with applicable laws, damage to or loss of data, programs or equipment, and unavailability or interruption of operations.\n\n   6. DISCLAIMER OF LIABILITY\n\n   EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\n   7. GENERAL\n\n   If any provision of this Agreement is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this Agreement, and without further action by the parties hereto, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.\n\n   If Recipient institutes patent litigation against a Contributor with respect to a patent applicable to software (including a cross-claim or counterclaim in a lawsuit), then any patent licenses granted by that Contributor to such Recipient under this Agreement shall terminate as of the date such litigation is filed. In addition, if Recipient institutes patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Program itself (excluding combinations of the Program with other software or hardware) infringes such Recipient's patent(s), then such Recipient's rights granted under Section 2(b) shall terminate as of the date such litigation is filed.\n\n   All Recipient's rights under this Agreement shall terminate if it fails to comply with any of the material terms or conditions of this Agreement and does not cure such failure in a reasonable period of time after becoming aware of such noncompliance. If all Recipient's rights under this Agreement terminate, Recipient agrees to cease use and distribution of the Program as soon as reasonably practicable. However, Recipient's obligations under this Agreement and any licenses granted by Recipient relating to the Program shall continue and survive.\n\n   IBM may publish new versions (including revisions) of this Agreement from time to time. Each new version of the Agreement will be given a distinguishing version number. The Program (including Contributions) may always be distributed subject to the version of the Agreement under which it was received. In addition, after a new version of the Agreement is published, Contributor may elect to distribute the Program (including its Contributions) under the new version. No one other than IBM has the right to modify this Agreement. Except as expressly stated in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to the intellectual property of any Contributor under this Agreement, whether expressly, by implication, estoppel or otherwise. All rights in the Program not expressly granted under this Agreement are reserved.\n\n   This Agreement is governed by the laws of the State of New York and the intellectual property laws of the United States of America. No party to this Agreement will bring a legal action under this Agreement more than one year after the cause of action arose. Each party waives its rights to a jury trial in any resulting litigation."],"licenseIds":["IPL-1.0"],"keywords":["of this ibm","this ibm public","case of international","of international business","machines corporation ibm","corporation ibm the","ibm the original","contributor means ibm","means ibm and","ibm and any","released by ibm","by ibm including","ibm including source","and contributions recipient","contributions recipient means","1996 1999 international","1999 international business","and survive ibm","survive ibm may","ibm may publish","other than ibm","than ibm has","ibm has the","ibm public license version","terms of this ibm","of this ibm public","this ibm public license","ibm public license agreement","the case of international","case of international business","of international business machines","business machines corporation ibm","machines corporation ibm the","corporation ibm the original","ibm the original program","program contributor means ibm","contributor means ibm and","means ibm and any","ibm and any other","other entity that distributes","as released by ibm","released by ibm including","by ibm including source","ibm including source code","program and contributions recipient","and contributions recipient means","contributions recipient means anyone","of the program each","each contributor must include","contributor must include the","program copyright c 1996","c 1996 1999 international","1996 1999 international business","1999 international business machines","reserved in addition each","continue and survive ibm","and survive ibm may","survive ibm may publish","ibm may publish new","one other than ibm","other than ibm has","than ibm has the","ibm has the right","ibm public license version 1","the terms of this ibm","terms of this ibm public","of this ibm public license","this ibm public license agreement","ibm public license agreement any","in the case of international","the case of international business","case of international business machines","of international business machines corporation","international business machines corporation ibm","business machines corporation ibm the","machines corporation ibm the original","corporation ibm the original program","ibm the original program and","the program contributor means ibm","program contributor means ibm and","contributor means ibm and any","means ibm and any other","ibm and any other entity","any other entity that distributes","other entity that distributes the","agreement as released by ibm","as released by ibm including","released by ibm including source","by ibm including source code","ibm including source code object","original program and contributions recipient","program and contributions recipient means","and contributions recipient means anyone","contributions recipient means anyone who","copy of the program each","of the program each contributor","program each contributor must include","each contributor must include the","contributor must include the following","the program copyright c 1996","program copyright c 1996 1999","copyright c 1996 1999 international","c 1996 1999 international business","1996 1999 international business machines","1999 international business machines corporation","others all rights reserved in","rights reserved in addition each","reserved in addition each contributor","shall continue and survive ibm","continue and survive ibm may","and survive ibm may publish","survive ibm may publish new","ibm may publish new versions","no one other than ibm","one other than ibm has","other than ibm has the","than ibm has the right","ibm has the right to"]},{"licenseTexts":["ISC License Copyright (c) 2004-2010 by Internet Systems Consortium, Inc. (\"ISC\")\n\nCopyright (c) 1995-2003 by Internet Software Consortium\n\nPermission to use, copy, modify, and /or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND ISC DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE."],"licenseIds":["ISC"],"keywords":["isc license copyright","c 2004 2010","2004 2010 by","2010 by internet","by internet systems","internet systems consortium","systems consortium inc","consortium inc isc","inc isc copyright","isc copyright c","c 1995 2003","1995 2003 by","2003 by internet","by internet software","internet software consortium","software consortium permission","consortium permission to","is and isc","and isc disclaims","isc disclaims all","event shall isc","shall isc be","isc be liable","isc license copyright c","license copyright c 2004","copyright c 2004 2010","c 2004 2010 by","2004 2010 by internet","2010 by internet systems","by internet systems consortium","internet systems consortium inc","systems consortium inc isc","consortium inc isc copyright","inc isc copyright c","isc copyright c 1995","copyright c 1995 2003","c 1995 2003 by","1995 2003 by internet","2003 by internet software","by internet software consortium","internet software consortium permission","software consortium permission to","consortium permission to use","as is and isc","is and isc disclaims","and isc disclaims all","isc disclaims all warranties","no event shall isc","event shall isc be","shall isc be liable","isc be liable for","isc license copyright c 2004","license copyright c 2004 2010","copyright c 2004 2010 by","c 2004 2010 by internet","2004 2010 by internet systems","2010 by internet systems consortium","by internet systems consortium inc","internet systems consortium inc isc","systems consortium inc isc copyright","consortium inc isc copyright c","inc isc copyright c 1995","isc copyright c 1995 2003","copyright c 1995 2003 by","c 1995 2003 by internet","1995 2003 by internet software","2003 by internet software consortium","by internet software consortium permission","internet software consortium permission to","software consortium permission to use","consortium permission to use copy","provided as is and isc","as is and isc disclaims","is and isc disclaims all","and isc disclaims all warranties","isc disclaims all warranties with","in no event shall isc","no event shall isc be","event shall isc be liable","shall isc be liable for","isc be liable for any"]},{"licenseTexts":["Before we get to the text of the license, lets just review what the license says in simple terms:\n\nIt allows you to:\n\n   * freely download and use ImageMagick software, in whole or in part, for personal, company internal, or commercial purposes;\n\n   * use ImageMagick software in packages or distributions that you create;\n\n   * link against a library under a different license;\n\n   * link code under a different license against a library under this license;\n\n   * merge code into a work under a different license;\n\n   * extend patent grants to any code using code under this license;\n\n   * and extend patent protection.\n\nIt forbids you to:\n\n   * redistribute any piece of ImageMagick-originated software without proper attribution;\n\n   * use any marks owned by ImageMagick Studio LLC in any way that might state or imply that ImageMagick Studio LLC endorses your distribution;\n\n   * use any marks owned by ImageMagick Studio LLC in any way that might state or imply that you created the ImageMagick software in question.\n\nIt requires you to:\n\n   * include a copy of the license in any redistribution you may make that includes ImageMagick software;\n\n   * provide clear attribution to ImageMagick Studio LLC for any distributions that include ImageMagick software.\n\nIt does not require you to:\n\n   * include the source of the ImageMagick software itself, or of any modifications you may have made to it, in any redistribution you may assemble that includes it;\n\n   * submit changes that you make to the software back to the ImageMagick Studio LLC (though such feedback is encouraged).\n\nA few other clarifications include:\n\n   * ImageMagick is freely available without charge;\n\n   * you may include ImageMagick on a DVD as long as you comply with the terms of the license;\n\n   * you can give modified code away for free or sell it under the terms of the ImageMagick license or distribute the result under a different license, but you need to acknowledge the use of the ImageMagick software;\n\n   * the license is compatible with the GPL V3.\n\n   * when exporting the ImageMagick software, review its export classification.\n\nTerms and Conditions for Use, Reproduction, and Distribution\n\nThe legally binding and authoritative terms and conditions for use, reproduction, and distribution of ImageMagick follow: Copyright 1999-2013 ImageMagick Studio LLC, a non-profit organization dedicated to making software imaging solutions freely available.\n\n   1. Definitions.\n\n   License shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.\n\n   Licensor shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.\n\n   Legal Entity shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, control means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.\n\n   You (or Your) shall mean an individual or Legal Entity exercising permissions granted by this License.\n\n   Source form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.\n\n   Object form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.\n\n   Work shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).\n\n   Derivative Works shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.\n\n   Contribution shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, \"submitted\" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as Not a Contribution.\n\n   Contributor shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.\n\n   2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.\n\n   3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.\n\n   4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:\n\n      a. You must give any other recipients of the Work or Derivative Works a copy of this License; and\n\n      b. You must cause any modified files to carry prominent notices stating that You changed the files; and\n\n      c. You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and\n\n      d. If the Work includes a \"NOTICE\" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.\n\n   You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.\n\n   5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.\n\n   6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.\n\n   7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an AS IS BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.\n\n   8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.\n\n   9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. How to Apply the License to your Work\n\nTo apply the ImageMagick License to your work, attach the following boilerplate notice, with the fields enclosed by brackets \"[]\" replaced with your own identifying information (don't include the brackets). The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same \"printed page\" as the copyright notice for easier identification within third-party archives.\n\nCopyright [yyyy] [name of copyright owner]\n\nLicensed under the ImageMagick License (the \"License\"); you may not use this file except in compliance with the License. You may obtain a copy of the License at\n\nhttp://www.imagemagick.org/script/license.php\n\nUnless required by applicable law or agreed to in writing, software distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License."],"licenseIds":["ImageMagick"],"keywords":["before we get","we get to","get to the","the license lets","license lets just","lets just review","just review what","review what the","what the license","the license says","license says in","says in simple","in simple terms","simple terms it","terms it allows","it allows you","to freely download","freely download and","download and use","and use imagemagick","part for personal","for personal company","personal company internal","company internal or","internal or commercial","or commercial purposes","commercial purposes use","purposes use imagemagick","software in packages","in packages or","packages or distributions","or distributions that","distributions that you","you create link","create link against","link against a","library under a","different license link","license link code","link code under","different license against","this license merge","license merge code","merge code into","code into a","into a work","a work under","different license extend","license extend patent","extend patent grants","patent grants to","to any code","any code using","code using code","using code under","license and extend","and extend patent","extend patent protection","patent protection it","protection it forbids","it forbids you","forbids you to","you to redistribute","redistribute any piece","piece of imagemagick","of imagemagick originated","imagemagick originated software","originated software without","software without proper","without proper attribution","proper attribution use","attribution use any","imply that imagemagick","that imagemagick studio","studio llc endorses","llc endorses your","endorses your distribution","your distribution use","distribution use any","that you created","you created the","created the imagemagick","software in question","in question it","question it requires","it requires you","may make that","make that includes","that includes imagemagick","includes imagemagick software","imagemagick software provide","software provide clear","provide clear attribution","clear attribution to","attribution to imagemagick","to imagemagick studio","studio llc for","llc for any","for any distributions","any distributions that","distributions that include","that include imagemagick","include imagemagick software","imagemagick software it","software it does","not require you","require you to","imagemagick software itself","software itself or","itself or of","may have made","have made to","made to it","to it in","you may assemble","may assemble that","assemble that includes","that includes it","includes it submit","it submit changes","submit changes that","changes that you","the software back","software back to","to the imagemagick","the imagemagick studio","studio llc though","llc though such","though such feedback","such feedback is","feedback is encouraged","is encouraged a","encouraged a few","a few other","few other clarifications","other clarifications include","clarifications include imagemagick","include imagemagick is","imagemagick is freely","freely available without","without charge you","charge you may","may include imagemagick","include imagemagick on","imagemagick on a","on a dvd","a dvd as","dvd as long","license you can","you can give","can give modified","give modified code","modified code away","code away for","away for free","for free or","free or sell","or sell it","sell it under","imagemagick license or","license or distribute","the result under","result under a","different license but","but you need","need to acknowledge","acknowledge the use","imagemagick software the","software the license","license is compatible","is compatible with","the gpl v3","gpl v3 when","v3 when exporting","when exporting the","exporting the imagemagick","imagemagick software review","software review its","review its export","its export classification","export classification terms","classification terms and","and distribution the","distribution the legally","the legally binding","legally binding and","binding and authoritative","and authoritative terms","authoritative terms and","distribution of imagemagick","of imagemagick follow","imagemagick follow copyright","follow copyright 1999","copyright 1999 2013","1999 2013 imagemagick","2013 imagemagick studio","studio llc a","llc a non","a non profit","non profit organization"]},{"licenseTexts":["Imlib2 License\n\nPermission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the \"Software\"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all copies of the Software and its Copyright notices. In addition publicly documented acknowledgment must be given that this software has been used if no source code of this software is made available publicly. Making the source available publicly means including the source for this software with the distribution, or a method to get this software via some reasonable mechanism (electronic transfer via a network or media) as well as making an offer to supply the source on request. This Copyright notice serves as an offer to supply the source on on request as well. Instead of this, supplying acknowledgments of use of this software in either Copyright notices, Manuals, Publicity and Marketing documents or any documentation provided with any product containing this software. This License does not apply to any software that links to the libraries provided by this software (statically or dynamically), but only to the software provided.\n\nPlease see the COPYING-PLAIN for a plain-english explanation of this notice and its intent.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE."],"licenseIds":["Imlib2"],"keywords":["imlib2 license permission","license permission is","available publicly making","publicly making the","making the source","the source available","source available publicly","available publicly means","publicly means including","means including the","source for this","distribution or a","or a method","method to get","to get this","get this software","this software via","software via some","via some reasonable","some reasonable mechanism","reasonable mechanism electronic","mechanism electronic transfer","electronic transfer via","transfer via a","a network or","network or media","or media as","media as well","well as making","as making an","making an offer","source on request","on request this","request this copyright","copyright notice serves","notice serves as","serves as an","as an offer","source on on","on on request","on request as","request as well","as well instead","well instead of","of this supplying","this supplying acknowledgments","supplying acknowledgments of","acknowledgments of use","software in either","notice and its","and its intent","its intent the","imlib2 license permission is","license permission is hereby","made available publicly making","available publicly making the","publicly making the source","making the source available","the source available publicly","source available publicly means","available publicly means including","publicly means including the","means including the source","including the source for","the source for this","source for this software","for this software with","this software with the","software with the distribution","with the distribution or","the distribution or a","distribution or a method","or a method to","a method to get","method to get this","to get this software","get this software via","this software via some","software via some reasonable","via some reasonable mechanism","some reasonable mechanism electronic","reasonable mechanism electronic transfer","mechanism electronic transfer via","electronic transfer via a","transfer via a network","via a network or","a network or media","network or media as","or media as well","media as well as","as well as making","well as making an","as making an offer","making an offer to","the source on request","source on request this","on request this copyright","request this copyright notice","this copyright notice serves","copyright notice serves as","notice serves as an","serves as an offer","as an offer to","the source on on","source on on request","on on request as","on request as well","request as well instead","as well instead of","well instead of this","instead of this supplying","of this supplying acknowledgments","this supplying acknowledgments of","supplying acknowledgments of use","acknowledgments of use of","this software in either","software in either copyright","this notice and its","notice and its intent","and its intent the","its intent the software","imlib2 license permission is hereby","license permission is hereby granted","is made available publicly making","made available publicly making the","available publicly making the source","publicly making the source available","making the source available publicly","the source available publicly means","source available publicly means including","available publicly means including the","publicly means including the source","means including the source for","including the source for this","the source for this software","source for this software with","for this software with the","this software with the distribution","software with the distribution or","with the distribution or a","the distribution or a method","distribution or a method to","or a method to get","a method to get this","method to get this software","to get this software via","get this software via some","this software via some reasonable","software via some reasonable mechanism","via some reasonable mechanism electronic","some reasonable mechanism electronic transfer","reasonable mechanism electronic transfer via","mechanism electronic transfer via a","electronic transfer via a network","transfer via a network or","via a network or media","a network or media as","network or media as well","or media as well as","media as well as making","as well as making an","well as making an offer","as making an offer to","making an offer to supply","supply the source on request","the source on request this","source on request this copyright","on request this copyright notice","request this copyright notice serves","this copyright notice serves as","copyright notice serves as an","notice serves as an offer","serves as an offer to","as an offer to supply","supply the source on on","the source on on request","source on on request as","on on request as well","on request as well instead","request as well instead of","as well instead of this","well instead of this supplying","instead of this supplying acknowledgments","of this supplying acknowledgments of","this supplying acknowledgments of use","supplying acknowledgments of use of","acknowledgments of use of this","of this software in either","this software in either copyright","software in either copyright notices","of this notice and its","this notice and its intent","notice and its intent the","and its intent the software","its intent the software is"]},{"licenseTexts":["Info-ZIP License Copyright (c) 1990-2009 Info-ZIP. All rights reserved.\n\nFor the purposes of this copyright and license, \"Info-ZIP\" is defined as the following set of individuals:\n\nMark Adler, John Bush, Karl Davis, Harald Denker, Jean-Michel Dubois, Jean-loup Gailly, Hunter Goatley, Ed Gordon, Ian Gorman, Chris Herborth, Dirk Haase, Greg Hartwig, Robert Heath, Jonathan Hudson, Paul Kienitz, David Kirschbaum, Johnny Lee, Onno van der Linden, Igor Mandrichenko, Steve P. Miller, Sergio Monesi, Keith Owens, George Petrov, Greg Roelofs, Kai Uwe Rommel, Steve Salisbury, Dave Smith, Steven M. Schweda, Christian Spieler, Cosmin Truta, Antoine Verheijen, Paul von Behren, Rich Wales, Mike White.\n\nThis software is provided \"as is,\" without warranty of any kind, express or implied. In no event shall Info-ZIP or its contributors be held liable for any direct, indirect, incidental, special or consequential damages arising out of the use of or inability to use this software.\n\nPermission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the above disclaimer and the following restrictions:\n\n   * Redistributions of source code (in whole or in part) must retain the above copyright notice, definition, disclaimer, and this list of conditions.\n\n   * Redistributions in binary form (compiled executables and libraries) must reproduce the above copyright notice, definition, disclaimer, and this list of conditions in documentation and/or other materials provided with the distribution. Additional documentation is not needed for executables where a command line license option provides these and a note regarding this option is in the executable's startup banner. The sole exception to this condition is redistribution of a standard UnZipSFX binary (including SFXWiz) as part of a self-extracting archive; that is permitted without inclusion of this license, as long as the normal SFX banner has not been removed from the binary or disabled.\n\n   * Altered versions--including, but not limited to, ports to new operating systems, existing ports with new graphical interfaces, versions with modified or added functionality, and dynamic, shared, or static library versions not from Info-ZIP--must be plainly marked as such and must not be misrepresented as being the original source or, if binaries, compiled from the original source. Such altered versions also must not be misrepresented as being Info-ZIP releases--including, but not limited to, labeling of the altered versions with the names \"Info-ZIP\" (or any variation thereof, including, but not limited to, different capitalizations), \"Pocket UnZip,\" \"WiZ\" or \"MacZip\" without the explicit permission of Info-ZIP. Such altered versions are further prohibited from misrepresentative use of the Zip-Bugs or Info-ZIP e-mail addresses or the Info-ZIP URL(s), such as to imply Info-ZIP will provide support for the altered versions.\n\n   * Info-ZIP retains the right to use the names \"Info-ZIP,\" \"Zip,\" \"UnZip,\" \"UnZipSFX,\" \"WiZ,\" \"Pocket UnZip,\" \"Pocket Zip,\" and \"MacZip\" for its own source and binary releases."],"licenseIds":["Info-ZIP"],"keywords":["info zip license","zip license copyright","c 1990 2009","1990 2009 info","2009 info zip","info zip all","zip all rights","reserved for the","and license info","license info zip","info zip is","zip is defined","of individuals mark","individuals mark adler","mark adler john","adler john bush","john bush karl","bush karl davis","karl davis harald","davis harald denker","harald denker jean","denker jean michel","jean michel dubois","michel dubois jean","dubois jean loup","jean loup gailly","loup gailly hunter","gailly hunter goatley","hunter goatley ed","goatley ed gordon","ed gordon ian","gordon ian gorman","ian gorman chris","gorman chris herborth","chris herborth dirk","herborth dirk haase","dirk haase greg","haase greg hartwig","greg hartwig robert","hartwig robert heath","robert heath jonathan","heath jonathan hudson","jonathan hudson paul","hudson paul kienitz","paul kienitz david","kienitz david kirschbaum","david kirschbaum johnny","kirschbaum johnny lee","johnny lee onno","lee onno van","onno van der","van der linden","der linden igor","linden igor mandrichenko","igor mandrichenko steve","mandrichenko steve p","steve p miller","p miller sergio","miller sergio monesi","sergio monesi keith","monesi keith owens","keith owens george","owens george petrov","george petrov greg","petrov greg roelofs","greg roelofs kai","roelofs kai uwe","kai uwe rommel","uwe rommel steve","rommel steve salisbury","steve salisbury dave","salisbury dave smith","dave smith steven","smith steven m","steven m schweda","m schweda christian","schweda christian spieler","christian spieler cosmin","spieler cosmin truta","cosmin truta antoine","truta antoine verheijen","antoine verheijen paul","verheijen paul von","paul von behren","von behren rich","behren rich wales","rich wales mike","wales mike white","mike white this","white this software","event shall info","shall info zip","zip or its","contributors be held","above disclaimer and","disclaimer and the","following restrictions redistributions","restrictions redistributions of","in part must","part must retain","of conditions redistributions","conditions redistributions in","binary form compiled","form compiled executables","compiled executables and","executables and libraries","and libraries must","libraries must reproduce","conditions in documentation","in documentation and","the distribution additional","distribution additional documentation","additional documentation is","not needed for","needed for executables","for executables where","executables where a","where a command","a command line","command line license","line license option","license option provides","option provides these","provides these and","these and a","and a note","a note regarding","note regarding this","regarding this option","option is in","the executable s","executable s startup","s startup banner","startup banner the","banner the sole","the sole exception","sole exception to","exception to this","to this condition","condition is redistribution","is redistribution of","redistribution of a","a standard unzipsfx","standard unzipsfx binary","unzipsfx binary including","binary including sfxwiz","including sfxwiz as","sfxwiz as part","of a self","a self extracting","self extracting archive","extracting archive that","archive that is","that is permitted","is permitted without","permitted without inclusion","without inclusion of","license as long","as the normal","the normal sfx","normal sfx banner","sfx banner has","banner has not","not been removed","from the binary","the binary or","binary or disabled","or disabled altered","disabled altered versions","altered versions including","versions including but","limited to ports","to ports to","ports to new","to new operating","new operating systems","operating systems existing","systems existing ports","existing ports with","ports with new","with new graphical","new graphical interfaces","graphical interfaces versions","interfaces versions with","versions with modified","with modified or","modified or added","or added functionality","added functionality and","functionality and dynamic","and dynamic shared","dynamic shared or","shared or static","or static library","static library versions","library versions not","versions not from","not from info","from info zip","info zip must"]},{"licenseTexts":["ACPI - Software License Agreement\n\nSoftware License Agreement IMPORTANT - READ BEFORE COPYING, INSTALLING OR USING.\n\nDo not use or load this software and any associated materials (collectively, the \"Software\") until you have carefully read the following terms and conditions. By loading or using the Software, you agree to the terms of this Agreement. If you do not wish to so agree, do not install or use the Software.\n\n   1. COPYRIGHT NOTICE Some or all of this work - Copyright © 1999-2005, Intel Corp. All rights reserved.\n\n   2. LICENSE\n\n      2.1. This is your license from Intel Corp. under its intellectual property rights. You may have additional license terms from the party that provided you this software, covering your right to use that party's intellectual property rights.\n\n      2.2. Intel grants, free of charge, to any person (\"Licensee\") obtaining a copy of the source code appearing in this file (\"Covered Code\") an irrevocable, perpetual, worldwide license under Intel's copyrights in the base code distributed originally by Intel (\"Original Intel Code\") to copy, make derivatives, distribute, use and display any portion of the Covered Code in any form, with the right to sublicense such rights; and\n\n      2.3. Intel grants Licensee a non-exclusive and non-transferable patent license (with the right to sublicense), under only those claims of Intel patents that are infringed by the Original Intel Code, to make, use, sell, offer to sell, and import the Covered Code and derivative works thereof solely to the minimum extent necessary to exercise the above copyright license, and in no event shall the patent license extend to any additions to or modifications of the Original Intel Code. No other license or right is granted directly or by implication, estoppel or otherwise; The above copyright and patent license is granted only if the following conditions are met:\n\n   3. CONDITIONS\n\n      3.1. Redistribution of Source with Rights to Further Distribute Source. Redistribution of source code of any substantial portion of the Covered Code or modification with rights to further distribute source must include the above Copyright Notice, the above License, this list of Conditions, and the following Disclaimer and Export Compliance provision. In addition, Licensee must cause all Covered Code to which Licensee contributes to contain a file documenting the changes Licensee made to create that Covered Code and the date of any change. Licensee must include in that file the documentation of any changes made by any predecessor Licensee. Licensee must include a prominent statement that the modification is derived, directly or indirectly, from Original Intel Code.\n\n      3.2. Redistribution of Source with no Rights to Further Distribute Source. Redistribution of source code of any substantial portion of the Covered Code or modification without rights to further distribute source must include the following Disclaimer and Export Compliance provision in the documentation and/or other materials provided with distribution. In addition, Licensee may not authorize further sublicense of source of any portion of the Covered Code, and must include terms to the effect that the license from Licensee to its licensee is limited to the intellectual property embodied in the software Licensee provides to its licensee, and not to intellectual property embodied in modifications its licensee may make.\n\n      3.3. Redistribution of Executable. Redistribution in executable form of any substantial portion of the Covered Code or modification must reproduce the above Copyright Notice, and the following Disclaimer and Export Compliance provision in the documentation and/or other materials provided with the distribution.\n\n      3.4. Intel retains all right, title, and interest in and to the Original Intel Code.\n\n      3.5. Neither the name Intel nor any other trademark owned or controlled by Intel shall be used in advertising or otherwise to promote the sale, use or other dealings in products derived from or relating to the Covered Code without prior written authorization from Intel.\n\n   4. DISCLAIMER AND EXPORT COMPLIANCE\n\n      4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE IS PROVIDED \"AS IS,\" AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE.\n\n      4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY LIMITED REMEDY.\n\n      4.3. Licensee shall not export, either directly or indirectly, any of this software or system incorporating such software without first obtaining any required license or other approval from the U. S. Department of Commerce or any other agency or department of the United States Government. In the event Licensee exports any such software from the United States or re-exports any such software from a foreign destination, Licensee shall ensure that the distribution and export/re-export of the software is in compliance with all laws, regulations, orders, or other restrictions of the U.S. Export Administration Regulations. Licensee agrees that neither it nor any of its subsidiaries will export/re-export any technical data, process, software, or service, directly or indirectly, to any country for which the United States government or any agency thereof requires an export license, other governmental approval, or letter of assurance, without first obtaining such license, approval or letter."],"licenseIds":["Intel-ACPI"],"keywords":["acpi software license","license agreement software","agreement software license","agreement important read","important read before","read before copying","before copying installing","installing or using","or using do","using do not","use or load","or load this","load this software","any associated materials","associated materials collectively","materials collectively the","the software until","software until you","until you have","you have carefully","have carefully read","conditions by loading","by loading or","loading or using","software you agree","wish to so","to so agree","so agree do","do not install","not install or","install or use","software 1 copyright","1 copyright notice","copyright notice some","notice some or","all of this","this work copyright","work copyright 1999","copyright 1999 2005","1999 2005 intel","2005 intel corp","intel corp all","corp all rights","reserved 2 license","1 this is","this is your","is your license","license from intel","from intel corp","intel corp under","corp under its","under its intellectual","rights you may","have additional license","additional license terms","license terms from","terms from the","from the party","party that provided","that provided you","provided you this","you this software","this software covering","software covering your","covering your right","use that party","that party s","property rights 2","rights 2 2","2 2 intel","2 intel grants","intel grants free","grants free of","any person licensee","person licensee obtaining","source code appearing","code appearing in","appearing in this","this file covered","file covered code","covered code an","code an irrevocable","an irrevocable perpetual","irrevocable perpetual worldwide","perpetual worldwide license","worldwide license under","license under intel","under intel s","intel s copyrights","the base code","base code distributed","code distributed originally","distributed originally by","originally by intel","by intel original","intel original intel","code to copy","to copy make","copy make derivatives","make derivatives distribute","derivatives distribute use","distribute use and","use and display","and display any","display any portion","any form with","to sublicense such","sublicense such rights","rights and 2","and 2 3","2 3 intel","3 intel grants","intel grants licensee","non exclusive and","exclusive and non","and non transferable","non transferable patent","transferable patent license","to sublicense under","sublicense under only","under only those","only those claims","those claims of","claims of intel","of intel patents","intel patents that","code and derivative","works thereof solely","thereof solely to","exercise the above","above copyright license","shall the patent","patent license extend","license extend to","extend to any","to any additions","to or modifications","intel code no","code no other","other license or","license or right","or right is","is granted directly","otherwise the above","and patent license","are met 3","met 3 conditions","3 conditions 3","conditions 3 1","source with rights","or modification with","modification with rights","notice the above","above license this","license this list","provision in addition","addition licensee must","which licensee contributes","licensee contributes to","contributes to contain","the changes licensee","changes licensee made","licensee made to","any change licensee","change licensee must","include in that","in that file","that file the","file the documentation","documentation of any","changes made by","by any predecessor","any predecessor licensee","predecessor licensee licensee","licensee licensee must","from original intel","source with no","with no rights","or modification without","modification without rights","without rights to","provided with distribution","with distribution in","distribution in addition","addition licensee may","may not authorize","not authorize further","authorize further sublicense","further sublicense of","sublicense of source","of source of","code and must","must include terms","include terms to","effect that the","license from licensee","from licensee to","licensee to its","its licensee is","licensee is limited"]},{"licenseTexts":["Intel Open Source License Copyright (c) 1996-2000 Intel Corporation\n\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   • Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n   • Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   • Neither the name of the Intel Corporation nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\nEXPORT LAWS: THIS LICENSE ADDS NO RESTRICTIONS TO THE EXPORT LAWS OF YOUR JURISDICTION. It is licensee's responsibility to comply with any export regulations applicable in licensee's jurisdiction. Under CURRENT (May 2000) U.S. export regulations this software is eligible for export from the U.S. and can be downloaded by or otherwise exported or reexported worldwide EXCEPT to U.S. embargoed destinations which include Cuba, Iraq, Libya, North Korea, Iran, Syria, Sudan, Afghanistan and any other country to which the U.S. has embargoed goods and services."],"licenseIds":["Intel"],"keywords":["1996 2000 intel","2000 intel corporation","intel corporation all","of the intel","the intel corporation","intel corporation nor","shall the intel","the intel or","intel or contributors","such damage export","damage export laws","export laws this","laws this license","this license adds","license adds no","adds no restrictions","no restrictions to","to the export","the export laws","export laws of","laws of your","of your jurisdiction","your jurisdiction it","jurisdiction it is","it is licensee","is licensee s","licensee s responsibility","with any export","any export regulations","export regulations applicable","regulations applicable in","applicable in licensee","in licensee s","licensee s jurisdiction","s jurisdiction under","jurisdiction under current","under current may","current may 2000","may 2000 u","2000 u s","s export regulations","export regulations this","regulations this software","software is eligible","eligible for export","for export from","export from the","s and can","can be downloaded","be downloaded by","downloaded by or","by or otherwise","or otherwise exported","otherwise exported or","exported or reexported","or reexported worldwide","reexported worldwide except","worldwide except to","except to u","s embargoed destinations","embargoed destinations which","destinations which include","which include cuba","include cuba iraq","cuba iraq libya","iraq libya north","libya north korea","north korea iran","korea iran syria","iran syria sudan","syria sudan afghanistan","sudan afghanistan and","afghanistan and any","any other country","other country to","country to which","which the u","u s has","s has embargoed","has embargoed goods","embargoed goods and","goods and services","c 1996 2000 intel","1996 2000 intel corporation","2000 intel corporation all","intel corporation all rights","name of the intel","of the intel corporation","the intel corporation nor","intel corporation nor the","event shall the intel","shall the intel or","the intel or contributors","intel or contributors be","of such damage export","such damage export laws","damage export laws this","export laws this license","laws this license adds","this license adds no","license adds no restrictions","adds no restrictions to","no restrictions to the","restrictions to the export","to the export laws","the export laws of","export laws of your","laws of your jurisdiction","of your jurisdiction it","your jurisdiction it is","jurisdiction it is licensee","it is licensee s","is licensee s responsibility","licensee s responsibility to","s responsibility to comply","comply with any export","with any export regulations","any export regulations applicable","export regulations applicable in","regulations applicable in licensee","applicable in licensee s","in licensee s jurisdiction","licensee s jurisdiction under","s jurisdiction under current","jurisdiction under current may","under current may 2000","current may 2000 u","may 2000 u s","2000 u s export","u s export regulations","s export regulations this","export regulations this software","regulations this software is","this software is eligible","software is eligible for","is eligible for export","eligible for export from","for export from the","export from the u","u s and can","s and can be","and can be downloaded","can be downloaded by","be downloaded by or","downloaded by or otherwise","by or otherwise exported","or otherwise exported or","otherwise exported or reexported","exported or reexported worldwide","or reexported worldwide except","reexported worldwide except to","worldwide except to u","except to u s","to u s embargoed","u s embargoed destinations","s embargoed destinations which","embargoed destinations which include","destinations which include cuba","which include cuba iraq","include cuba iraq libya","cuba iraq libya north","iraq libya north korea","libya north korea iran","north korea iran syria","korea iran syria sudan","iran syria sudan afghanistan","syria sudan afghanistan and","sudan afghanistan and any","afghanistan and any other","and any other country","any other country to","other country to which","country to which the","to which the u","which the u s","the u s has","u s has embargoed","s has embargoed goods","has embargoed goods and","embargoed goods and services","intel open source license copyright","source license copyright c 1996","license copyright c 1996 2000","copyright c 1996 2000 intel","c 1996 2000 intel corporation","1996 2000 intel corporation all","2000 intel corporation all rights","intel corporation all rights reserved","corporation all rights reserved redistribution","the name of the intel","name of the intel corporation","of the intel corporation nor","the intel corporation nor the","intel corporation nor the names","no event shall the intel","event shall the intel or","shall the intel or contributors","the intel or contributors be","intel or contributors be liable","possibility of such damage export"]},{"licenseTexts":["INTERBASE PUBLIC LICENSE\n\nVersion 1.0\n\n   1. Definitions.\n\n      1.0.1. \"Commercial Use\" means distribution or otherwise making the Covered Code available to a third party.\n\n      1.1. ''Contributor'' means each entity that creates or contributes to the creation of Modifications.\n\n      1.2. ''Contributor Version'' means the combination of the Original Code, prior Modifications used by a Contributor, and the Modifications made by that particular Contributor.\n\n      1.3. ''Covered Code'' means the Original Code or Modifications or the combination of the Original Code and Modifications, in each case including portions thereof.\n\n      1.4. ''Electronic Distribution Mechanism'' means a mechanism generally accepted in the software development community for the electronic transfer of data.\n\n      1.5. ''Executable'' means Covered Code in any form other than Source Code.\n\n      1.6. ''Initial Developer'' means the individual or entity identified as the Initial Developer in the Source Code notice required by Exhibit A.\n\n      1.7. ''Larger Work'' means a work which combines Covered Code or portions thereof with code not governed by the terms of this License.\n\n      1.8. ''License'' means this document.\n\n      1.8.1. \"Licensable\" means having the right to grant, to the maximum extent possible, whether at the time of the initial grant or subsequently acquired, any and all of the rights conveyed herein.\n\n      1.9. ''Modifications'' means any addition to or deletion from the substance or structure of either the Original Code or any previous Modifications. When Covered Code is released as a series of files, a Modification is:\n\n         A. Any addition to or deletion from the contents of a file containing Original Code or previous Modifications.\n\n         B. Any new file that contains any part of the Original Code or previous Modifications.\n\n      1.10. ''Original Code'' means Source Code of computer software code which is described in the Source Code notice required by Exhibit A as Original Code, and which, at the time of its release under this License is not already Covered Code governed by this License.\n\n      1.10.1. \"Patent Claims\" means any patent claim(s), now owned or hereafter acquired, including without limitation, method, process, and apparatus claims, in any patent Licensable by grantor.\n\n      1.11. ''Source Code'' means the preferred form of the Covered Code for making modifications to it, including all modules it contains, plus any associated interface definition files, scripts used to control compilation and installation of an Executable, or source code differential comparisons against either the Original Code or another well known, available Covered Code of the Contributor's choice. The Source Code can be in a compressed or archival form, provided the appropriate decompression or de-archiving software is widely available for no charge.\n\n      1.12. \"You'' (or \"Your\") means an individual or a legal entity exercising rights under, and complying with all of the terms of, this License or a future version of this License issued under Section 6.1. For legal entities, \"You'' includes any entity which controls, is controlled by, or is under common control with You. For purposes of this definition, \"control'' means (a) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (b) ownership of more than fifty percent (50%) of the outstanding shares or beneficial ownership of such entity.\n\n   2. Source Code License.\n\n      2.1. The Initial Developer Grant.\n\n      The Initial Developer hereby grants You a world-wide, royalty-free, non-exclusive license, subject to third party intellectual property claims:\n\n         (a) under intellectual property rights (other than patent or trademark) Licensable by Initial Developer to use, reproduce, modify, display, perform, sublicense and distribute the Original Code (or portions thereof) with or without Modifications, and/or as part of a Larger Work; and\n\n         (b) under Patents Claims infringed by the making, using or selling of Original Code, to make, have made, use, practice, sell, and offer for sale, and/or otherwise dispose of the Original Code (or portions thereof).\n\n         (c) the licenses granted in this Section 2.1(a) and (b) are effective on the date Initial Developer first distributes Original Code under the terms of this License.\n\n         (d) Notwithstanding Section 2.1(b) above, no patent license is granted: 1) for code that You delete from the Original Code; 2) separate from the Original Code; or 3) for infringements caused by: i) the modification of the Original Code or ii) the combination of the Original Code with other software or devices.\n\n      2.2. Contributor Grant.\n\n      Subject to third party intellectual property claims, each Contributor hereby grants You a world-wide, royalty-free, non-exclusive license\n\n         (a) under intellectual property rights (other than patent or trademark) Licensable by Contributor, to use, reproduce, modify, display, perform, sublicense and distribute the Modifications created by such Contributor (or portions thereof) either on an unmodified basis, with other Modifications, as Covered Code and/or as part of a Larger Work; and\n\n         (b) under Patent Claims infringed by the making, using, or selling of Modifications made by that Contributor either alone and/or in combination with its Contributor Version (or portions of such combination), to make, use, sell, offer for sale, have made, and/or otherwise dispose of: 1) Modifications made by that Contributor (or portions thereof); and 2) the combination of Modifications made by that Contributor with its Contributor Version (or portions of such combination).\n\n         (c) the licenses granted in Sections 2.2(a) and 2.2(b) are effective on the date Contributor first makes Commercial Use of the Covered Code.\n\n         (d) Notwithstanding Section 2.2(b) above, no patent license is granted: 1) for any code that Contributor has deleted from the Contributor Version; 2) separate from the Contributor Version; 3) for infringements caused by: i) third party modifications of Contributor Version or ii) the combination of Modifications made by that Contributor with other software (except as part of the Contributor Version) or other devices; or 4) under Patent Claims infringed by Covered Code in the absence of Modifications made by that Contributor.\n\n   3. Distribution Obligations.\n\n      3.1. Application of License.\n\n      The Modifications which You create or to which You contribute are governed by the terms of this License, including without limitation Section 2.2. The Source Code version of Covered Code may be distributed only under the terms of this License or a future version of this License released under Section 6.1, and You must include a copy of this License with every copy of the Source Code You distribute. You may not offer or impose any terms on any Source Code version that alters or restricts the applicable version of this License or the recipients' rights hereunder. However, You may include an additional document offering the additional rights described in Section 3.5.\n\n      3.2. Availability of Source Code.\n\n      Any Modification which You create or to which You contribute must be made available in Source Code form under the terms of this License either on the same media as an Executable version or via an accepted Electronic Distribution Mechanism to anyone to whom you made an Executable version available; and if made available via Electronic Distribution Mechanism, must remain available for at least twelve (12) months after the date it initially became available, or at least six (6) months after a subsequent version of that particular Modification has been made available to such recipients. You are responsible for ensuring that the Source Code version remains available even if the Electronic Distribution Mechanism is maintained by a third party.\n\n      3.3. Description of Modifications.\n\n      You must cause all Covered Code to which You contribute to contain a file documenting the changes You made to create that Covered Code and the date of any change. You must include a prominent statement that the Modification is derived, directly or indirectly, from Original Code provided by the Initial Developer and including the name of the Initial Developer in (a) the Source Code, and (b) in any notice in an Executable version or related documentation in which You describe the origin or ownership of the Covered Code.\n\n      3.4. Intellectual Property Matters\n\n         (a) Third Party Claims.\n\n         If Contributor has knowledge that a license under a third party's intellectual property rights is required to exercise the rights granted by such Contributor under Sections 2.1 or 2.2, Contributor must include a text file with the Source Code distribution titled \"LEGAL'' which describes the claim and the party making the claim in sufficient detail that a recipient will know whom to contact. If Contributor obtains such knowledge after the Modification is made available as described in Section 3.2, Contributor shall promptly modify the LEGAL file in all copies Contributor makes available thereafter and shall take other steps (such as notifying appropriate mailing lists or newsgroups) reasonably calculated to inform those who received the Covered Code that new knowledge has been obtained.\n\n         (b) Contributor APIs.\n\n         If Contributor's Modifications include an application programming interface and Contributor has knowledge of patent licenses which are reasonably necessary to implement that API, Contributor must also include this information in the LEGAL file.\n\n         (c) Representations.\n\n         Contributor represents that, except as disclosed pursuant to Section 3.4(a) above, Contributor believes that Contributor's Modifications are Contributor's original creation(s) and/or Contributor has sufficient rights to grant the rights conveyed by this License.\n\n      3.5. Required Notices.\n\n      You must duplicate the notice in Exhibit A in each file of the Source Code. If it is not possible to put such notice in a particular Source Code file due to its structure, then You must include such notice in a location (such as a relevant directory) where a user would be likely to look for such a notice. If You created one or more Modification(s) You may add your name as a Contributor to the notice described in Exhibit A. You must also duplicate this License in any documentation for the Source Code where You describe recipients' rights or ownership rights relating to Covered Code. You may choose to offer, and to charge a fee for, warranty, support, indemnity or liability obligations to one or more recipients of Covered Code. However, You may do so only on Your own behalf, and not on behalf of the Initial Developer or any Contributor. You must make it absolutely clear than any such warranty, support, indemnity or liability obligation is offered by You alone, and You hereby agree to indemnify the Initial Developer and every Contributor for any liability incurred by the Initial Developer or such Contributor as a result of warranty, support, indemnity or liability terms You offer.\n\n      3.6. Distribution of Executable Versions.\n\n      You may distribute Covered Code in Executable form only if the requirements of Section 3.1-3.5 have been met for that Covered Code, and if You include a notice stating that the Source Code version of the Covered Code is available under the terms of this License, including a description of how and where You have fulfilled the obligations of Section 3.2. The notice must be conspicuously included in any notice in an Executable version, related documentation or collateral in which You describe recipients' rights relating to the Covered Code. You may distribute the Executable version of Covered Code or ownership rights under a license of Your choice, which may contain terms different from this License, provided that You are in compliance with the terms of this License and that the license for the Executable version does not attempt to limit or alter the recipient's rights in the Source Code version from the rights set forth in this License. If You distribute the Executable version under a different license You must make it absolutely clear that any terms which differ from this License are offered by You alone, not by the Initial Developer or any Contributor. You hereby agree to indemnify the Initial Developer and every Contributor for any liability incurred by the Initial Developer or such Contributor as a result of any such terms You offer.\n\n      3.7. Larger Works.\n\n      You may create a Larger Work by combining Covered Code with other code not governed by the terms of this License and distribute the Larger Work as a single product. In such a case, You must make sure the requirements of this License are fulfilled for the Covered Code.\n\n   4. Inability to Comply Due to Statute or Regulation.\n\n   If it is impossible for You to comply with any of the terms of this License with respect to some or all of the Covered Code due to statute, judicial order, or regulation then You must: (a) comply with the terms of this License to the maximum extent possible; and (b) describe the limitations and the code they affect. Such description must be included in the LEGAL file described in Section 3.4 and must be included with all distributions of the Source Code. Except to the extent prohibited by statute or regulation, such description must be sufficiently detailed for a recipient of ordinary skill to be able to understand it.\n\n   5. Application of this License.\n\n   This License applies to code to which the Initial Developer has attached the notice in Exhibit A and to related Covered Code.\n\n   6. Versions of the License.\n\n      6.1. New Versions.\n\n      Borland Software Corporation (''Interbase'') may publish revised and/or new versions of the License from time to time. Each version will be given a distinguishing version number.\n\n      6.2. Effect of New Versions.\n\n      Once Covered Code has been published under a particular version of the License, You may always continue to use it under the terms of that version. You may also choose to use such Covered Code under the terms of any subsequent version of the License published by Interbase. No one other than Interbase has the right to modify the terms applicable to Covered Code created under this License.\n\n      6.3. Derivative Works.\n\n      If You create or use a modified version of this License (which you may only do in order to apply it to code which is not already Covered Code governed by this License), You must (a) rename Your license so that the phrases ''Mozilla'', ''MOZILLAPL'', ''MOZPL'', ''Netscape'', \"MPL\", ''NPL\", \"Interbase\", \"ISC\", \"IB'' or any confusingly similar phrase do not appear in your license (except to note that your license differs from this License) and (b) otherwise make it clear that Your version of the license contains terms which differ from the Mozilla Public License and Netscape Public License. (Filling in the name of the Initial Developer, Original Code or Contributor in the notice described in Exhibit A shall not of themselves be deemed to be modifications of this License.)\n\n      6.4 Origin of the Interbase Public License.\n\n      The Interbase public license is based on the Mozilla Public License V 1.1 with the following changes:\n\n      The license is published by Borland Software Corporation. Only Borland Software Corporation can modify the terms applicable to Covered Code.\n\n      The license can be modified used for code which is not already governed by this license. Modified versions of the license must be renamed to avoid confusion with Netscape?s or Interbase Software?s license and must include a description of changes from the Interbase Public License.\n\n      The name of the license in Exhibit A is the \"Interbase Public License\".\n\n      The reference to an alternative license in Exhibit A has been removed.\n\n      Amendments I, II, III, V, and VI have been deleted.\n\n      Exhibit A, Netscape Public License has been deleted\n\n      A new amendment (II) has been added, describing the required and restricted rights to use the trademarks of Borland Software Corporation\n\n   7. DISCLAIMER OF WARRANTY.\n\n   COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN \"AS IS'' BASIS, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER.\n\n   8. TERMINATION.\n\n      8.1. This License and the rights granted hereunder will terminate automatically if You fail to comply with terms herein and fail to cure such breach within 30 days of becoming aware of the breach. All sublicenses to the Covered Code which are properly granted shall survive any termination of this License. Provisions which, by their nature, must remain in effect beyond the termination of this License shall survive.\n\n      8.2. If You initiate litigation by asserting a patent infringement claim (excluding declatory judgment actions) against Initial Developer or a Contributor (the Initial Developer or Contributor against whom You file such action is referred to as \"Participant\") alleging that:\n\n         (a) such Participant's Contributor Version directly or indirectly infringes any patent, then any and all rights granted by such Participant to You under Sections 2.1 and/or 2.2 of this License shall, upon 60 days notice from Participant terminate prospectively, unless if within 60 days after receipt of notice You either: (i) agree in writing to pay Participant a mutually agreeable reasonable royalty for Your past and future use of Modifications made by such Participant, or (ii) withdraw Your litigation claim with respect to the Contributor Version against such Participant. If within 60 days of notice, a reasonable royalty and payment arrangement are not mutually agreed upon in writing by the parties or the litigation claim is not withdrawn, the rights granted by Participant to You under Sections 2.1 and/or 2.2 automatically terminate at the expiration of the 60 day notice period specified above.\n\n         (b) any software, hardware, or device, other than such Participant's Contributor Version, directly or indirectly infringes any patent, then any rights granted to You by such Participant under Sections 2.1(b) and 2.2(b) are revoked effective as of the date You first made, used, sold, distributed, or had made, Modifications made by that Participant.\n\n      8.3. If You assert a patent infringement claim against Participant alleging that such Participant's Contributor Version directly or indirectly infringes any patent where such claim is resolved (such as by license or settlement) prior to the initiation of patent infringement litigation, then the reasonable value of the licenses granted by such Participant under Sections 2.1 or 2.2 shall be taken into account in determining the amount or value of any payment or license.\n\n      8.4. In the event of termination under Sections 8.1 or 8.2 above, all end user license agreements (excluding distributors and resellers) which have been validly granted by You or any distributor hereunder prior to termination shall survive termination.\n\n   9. LIMITATION OF LIABILITY.\n\n   UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER TORT (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL YOU, THE INITIAL DEVELOPER, ANY OTHER CONTRIBUTOR, OR ANY DISTRIBUTOR OF COVERED CODE, OR ANY SUPPLIER OF ANY OF SUCH PARTIES, BE LIABLE TO ANY PERSON FOR ANY INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, COMPUTER FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER COMMERCIAL DAMAGES OR LOSSES, EVEN IF SUCH PARTY SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF LIABILITY SHALL NOT APPLY TO LIABILITY FOR DEATH OR PERSONAL INJURY RESULTING FROM SUCH PARTY'S NEGLIGENCE TO THE EXTENT APPLICABLE LAW PROHIBITS SUCH LIMITATION. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OR LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THIS EXCLUSION AND LIMITATION MAY NOT APPLY TO YOU.\n\n   10. U.S. GOVERNMENT END USERS.\n\n   The Covered Code is a ''commercial item,'' as that term is defined in 48 C.F.R. 2.101 (Oct. 1995), consisting of ''commercial computer software'' and ''commercial computer software documentation,'' as such terms are used in 48 C.F.R. 12.212 (Sept. 1995). Consistent with 48 C.F.R. 12.212 and 48 C.F.R. 227.7202-1 through 227.7202-4 (June 1995), all U.S. Government End Users acquire Covered Code with only those rights set forth herein.\n\n   11. MISCELLANEOUS.\n\n   This License represents the complete agreement concerning subject matter hereof. If any provision of this License is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable. This License shall be governed by California law provisions (except to the extent applicable law, if any, provides otherwise), excluding its conflict-of-law provisions. With respect to disputes in which at least one party is a citizen of, or an entity chartered or registered to do business in the United States of America, any litigation relating to this License shall be subject to the jurisdiction of the Federal Courts of the Northern District of California, with venue lying in Santa Clara County, California, with the losing party responsible for costs, including without limitation, court costs and reasonable attorneys' fees and expenses. The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded. Any law or regulation which provides that the language of a contract shall be construed against the drafter shall not apply to this License.\n\n   12. RESPONSIBILITY FOR CLAIMS.\n\n   As between Initial Developer and the Contributors, each party is responsible for claims and damages arising, directly or indirectly, out of its utilization of rights under this License and You agree to work with Initial Developer and Contributors to distribute such responsibility on an equitable basis. Nothing herein is intended or shall be deemed to constitute any admission of liability.\n\n   13. MULTIPLE-LICENSED CODE.\n\n   Initial Developer may designate portions of the Covered Code as \"Multiple-Licensed\". \"Multiple-Licensed\" means that the Initial Developer permits you to utilize portions of the Covered Code under Your choice of the NPL or the alternative licenses, if any, specified by the Initial Developer in the file described in Exhibit A.\n\n   EXHIBIT A - InterBase Public License.\n\n   \"The contents of this file are subject to the Interbase Public License Version 1.0 (the \"License\"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.Interbase.com/IPL.html\n\n   Software distributed under the License is distributed on an \"AS IS\" basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the specific language governing rights and limitations under the License.\n\n   The Original Code was created by InterBase Software Corp and its successors.\n\n   Portions created by Borland/Inprise are Copyright (C) Borland/Inprise. All Rights Reserved.\n\n   Contributor(s): ______________________________________ .\n\nAMENDMENTS\n\n   I. InterBase and logo. This License does not grant any rights to use the trademarks \"Interbase'', \"Java\" or \"JavaScript\" even if such marks are included in the Original Code or Modifications.\n\n   II. Trademark Usage.\n\n      II.1. Advertising Materials. All advertising materials mentioning features or use of the covered Code must display the following acknowledgement: \"This product includes software developed by Borland Software Corp. \"\n\n      II.2. Endorsements. The names \"InterBase,\" \"ISC,\" and \"IB\" must not be used to endorse or promote Contributor Versions or Larger Works without the prior written permission of Interbase.\n\n      II.3. Product Names. Contributor Versions and Larger Works may not be called \"InterBase\" or \"Interbase\" nor may the word \"InterBase\" appear in their names without the prior written permission of Interbase."],"licenseIds":["Interbase-1.0"],"keywords":["new versions borland","versions borland software","software corporation interbase","corporation interbase may","interbase may publish","published by interbase","by interbase no","interbase no one","other than interbase","than interbase has","interbase has the","mpl npl interbase","npl interbase isc","interbase isc ib","isc ib or","ib or any","6 4 origin","4 origin of","of the interbase","license the interbase","the following changes","following changes the","changes the license","is published by","published by borland","software corporation only","corporation only borland","only borland software","software corporation can","corporation can modify","code the license","the license can","be modified used","modified used for","used for code","for code which","not already governed","already governed by","this license modified","license modified versions","the license must","be renamed to","renamed to avoid","avoid confusion with","confusion with netscape","with netscape s","netscape s or","s or interbase","or interbase software","interbase software s","software s license","include a description","description of changes","of changes from","from the interbase","license the name","a is the","is the interbase","license the reference","the reference to","reference to an","alternative license in","been removed amendments","removed amendments i","amendments i ii","i ii iii","ii iii v","iii v and","v and vi","and vi have","vi have been","been deleted exhibit","deleted exhibit a","has been deleted","been deleted a","deleted a new","a new amendment","new amendment ii","amendment ii has","ii has been","been added describing","added describing the","describing the required","the required and","required and restricted","and restricted rights","restricted rights to","trademarks of borland","of borland software","software corporation 7","corporation 7 disclaimer","exhibit a interbase","a interbase public","to the interbase","http www interbase","www interbase com","interbase com ipl","com ipl html","ipl html software","code was created","created by interbase","by interbase software","interbase software corp","software corp and","corp and its","and its successors","its successors portions","successors portions created","created by borland","by borland inprise","borland inprise are","inprise are copyright","copyright c borland","c borland inprise","borland inprise all","inprise all rights","contributor s amendments","s amendments i","amendments i interbase","i interbase and","interbase and logo","the trademarks interbase","trademarks interbase java","interbase java or","or javascript even","javascript even if","or modifications ii","modifications ii trademark","ii trademark usage","trademark usage ii","usage ii 1","ii 1 advertising","developed by borland","borland software corp","software corp ii","corp ii 2","ii 2 endorsements","the names interbase","names interbase isc","interbase isc and","isc and ib","and ib must","ib must not","of interbase ii","interbase ii 3","ii 3 product","be called interbase","called interbase or","interbase or interbase","or interbase nor","interbase nor may","the word interbase","word interbase appear","interbase appear in","1 new versions borland","new versions borland software","versions borland software corporation","borland software corporation interbase","software corporation interbase may","corporation interbase may publish","interbase may publish revised","license published by interbase","published by interbase no","by interbase no one","interbase no one other","one other than interbase","other than interbase has","than interbase has the","interbase has the right","netscape mpl npl interbase","mpl npl interbase isc","npl interbase isc ib","interbase isc ib or","isc ib or any","ib or any confusingly","license 6 4 origin","6 4 origin of","4 origin of the","origin of the interbase","of the interbase public","public license the interbase","license the interbase public","interbase public license is","public license is based","v 1 1 with","with the following changes","the following changes the","following changes the license","changes the license is","license is published by","is published by borland","published by borland software","by borland software corporation","borland software corporation only","software corporation only borland","corporation only borland software","only borland software corporation","borland software corporation can","software corporation can modify","corporation can modify the"]},{"licenseTexts":["Japan Network Information Center License Copyright (c) 2000-2002 Japan Network Information Center. All rights reserved.\n\nBy using this file, you agree to the terms and conditions set forth bellow .\n\nLICENSE TERMS AND CONDITIONS\n\nThe following License Terms and Conditions apply, unless a different license is obtained from Japan Network Information Center (\" JPNIC \"), a Japanese association, Kokusai-Kougyou-Kanda Bldg 6F, 2-3-4 Uchi-Kanda, Chiyoda-ku, Tokyo 101-0047, Japan .\n\n   1. Use, Modification and Redistribution (including distribution of any modified or derived work) in source and/or binary forms is permitted under this License Terms and Conditions.\n\n   2. Redistribution of source code must retain the copyright notices as they appear in each source code file, this License Terms and Conditions.\n\n   3. Redistribution in binary form must reproduce the Copyright Notice, this License Terms and Conditions, in the documentation and/or other materials provided with the distribution. For the purposes of binary distribution the \"Copyright Notice\" refers to the following language: \"Copyright (c) 2000-2002 Japan Network Information Center . All rights reserved.\"\n\n   4. The name of JPNIC may not be used to endorse or promote products derived from this Software without specific prior written approval of JPNIC .\n\n   5. Disclaimer/Limitation of Liability: THIS SOFTWARE IS PROVIDED BY JPNIC \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JPNIC BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES."],"licenseIds":["JPNIC"],"keywords":["information center license","center license copyright","rights reserved by","reserved by using","set forth bellow","forth bellow license","bellow license terms","conditions the following","unless a different","different license is","obtained from japan","from japan network","information center jpnic","center jpnic a","jpnic a japanese","a japanese association","japanese association kokusai","association kokusai kougyou","kokusai kougyou kanda","kougyou kanda bldg","kanda bldg 6f","bldg 6f 2","6f 2 3","3 4 uchi","4 uchi kanda","uchi kanda chiyoda","kanda chiyoda ku","chiyoda ku tokyo","ku tokyo 101","tokyo 101 0047","101 0047 japan","0047 japan 1","japan 1 use","1 use modification","is permitted under","permitted under this","conditions 2 redistribution","code file this","file this license","conditions 3 redistribution","3 redistribution in","notice this license","reserved 4 the","name of jpnic","of jpnic may","jpnic may not","written approval of","approval of jpnic","of jpnic 5","jpnic 5 disclaimer","5 disclaimer limitation","provided by jpnic","by jpnic as","jpnic as is","event shall jpnic","shall jpnic be","jpnic be liable","network information center license","information center license copyright","center license copyright c","all rights reserved by","rights reserved by using","reserved by using this","conditions set forth bellow","set forth bellow license","forth bellow license terms","bellow license terms and","and conditions the following","conditions the following license","apply unless a different","unless a different license","a different license is","different license is obtained","is obtained from japan","obtained from japan network","from japan network information","network information center jpnic","information center jpnic a","center jpnic a japanese","jpnic a japanese association","a japanese association kokusai","japanese association kokusai kougyou","association kokusai kougyou kanda","kokusai kougyou kanda bldg","kougyou kanda bldg 6f","kanda bldg 6f 2","bldg 6f 2 3","6f 2 3 4","2 3 4 uchi","3 4 uchi kanda","4 uchi kanda chiyoda","uchi kanda chiyoda ku","kanda chiyoda ku tokyo","chiyoda ku tokyo 101","ku tokyo 101 0047","tokyo 101 0047 japan","101 0047 japan 1","0047 japan 1 use","japan 1 use modification","1 use modification and","or binary forms is","forms is permitted under","is permitted under this","permitted under this license","under this license terms","and conditions 2 redistribution","conditions 2 redistribution of","source code file this","code file this license","file this license terms","and conditions 3 redistribution","conditions 3 redistribution in","3 redistribution in binary","copyright notice this license","notice this license terms","and conditions in the","language copyright c 2000","rights reserved 4 the","reserved 4 the name","the name of jpnic","name of jpnic may","of jpnic may not","jpnic may not be","specific prior written approval","prior written approval of","written approval of jpnic","approval of jpnic 5","of jpnic 5 disclaimer","jpnic 5 disclaimer limitation","5 disclaimer limitation of","is provided by jpnic","provided by jpnic as","by jpnic as is","jpnic as is and","no event shall jpnic","event shall jpnic be","shall jpnic be liable","jpnic be liable for","japan network information center license","network information center license copyright","information center license copyright c","center license copyright c 2000","license copyright c 2000 2002","center all rights reserved by","all rights reserved by using","rights reserved by using this","reserved by using this file","file you agree to the","agree to the terms and","and conditions set forth bellow","conditions set forth bellow license","set forth bellow license terms","forth bellow license terms and","bellow license terms and conditions","license terms and conditions the","terms and conditions the following","and conditions the following license","conditions the following license terms","conditions apply unless a different","apply unless a different license","unless a different license is","a different license is obtained","different license is obtained from","license is obtained from japan","is obtained from japan network","obtained from japan network information","from japan network information center","japan network information center jpnic","network information center jpnic a","information center jpnic a japanese","center jpnic a japanese association","jpnic a japanese association kokusai","a japanese association kokusai kougyou","japanese association kokusai kougyou kanda","association kokusai kougyou kanda bldg","kokusai kougyou kanda bldg 6f","kougyou kanda bldg 6f 2","kanda bldg 6f 2 3","bldg 6f 2 3 4","6f 2 3 4 uchi","2 3 4 uchi kanda","3 4 uchi kanda chiyoda","4 uchi kanda chiyoda ku","uchi kanda chiyoda ku tokyo","kanda chiyoda ku tokyo 101","chiyoda ku tokyo 101 0047","ku tokyo 101 0047 japan","tokyo 101 0047 japan 1","101 0047 japan 1 use","0047 japan 1 use modification","japan 1 use modification and","1 use modification and redistribution","work in source and or","and or binary forms is","or binary forms is permitted","binary forms is permitted under","forms is permitted under this","is permitted under this license","permitted under this license terms","under this license terms and"]},{"licenseTexts":["JSON License Copyright (c) 2002 JSON.org\n\nPermission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the \"Software\"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.\n\nThe Software shall be used for Good, not Evil.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE."],"licenseIds":["JSON"],"keywords":["json license copyright","c 2002 json","2002 json org","json org permission","org permission is","used for good","for good not","good not evil","not evil the","evil the software","json license copyright c","copyright c 2002 json","c 2002 json org","2002 json org permission","json org permission is","org permission is hereby","software the software shall","software shall be used","be used for good","used for good not","for good not evil","good not evil the","not evil the software","evil the software is","json license copyright c 2002","license copyright c 2002 json","copyright c 2002 json org","c 2002 json org permission","2002 json org permission is","json org permission is hereby","org permission is hereby granted","the software the software shall","software the software shall be","the software shall be used","software shall be used for","shall be used for good","be used for good not","used for good not evil","for good not evil the","good not evil the software","not evil the software is","evil the software is provided"]},{"licenseTexts":["JasPer License Version 2.0 Copyright (c) 2001-2006 Michael David Adams\n\nCopyright (c) 1999-2000 Image Power, Inc.\n\nCopyright (c) 1999-2000 The University of British Columbia\n\nAll rights reserved.\n\nPermission is hereby granted, free of charge, to any person (the \"User\") obtaining a copy of this software and associated documentation files (the \"Software\"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:\n\n   1. The above copyright notices and this permission notice (which includes the disclaimer below) shall be included in all copies or substantial portions of the Software.\n\n   2. The name of a copyright holder shall not be used to endorse or promote products derived from the Software without specific prior written permission.\n\nTHIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. NO USE OF THE SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER. THE SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. NO ASSURANCES ARE PROVIDED BY THE COPYRIGHT HOLDERS THAT THE SOFTWARE DOES NOT INFRINGE THE PATENT OR OTHER INTELLECTUAL PROPERTY RIGHTS OF ANY OTHER ENTITY. EACH COPYRIGHT HOLDER DISCLAIMS ANY LIABILITY TO THE USER FOR CLAIMS BROUGHT BY ANY OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS OR OTHERWISE. AS A CONDITION TO EXERCISING THE RIGHTS GRANTED HEREUNDER, EACH USER HEREBY ASSUMES SOLE RESPONSIBILITY TO SECURE ANY OTHER INTELLECTUAL PROPERTY RIGHTS NEEDED, IF ANY. THE SOFTWARE IS NOT FAULT-TOLERANT AND IS NOT INTENDED FOR USE IN MISSION-CRITICAL SYSTEMS, SUCH AS THOSE USED IN THE OPERATION OF NUCLEAR FACILITIES, AIRCRAFT NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL SYSTEMS, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH THE FAILURE OF THE SOFTWARE OR SYSTEM COULD LEAD DIRECTLY TO DEATH, PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE (\"HIGH RISK ACTIVITIES\"). THE COPYRIGHT HOLDERS SPECIFICALLY DISCLAIM ANY EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES."],"licenseIds":["JasPer-2.0"],"keywords":["jasper license version","c 2001 2006","2001 2006 michael","2006 michael david","michael david adams","david adams copyright","adams copyright c","1999 2000 image","2000 image power","image power inc","power inc copyright","2000 the university","university of british","of british columbia","british columbia all","columbia all rights","any person the","person the user","the user obtaining","user obtaining a","1 the above","permission notice which","notice which includes","includes the disclaimer","disclaimer below shall","2 the name","permission this disclaimer","this disclaimer the","software no assurances","copyright holders that","holders that the","entity each copyright","holder disclaims any","the user for","user for claims","hereunder each user","each user hereby","user hereby assumes","any the software","use in mission","in mission critical","mission critical systems","critical systems such","as those used","those used in","navigation or communication","or communication systems","communication systems air","traffic control systems","control systems direct","systems direct life","or system could","system could lead","activities the copyright","copyright holders specifically","holders specifically disclaim","jasper license version 2","version 2 0 copyright","0 copyright c 2001","copyright c 2001 2006","c 2001 2006 michael","2001 2006 michael david","2006 michael david adams","michael david adams copyright","david adams copyright c","adams copyright c 1999","c 1999 2000 image","1999 2000 image power","2000 image power inc","image power inc copyright","power inc copyright c","inc copyright c 1999","c 1999 2000 the","1999 2000 the university","2000 the university of","the university of british","university of british columbia","of british columbia all","british columbia all rights","columbia all rights reserved","to any person the","any person the user","person the user obtaining","the user obtaining a","user obtaining a copy","conditions 1 the above","1 the above copyright","this permission notice which","permission notice which includes","notice which includes the","which includes the disclaimer","includes the disclaimer below","the disclaimer below shall","disclaimer below shall be","below shall be included","of the software 2","software 2 the name","2 the name of","from the software without","written permission this disclaimer","permission this disclaimer of","no use of the","the software is authorized","under this disclaimer the","this disclaimer the software","holders as is without","this software no assurances","software no assurances are","the copyright holders that","copyright holders that the","holders that the software","other entity each copyright","entity each copyright holder","each copyright holder disclaims","copyright holder disclaims any","holder disclaims any liability","any liability to the","liability to the user","to the user for","the user for claims","user for claims brought","exercising the rights granted","rights granted hereunder each","granted hereunder each user","hereunder each user hereby","each user hereby assumes","user hereby assumes sole","needed if any the","if any the software","any the software is","and is not intended","for use in mission","use in mission critical","in mission critical systems","mission critical systems such","critical systems such as","systems such as those","such as those used","as those used in","those used in the","used in the operation","aircraft navigation or communication","navigation or communication systems","or communication systems air","communication systems air traffic","air traffic control systems","traffic control systems direct","control systems direct life","systems direct life support","failure of the software","the software or system","software or system could","or system could lead","system could lead directly","risk activities the copyright","activities the copyright holders","the copyright holders specifically","copyright holders specifically disclaim","holders specifically disclaim any","jasper license version 2 0","license version 2 0 copyright","version 2 0 copyright c","2 0 copyright c 2001","0 copyright c 2001 2006","copyright c 2001 2006 michael","c 2001 2006 michael david","2001 2006 michael david adams","2006 michael david adams copyright","michael david adams copyright c","david adams copyright c 1999","adams copyright c 1999 2000","copyright c 1999 2000 image","c 1999 2000 image power","1999 2000 image power inc","2000 image power inc copyright","image power inc copyright c","power inc copyright c 1999","inc copyright c 1999 2000","copyright c 1999 2000 the","c 1999 2000 the university","1999 2000 the university of","2000 the university of british","the university of british columbia","university of british columbia all","of british columbia all rights","british columbia all rights reserved","columbia all rights reserved permission","charge to any person the","to any person the user","any person the user obtaining","person the user obtaining a","the user obtaining a copy","user obtaining a copy of","following conditions 1 the above","conditions 1 the above copyright","1 the above copyright notices","and this permission notice which","this permission notice which includes","permission notice which includes the","notice which includes the disclaimer"]},{"licenseTexts":["Licence Art Libre\n\n[ Copyleft Attitude ]\n\nVersion 1.2\n\nPréambule :\n\nAvec cette Licence Art Libre, l'autorisation est donnée de copier, de diffuser et de transformer librement les oeuvres dans le respect des droits de l'auteur.\n\nLoin d'ignorer les droits de l'auteur, cette licence les reconnaît et les protège. Elle en reformule le principe en permettant au public de faire un usage créatif des oeuvres d'art.\n\nAlors que l'usage fait du droit de la propriété littéraire et artistique conduit à restreindre l'accès du public à l'oeuvre, la Licence Art Libre a pour but de le favoriser.\n\nL'intention est d'ouvrir l'accès et d'autoriser l'utilisation des ressources d'une oeuvre par le plus grand nombre. En avoir jouissance pour en multiplier les réjouissances, créer de nouvelles conditions de création pour amplifier les possibilités de création. Dans le respect des auteurs avec la reconnaissance et la défense de leur droit moral.\n\nEn effet, avec la venue du numérique, l'invention de l'internet et des logiciels libres, un nouveau mode de création et de production est apparu. Il est aussi l'amplification de ce qui a été expérimenté par nombre d'artistes contemporains.\n\nLe savoir et la création sont des ressources qui doivent demeurer libres pour être encore véritablement du savoir et de la création. C'est à dire rester une recherche fondamentale qui ne soit pas directement liée à une application concrète. Créer c'est découvrir l'inconnu, c'est inventer le réel avant tout souci de réalisme.\n\nAinsi, l'objet de l'art n'est pas confondu avec l'objet d'art fini et défini comme tel.\n\nC'est la raison essentielle de cette Licence Art Libre : promouvoir et protéger des pratiques artistiques libérées des seules règles de l'économie de marché.\n\nDÉFINITIONS\n\n– L'oeuvre :\n\nil s'agit d'une oeuvre commune qui comprend l'oeuvre originelle ainsi que toutes les contributions postérieures (les originaux conséquents et les copies). Elle est créée à l'initiative de l'auteur originel qui par cette licence définit les conditions selon lesquelles les contributions sont faites.\n\n– L'oeuvre originelle :\n\nc'est-à-dire l'oeuvre créée par l'initiateur de l'oeuvre commune dont les copies vont être modifiées par qui le souhaite.\n\n– Les oeuvres conséquentes :\n\nc'est-à-dire les propositions des auteurs qui contribuent à la formation de l'oeuvre en faisant usage des droits de reproduction, de diffusion et de modification que leur confère la licence.\n\n– Original (source ou ressource de l'oeuvre) :\n\nexemplaire daté de l'oeuvre, de sa définition, de sa partition ou de son programme que l'auteur présente comme référence pour toutes actualisations, interprétations, copies ou reproductions ultérieures.\n\n– Copie :\n\ntoute reproduction d'un original au sens de cette licence.\n\n– Auteur de l'oeuvre originelle :\n\nc'est la personne qui a créé l'oeuvre à l'origine d'une arborescence de cette oeuvre modifiée. Par cette licence, l'auteur détermine les conditions dans lesquelles ce travail se fait.\n\n– Contributeur :\n\ntoute personne qui contribue à la création de l'oeuvre. Il est l'auteur d'une oeuvre originale résultant de la modification d'une copie de l'oeuvre originelle ou de la modification d'une copie d'une oeuvre conséquente.\n\n   1. OBJET\n\n   Cette licence a pour objet de définir les conditions selon lesquelles vous pouvez jouir librement de cette oeuvre.\n\n   2. L'ÉTENDUE DE LA JOUISSANCE\n\n   Cette oeuvre est soumise au droit d'auteur, et l'auteur par cette licence vous indique quelles sont vos libertés pour la copier, la diffuser et la modifier:\n\n   2.1 LA LIBERTÉ DE COPIER (OU DE REPRODUCTION)\n\n   Vous avez la liberté de copier cette oeuvre pour un usage personnel, pour vos amis, ou toute autre personne et quelque soit la technique employée.\n\n   2.2 LA LIBERTÉ DE DIFFUSER, D'INTERPRÉTER (OU DE REPRÉSENTATION)\n\n   Vous pouvez diffuser librement les copies de ces oeuvres, modifiées ou non, quel que soit le support, quel que soit le lieu, à titre onéreux ou gratuit si vous respectez toutes les conditions suivantes:\n\n   – joindre aux copies, cette licence à l'identique, ou indiquer précisément où se trouve la licence,\n\n   – indiquer au destinataire le nom de l'auteur des originaux,\n\n   – indiquer au destinataire où il pourra avoir accès aux originaux\n\n   (originels et/ou conséquents). L'auteur de l'original pourra, s'il le souhaite, vous autoriser à diffuser l'original dans les mêmes conditions que les copies.\n\n   2.3 LA LIBERTÉ DE MODIFIER\n\n   Vous avez la liberté de modifier les copies des originaux (originels et conséquents), qui peuvent être partielles ou non, dans le respect des conditions prévues à l'article 2.2 en cas de diffusion (ou représentation) de la copie modifiée. L'auteur de l'original pourra, s'il le souhaite, vous autoriser à modifier l'original dans les mêmes conditions que les copies.\n\n   3. L'INCORPORATION DE L'OEUVRE\n\n   Tous les éléments de cette oeuvre doivent demeurer libres, c'est pourquoi il ne vous est pas permis d'intégrer les originaux (originels et conséquents) dans une autre oeuvre qui ne serait pas soumise à cette licence.\n\n   4. VOS DROITS D'AUTEUR\n\n   Cette licence n'a pas pour objet de nier vos droits d'auteur sur votre contribution. En choisissant de contribuer à l'évolution de cette oeuvre, vous acceptez seulement d'offrir aux autres les mêmes droits sur votre contribution que ceux qui vous ont été accordés par cette licence.\n\n   5. LA DURÉE DE LA LICENCE\n\n   Cette licence prend effet dès votre acceptation de ses dispositions. Le fait de copier, de diffuser, ou de modifier l'oeuvre constitue une acception tacite.\n\n   Cette licence a pour durée la durée des droits d'auteur attachés à l'oeuvre.\n\n   Si vous ne respectez pas les termes de cette licence, vous perdez automatiquement les droits qu'elle vous confère.\n\n   Si le régime juridique auquel vous êtes soumis ne vous permet pas de respecter les termes de cette licence, vous ne pouvez pas vous prévaloir des libertés qu'elle confère.\n\n   6. LES DIFFÉRENTES VERSIONS DE LA LICENCE\n\n   Cette licence pourra être modifiée régulièrement, en vue de son amélioration, par ses auteurs (les acteurs du mouvement « copyleft attitude ») sous la forme de nouvelles versions numérotées.\n\n   Vous avez toujours le choix entre vous contenter des dispositions contenues dans la version sous laquelle la copie vous a été communiquée ou alors, vous prévaloir des dispositions d'une des versions ultérieures.\n\n   7. LES SOUS-LICENCES\n\n   Les sous licences ne sont pas autorisées par la présente. Toute personne qui souhaite bénéficier des libertés qu'elle confère sera liée directement à l'auteur de l'oeuvre originelle.\n\n   8. LA LOI APPLICABLE AU CONTRAT\n\nCette licence est soumise au droit français."],"licenseIds":["LAL-1.2"],"keywords":["art libre copyleft","libre copyleft attitude","copyleft attitude version","attitude version 1","1 2 pr","2 pr ambule","ambule avec cette","avec cette licence","librement les oeuvres","les oeuvres dans","oeuvres dans le","d ignorer les","ignorer les droits","l auteur cette","licence les reconna","en reformule le","reformule le principe","le principe en","principe en permettant","en permettant au","permettant au public","au public de","public de faire","atif des oeuvres","des oeuvres d","oeuvres d art","d art alors","art alors que","alors que l","que l usage","l usage fait","usage fait du","fait du droit","propri t litt","t litt raire","litt raire et","raire et artistique","et artistique conduit","artistique conduit restreindre","acc s du","s du public","du public l","public l oeuvre","l oeuvre la","oeuvre la licence","art libre a","libre a pour","a pour but","pour but de","but de le","de le favoriser","le favoriser l","favoriser l intention","est d ouvrir","d ouvrir l","ouvrir l acc","acc s et","s et d","et d autoriser","une oeuvre par","oeuvre par le","par le plus","grand nombre en","nombre en avoir","en avoir jouissance","avoir jouissance pour","jouissance pour en","pour en multiplier","en multiplier les","multiplier les r","les r jouissances","r jouissances cr","jouissances cr er","cr ation dans","ation dans le","respect des auteurs","des auteurs avec","auteurs avec la","avec la reconnaissance","la reconnaissance et","reconnaissance et la","et la d","la d fense","d fense de","fense de leur","de leur droit","leur droit moral","droit moral en","moral en effet","en effet avec","effet avec la","avec la venue","la venue du","venue du num","l invention de","invention de l","de l internet","l internet et","logiciels libres un","libres un nouveau","un nouveau mode","nouveau mode de","mode de cr","cr ation et","ation et de","et de production","de production est","production est apparu","est apparu il","apparu il est","il est aussi","est aussi l","aussi l amplification","l amplification de","amplification de ce","de ce qui","ce qui a","qui a t","a t exp","t exp riment","exp riment par","riment par nombre","par nombre d","nombre d artistes","d artistes contemporains","artistes contemporains le","contemporains le savoir","le savoir et","savoir et la","et la cr","cr ation sont","ation sont des","sont des ressources","des ressources qui","ressources qui doivent","qui doivent demeurer","demeurer libres pour","libres pour tre","pour tre encore","tre encore v","encore v ritablement","v ritablement du","ritablement du savoir","du savoir et","savoir et de","de la cr","cr ation c","ation c est","est dire rester","dire rester une","rester une recherche","une recherche fondamentale","recherche fondamentale qui","fondamentale qui ne","qui ne soit","ne soit pas","soit pas directement","pas directement li","directement li e","e une application","une application concr","application concr te","concr te cr","te cr er","cr er c","er c est","c est d","est d couvrir","d couvrir l","couvrir l inconnu","l inconnu c","inconnu c est","c est inventer","est inventer le","inventer le r","le r el","r el avant","el avant tout","avant tout souci","tout souci de","souci de r","de r alisme","r alisme ainsi","alisme ainsi l","ainsi l objet","l objet de","objet de l","de l art","l art n","art n est","est pas confondu","pas confondu avec","confondu avec l","avec l objet","objet d art","d art fini","art fini et","fini et d","et d fini","d fini comme"]},{"licenseTexts":["Licence Art Libre 1.3 (LAL 1.3)\n\nPréambule :\n\nAvec la Licence Art Libre, l'autorisation est donnée de copier, de diffuser et de transformer librement les œuvres dans le respect des droits de l'auteur.\n\nLoin d'ignorer ces droits, la Licence Art Libre les reconnaît et les protège. Elle en reformule l'exercice en permettant à tout un chacun de faire un usage créatif des productions de l'esprit quels que soient leur genre et leur forme d'expression.\n\nSi, en règle générale, l'application du droit d'auteur conduit à restreindre l'accès aux œuvres de l'esprit, la Licence Art Libre, au contraire, le favorise. L'intention est d'autoriser l'utilisation des ressources d'une œuvre ; créer de nouvelles conditions de création pour amplifier les possibilités de création. La Licence Art Libre permet d'avoir jouissance des œuvres tout en reconnaissant les droits et les responsabilités de chacun.\n\nAvec le développement du numérique, l'invention d'internet et des logiciels libres, les modalités de création ont évolué : les productions de l'esprit s'offrent naturellement à la circulation, à l'échange et aux transformations. Elles se prêtent favorablement à la réalisation d'œuvres communes que chacun peut augmenter pour l'avantage de tous.\n\nC'est la raison essentielle de la Licence Art Libre : promouvoir et protéger ces productions de l'esprit selon les principes du copyleft : liberté d'usage, de copie, de diffusion, de transformation et interdiction d'appropriation exclusive.\n\nDéfinitions :\n\nNous désignons par « œuvre », autant l'œuvre initiale, les œuvres conséquentes, que l'œuvre commune telles que définies ci-après :\n\nL'œuvre commune : Il s'agit d'une œuvre qui comprend l'œuvre initiale ainsi que toutes les contributions postérieures (les originaux conséquents et les copies). Elle est créée à l'initiative de l'auteur initial qui par cette licence définit les conditions selon lesquelles les contributions sont faites.\n\nL'œuvre initiale : C'est-à-dire l'œuvre créée par l'initiateur de l'œuvre commune dont les copies vont être modifiées par qui le souhaite.\n\nLes œuvres conséquentes : C'est-à-dire les contributions des auteurs qui participent à la formation de l'œuvre commune en faisant usage des droits de reproduction, de diffusion et de modification que leur confère la licence.\n\nOriginaux (sources ou ressources de l'œuvre) : Chaque exemplaire daté de l'œuvre initiale ou conséquente que leurs auteurs présentent comme référence pour toutes actualisations, interprétations, copies ou reproductions ultérieures.\n\nCopie : Toute reproduction d'un original au sens de cette licence.\n\n   1- OBJET.\n\n   Cette licence a pour objet de définir les conditions selon lesquelles vous pouvez jouir librement de l'œuvre.\n\n   2. L'ÉTENDUE DE LA JOUISSANCE.\n\n   Cette œuvre est soumise au droit d'auteur, et l'auteur par cette licence vous indique quelles sont vos libertés pour la copier, la diffuser et la modifier.\n\n      2.1 LA LIBERTÉ DE COPIER (OU DE REPRODUCTION).\n\n      Vous avez la liberté de copier cette œuvre pour vous, vos amis ou toute autre personne, quelle que soit la technique employée.\n\n      2.2 LA LIBERTÉ DE DIFFUSER (INTERPRÉTER, REPRÉSENTER, DISTRIBUER).\n\n      Vous pouvez diffuser librement les copies de ces œuvres, modifiées ou non, quel que soit le support, quel que soit le lieu, à titre onéreux ou gratuit, si vous respectez toutes les conditions suivantes :\n\n         1. joindre aux copies cette licence à l'identique ou indiquer précisément où se trouve la licence ;\n\n         2. indiquer au destinataire le nom de chaque auteur des originaux, y compris le vôtre si vous avez modifié l'œuvre ;\n\n         3. indiquer au destinataire où il pourrait avoir accès aux originaux (initiaux et/ou conséquents). Les auteurs des originaux pourront, s'ils le souhaitent, vous autoriser à diffuser l'original dans les mêmes conditions que les copies.\n\n      2.3 LA LIBERTÉ DE MODIFIER.\n\n      Vous avez la liberté de modifier les copies des originaux (initiaux et conséquents) dans le respect des conditions suivantes :\n\n         1. celles prévues à l'article 2.2 en cas de diffusion de la copie modifiée ;\n\n         2. indiquer qu'il s'agit d'une œuvre modifiée et, si possible, la nature de la modification ;\n\n         3. diffuser cette œuvre conséquente avec la même licence ou avec toute licence compatible ;\n\n         4. Les auteurs des originaux pourront, s'ils le souhaitent, vous autoriser à modifier l'original dans les mêmes conditions que les copies.\n\n   3. DROITS CONNEXES.\n\n   Les actes donnant lieu à des droits d'auteur ou des droits voisins ne doivent pas constituer un obstacle aux libertés conférées par cette licence.\n\n   C'est pourquoi, par exemple, les interprétations doivent être soumises à la même licence ou une licence compatible. De même, l'intégration de l'œuvre à une base de données, une compilation ou une anthologie ne doit pas faire obstacle à la jouissance de l'œuvre telle que définie par cette licence.\n\n   4. L' INTÉGRATION DE L'ŒUVRE.\n\n   Toute intégration de cette œuvre à un ensemble non soumis à la LAL doit assurer l'exercice des libertés conférées par cette licence.\n\n   Si l'œuvre n'est plus accessible indépendamment de l'ensemble, alors l'intégration n'est possible qu'à condition que l'ensemble soit soumis à la LAL ou une licence compatible.\n\n   5. CRITÈRES DE COMPATIBILITÉ.\n\n   Une licence est compatible avec la LAL si et seulement si :\n\n      1. elle accorde l'autorisation de copier, diffuser et modifier des copies de l'œuvre, y compris à des fins lucratives, et sans autres restrictions que celles qu'impose le respect des autres critères de compatibilité ;\n\n      2. elle garantit la paternité de l'œuvre et l'accès aux versions antérieures de l'œuvre quand cet accès est possible ;\n\n      3. elle reconnaît la LAL également compatible (réciprocité) ;\n\n      4. elle impose que les modifications faites sur l'œuvre soient soumises à la même licence ou encore à une licence répondant aux critères de compatibilité posés par la LAL.\n\n   6. VOS DROITS INTELLECTUELS.\n\n   La LAL n'a pas pour objet de nier vos droits d'auteur sur votre contribution ni vos droits connexes. En choisissant de contribuer à l'évolution de cette œuvre commune, vous acceptez seulement d'offrir aux autres les mêmes autorisations sur votre contribution que celles qui vous ont été accordées par cette licence. Ces autorisations n'entraînent pas un dessaisissement de vos droits intellectuels.\n\n   7. VOS RESPONSABILITÉS.\n\n   La liberté de jouir de l'œuvre tel que permis par la LAL (liberté de copier, diffuser, modifier) implique pour chacun la responsabilité de ses propres faits.\n\n   8. LA DURÉE DE LA LICENCE.\n\n   Cette licence prend effet dès votre acceptation de ses dispositions. Le fait de copier, de diffuser, ou de modifier l'œuvre constitue une acceptation tacite.\n\n   Cette licence a pour durée la durée des droits d'auteur attachés à l'œuvre. Si vous ne respectez pas les termes de cette licence, vous perdez automatiquement les droits qu'elle vous confère.\n\n   Si le régime juridique auquel vous êtes soumis ne vous permet pas de respecter les termes de cette licence, vous ne pouvez pas vous prévaloir des libertés qu'elle confère.\n\n   9. LES DIFFÉRENTES VERSIONS DE LA LICENCE.\n\n   Cette licence pourra être modifiée régulièrement, en vue de son amélioration, par ses auteurs (les acteurs du mouvement Copyleft Attitude) sous la forme de nouvelles versions numérotées.\n\n   Vous avez toujours le choix entre vous contenter des dispositions contenues dans la version de la LAL sous laquelle la copie vous a été communiquée ou alors, vous prévaloir des dispositions d'une des versions ultérieures.\n\n   10. LES SOUS-LICENCES.\n\n   Les sous-licences ne sont pas autorisées par la présente. Toute personne qui souhaite bénéficier des libertés qu'elle confère sera liée directement aux auteurs de l'œuvre commune.\n\n   11. LE CONTEXTE JURIDIQUE.\n\n   Cette licence est rédigée en référence au droit français et à la Convention de Berne relative au droit d'auteur."],"licenseIds":["LAL-1.3"],"keywords":["art libre 1","libre 1 3","1 3 lal","3 lal 1","lal 1 3","1 3 pr","3 pr ambule","ambule avec la","librement les uvres","les uvres dans","uvres dans le","d ignorer ces","ignorer ces droits","ces droits la","droits la licence","art libre les","libre les reconna","en reformule l","reformule l exercice","l exercice en","exercice en permettant","en permettant tout","permettant tout un","tout un chacun","un chacun de","chacun de faire","atif des productions","des productions de","l esprit quels","esprit quels que","quels que soient","que soient leur","soient leur genre","leur genre et","genre et leur","et leur forme","leur forme d","forme d expression","d expression si","expression si en","si en r","en r gle","r gle g","gle g n","g n rale","n rale l","rale l application","l application du","application du droit","d auteur conduit","auteur conduit restreindre","s aux uvres","aux uvres de","uvres de l","l esprit la","esprit la licence","art libre au","libre au contraire","au contraire le","contraire le favorise","le favorise l","favorise l intention","est d autoriser","une uvre cr","uvre cr er","cr ation la","ation la licence","art libre permet","libre permet d","permet d avoir","d avoir jouissance","avoir jouissance des","jouissance des uvres","des uvres tout","uvres tout en","tout en reconnaissant","en reconnaissant les","reconnaissant les droits","les droits et","droits et les","et les responsabilit","les responsabilit s","responsabilit s de","s de chacun","de chacun avec","chacun avec le","avec le d","le d veloppement","d veloppement du","veloppement du num","l invention d","invention d internet","d internet et","logiciels libres les","libres les modalit","modalit s de","cr ation ont","ation ont volu","ont volu les","volu les productions","les productions de","l esprit s","esprit s offrent","s offrent naturellement","offrent naturellement la","naturellement la circulation","la circulation l","circulation l change","l change et","change et aux","et aux transformations","aux transformations elles","transformations elles se","elles se pr","se pr tent","pr tent favorablement","tent favorablement la","favorablement la r","r alisation d","alisation d uvres","d uvres communes","uvres communes que","communes que chacun","que chacun peut","chacun peut augmenter","peut augmenter pour","augmenter pour l","pour l avantage","l avantage de","avantage de tous","de tous c","tous c est","essentielle de la","prot ger ces","ger ces productions","ces productions de","l esprit selon","esprit selon les","selon les principes","les principes du","principes du copyleft","du copyleft libert","copyleft libert d","libert d usage","d usage de","usage de copie","copie de diffusion","diffusion de transformation","de transformation et","transformation et interdiction","et interdiction d","interdiction d appropriation","d appropriation exclusive","appropriation exclusive d","exclusive d finitions","d finitions nous","finitions nous d","nous d signons","d signons par","signons par uvre","par uvre autant","uvre autant l","autant l uvre","uvre initiale les","initiale les uvres","cons quentes que","quentes que l","que l uvre","uvre commune telles","commune telles que","d finies ci","finies ci apr","uvre commune il","commune il s","une uvre qui","uvre qui comprend","comprend l uvre","uvre initiale ainsi","initiale ainsi que","l auteur initial","auteur initial qui","initial qui par","faites l uvre","uvre initiale c","initiale c est","dire l uvre","l uvre cr","uvre cr e","uvre commune dont","souhaite les uvres","dire les contributions","les contributions des","contributions des auteurs","auteurs qui participent","qui participent la","participent la formation","uvre commune en","commune en faisant","la licence originaux","licence originaux sources"]},{"licenseTexts":["GNU LIBRARY GENERAL PUBLIC LICENSE\n\nVersion 2, June 1991 Copyright (C) 1991 Free Software Foundation, Inc.\n\n51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA\n\nEveryone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.\n\n[This is the first released version of the library GPL. It is numbered 2 because it goes with version 2 of the ordinary GPL.]\n\nPreamble\n\nThe licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public Licenses are intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users.\n\nThis license, the Library General Public License, applies to some specially designated Free Software Foundation software, and to any other libraries whose authors decide to use it. You can use it for your libraries, too.\n\nWhen we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things.\n\nTo protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the library, or if you modify it.\n\nFor example, if you distribute copies of the library, whether gratis or for a fee, you must give the recipients all the rights that we gave you. You must make sure that they, too, receive or can get the source code. If you link a program with the library, you must provide complete object files to the recipients so that they can relink them with the library, after making changes to the library and recompiling it. And you must show them these terms so they know their rights.\n\nOur method of protecting your rights has two steps: (1) copyright the library, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the library.\n\nAlso, for each distributor's protection, we want to make certain that everyone understands that there is no warranty for this free library. If the library is modified by someone else and passed on, we want its recipients to know that what they have is not the original version, so that any problems introduced by others will not reflect on the original authors' reputations.\n\nFinally, any free program is threatened constantly by software patents. We wish to avoid the danger that companies distributing free software will individually obtain patent licenses, thus in effect transforming the program into proprietary software. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all.\n\nMost GNU software, including some libraries, is covered by the ordinary GNU General Public License, which was designed for utility programs. This license, the GNU Library General Public License, applies to certain designated libraries. This license is quite different from the ordinary one; be sure to read it in full, and don't assume that anything in it is the same as in the ordinary license.\n\nThe reason we have a separate public license for some libraries is that they blur the distinction we usually make between modifying or adding to a program and simply using it. Linking a program with a library, without changing the library, is in some sense simply using the library, and is analogous to running a utility program or application program. However, in a textual and legal sense, the linked executable is a combined work, a derivative of the original library, and the ordinary General Public License treats it as such.\n\nBecause of this blurred distinction, using the ordinary General Public License for libraries did not effectively promote software sharing, because most developers did not use the libraries. We concluded that weaker conditions might promote sharing better.\n\nHowever, unrestricted linking of non-free programs would deprive the users of those programs of all benefit from the free status of the libraries themselves. This Library General Public License is intended to permit developers of non-free programs to use free libraries, while preserving your freedom as a user of such programs to change the free libraries that are incorporated in them. (We have not seen how to achieve this as regards changes in header files, but we have achieved it as regards changes in the actual functions of the Library.) The hope is that this will lead to faster development of free libraries.\n\nThe precise terms and conditions for copying, distribution and modification follow. Pay close attention to the difference between a \"work based on the library\" and a \"work that uses the library\". The former contains code derived from the library, while the latter only works together with the library.\n\nNote that it is possible for a library to be covered by the ordinary General Public License rather than by this special one.\n\nTERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION\n\n   0. This License Agreement applies to any software library which contains a notice placed by the copyright holder or other authorized party saying it may be distributed under the terms of this Library General Public License (also called \"this License\"). Each licensee is addressed as \"you\".\n\n   A \"library\" means a collection of software functions and/or data prepared so as to be conveniently linked with application programs (which use some of those functions and data) to form executables.\n\n   The \"Library\", below, refers to any such software library or work which has been distributed under these terms. A \"work based on the Library\" means either the Library or any derivative work under copyright law: that is to say, a work containing the Library or a portion of it, either verbatim or with modifications and/or translated straightforwardly into another language. (Hereinafter, translation is included without limitation in the term \"modification\".)\n\n   \"Source code\" for a work means the preferred form of the work for making modifications to it. For a library, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the library.\n\n   Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running a program using the Library is not restricted, and output from such a program is covered only if its contents constitute a work based on the Library (independent of the use of the Library in a tool for writing it). Whether that is true depends on what the Library does and what the program that uses the Library does.\n\n   1. You may copy and distribute verbatim copies of the Library's complete source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and distribute a copy of this License along with the Library.\n\n   You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee.\n\n   2. You may modify your copy or copies of the Library or any portion of it, thus forming a work based on the Library, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions:\n\n      a) The modified work must itself be a software library.\n\n      b) You must cause the files modified to carry prominent notices stating that you changed the files and the date of any change.\n\n      c) You must cause the whole of the work to be licensed at no charge to all third parties under the terms of this License.\n\n      d) If a facility in the modified Library refers to a function or a table of data to be supplied by an application program that uses the facility, other than as an argument passed when the facility is invoked, then you must make a good faith effort to ensure that, in the event an application does not supply such function or table, the facility still operates, and performs whatever part of its purpose remains meaningful.\n\n      (For example, a function in a library to compute square roots has a purpose that is entirely well-defined independent of the application. Therefore, Subsection 2d requires that any application-supplied function or table used by this function must be optional: if the application does not supply it, the square root function must still compute square roots.)\n\n   These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Library, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Library, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it.\n\n   Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Library.\n\n   In addition, mere aggregation of another work not based on the Library with the Library (or with a work based on the Library) on a volume of a storage or distribution medium does not bring the other work under the scope of this License.\n\n   3. You may opt to apply the terms of the ordinary GNU General Public License instead of this License to a given copy of the Library. To do this, you must alter all the notices that refer to this License, so that they refer to the ordinary GNU General Public License, version 2, instead of to this License. (If a newer version than version 2 of the ordinary GNU General Public License has appeared, then you can specify that version instead if you wish.) Do not make any other change in these notices.\n\n   Once this change is made in a given copy, it is irreversible for that copy, so the ordinary GNU General Public License applies to all subsequent copies and derivative works made from that copy.\n\n   This option is useful when you wish to copy part of the code of the Library into a program that is not a library.\n\n   4. You may copy and distribute the Library (or a portion or derivative of it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange.\n\n   If distribution of object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place satisfies the requirement to distribute the source code, even though third parties are not compelled to copy the source along with the object code.\n\n   5. A program that contains no derivative of any portion of the Library, but is designed to work with the Library by being compiled or linked with it, is called a \"work that uses the Library\". Such a work, in isolation, is not a derivative work of the Library, and therefore falls outside the scope of this License.\n\n   However, linking a \"work that uses the Library\" with the Library creates an executable that is a derivative of the Library (because it contains portions of the Library), rather than a \"work that uses the library\". The executable is therefore covered by this License. Section 6 states terms for distribution of such executables.\n\n   When a \"work that uses the Library\" uses material from a header file that is part of the Library, the object code for the work may be a derivative work of the Library even though the source code is not. Whether this is true is especially significant if the work can be linked without the Library, or if the work is itself a library. The threshold for this to be true is not precisely defined by law.\n\n   If such an object file uses only numerical parameters, data structure layouts and accessors, and small macros and small inline functions (ten lines or less in length), then the use of the object file is unrestricted, regardless of whether it is legally a derivative work. (Executables containing this object code plus portions of the Library will still fall under Section 6.)\n\n   Otherwise, if the work is a derivative of the Library, you may distribute the object code for the work under the terms of Section 6. Any executables containing that work also fall under Section 6, whether or not they are linked directly with the Library itself.\n\n   6. As an exception to the Sections above, you may also compile or link a \"work that uses the Library\" with the Library to produce a work containing portions of the Library, and distribute that work under terms of your choice, provided that the terms permit modification of the work for the customer's own use and reverse engineering for debugging such modifications.\n\n   You must give prominent notice with each copy of the work that the Library is used in it and that the Library and its use are covered by this License. You must supply a copy of this License. If the work during execution displays copyright notices, you must include the copyright notice for the Library among them, as well as a reference directing the user to the copy of this License. Also, you must do one of these things:\n\n      a) Accompany the work with the complete corresponding machine-readable source code for the Library including whatever changes were used in the work (which must be distributed under Sections 1 and 2 above); and, if the work is an executable linked with the Library, with the complete machine-readable \"work that uses the Library\", as object code and/or source code, so that the user can modify the Library and then relink to produce a modified executable containing the modified Library. (It is understood that the user who changes the contents of definitions files in the Library will not necessarily be able to recompile the application to use the modified definitions.)\n\n      b) Accompany the work with a written offer, valid for at least three years, to give the same user the materials specified in Subsection 6a, above, for a charge no more than the cost of performing this distribution.\n\n      c) If distribution of the work is made by offering access to copy from a designated place, offer equivalent access to copy the above specified materials from the same place.\n\n      d) Verify that the user has already received a copy of these materials or that you have already sent this user a copy.\n\n   For an executable, the required form of the \"work that uses the Library\" must include any data and utility programs needed for reproducing the executable from it. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable.\n\n   It may happen that this requirement contradicts the license restrictions of other proprietary libraries that do not normally accompany the operating system. Such a contradiction means you cannot use both them and the Library together in an executable that you distribute.\n\n   7. You may place library facilities that are a work based on the Library side-by-side in a single library together with other library facilities not covered by this License, and distribute such a combined library, provided that the separate distribution of the work based on the Library and of the other library facilities is otherwise permitted, and provided that you do these two things:\n\n      a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities. This must be distributed under the terms of the Sections above.\n\n      b) Give prominent notice with the combined library of the fact that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work.\n\n   8. You may not copy, modify, sublicense, link with, or distribute the Library except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense, link with, or distribute the Library is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance.\n\n   9. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Library or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Library (or any work based on the Library), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Library or works based on it.\n\n   10. Each time you redistribute the Library (or any work based on the Library), the recipient automatically receives a license from the original licensor to copy, distribute, link with or modify the Library subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License.\n\n   11. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Library at all. For example, if a patent license would not permit royalty-free redistribution of the Library by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Library.\n\n   If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply, and the section as a whole is intended to apply in other circumstances.\n\n   It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice.\n\n   This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License.\n\n   12. If the distribution and/or use of the Library is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Library under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License.\n\n   13. The Free Software Foundation may publish revised and/or new versions of the Library General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.\n\n   Each version is given a distinguishing version number. If the Library specifies a version number of this License which applies to it and \"any later version\", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Library does not specify a license version number, you may choose any version ever published by the Free Software Foundation.\n\n   14. If you wish to incorporate parts of the Library into other free programs whose distribution conditions are incompatible with these, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally.\n\n   NO WARRANTY\n\n   15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE LIBRARY \"AS IS\" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.\n\n   16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS\n\nHow to Apply These Terms to Your New Libraries\n\nIf you develop a new library, and you want it to be of the greatest possible use to the public, we recommend making it free software that everyone can redistribute and change. You can do so by permitting redistribution under these terms (or, alternatively, under the terms of the ordinary General Public License).\n\nTo apply these terms, attach the following notices to the library. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the \"copyright\" line and a pointer to where the full notice is found.\n\none line to give the library's name and an idea of what it does.\n\nCopyright (C) year name of author\n\nThis library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.\n\nThis library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details.\n\nYou should have received a copy of the GNU Library General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.\n\nAlso add information on how to contact you by electronic and paper mail.\n\nYou should also get your employer (if you work as a programmer) or your school, if any, to sign a \"copyright disclaimer\" for the library, if necessary. Here is a sample; alter the names:\n\nYoyodyne, Inc., hereby disclaims all copyright interest in\n\nthe library `Frob' (a library for tweaking knobs) written\n\nby James Random Hacker.\n\nsignature of Ty Coon, 1 April 1990\n\nTy Coon, President of Vice\n\nThat's all there is to it!"],"licenseIds":["LGPL-2.0-or-later","LGPL-2.0-only","LGPL-2.0+","LGPL-2.0"],"keywords":["c 1991 free","the library gpl","library gpl it","gpl it is","it is numbered","is numbered 2","numbered 2 because","2 because it","because it goes","it goes with","goes with version","with version 2","the ordinary gpl","ordinary gpl preamble","gpl preamble the","specially designated free","designated free software","foundation software and","any other libraries","other libraries whose","libraries whose authors","whose authors decide","authors decide to","for your libraries","your libraries too","libraries too when","you link a","link a program","their rights our","rights our method","our method of","method of protecting","of protecting your","protecting your rights","your rights has","rights has two","has two steps","the library also","library also for","for each distributor","each distributor s","distributor s protection","s protection we","protection we want","this free library","free library if","danger that companies","that companies distributing","companies distributing free","distributing free software","free software will","software will individually","patent licenses thus","licenses thus in","thus in effect","in effect transforming","effect transforming the","transforming the program","into proprietary software","proprietary software to","software to prevent","at all most","all most gnu","license which was","which was designed","was designed for","designed for utility","for utility programs","utility programs this","programs this license","designated libraries this","libraries this license","license is quite","the ordinary one","ordinary one be","one be sure","be sure to","sure to read","read it in","it in full","in full and","full and don","and don t","don t assume","t assume that","assume that anything","that anything in","anything in it","in it is","same as in","in the ordinary","the ordinary license","ordinary license the","license the reason","reason we have","we have a","have a separate","a separate public","separate public license","license for some","for some libraries","libraries is that","is that they","that they blur","they blur the","blur the distinction","the distinction we","distinction we usually","we usually make","usually make between","make between modifying","between modifying or","modifying or adding","or adding to","adding to a","a program and","program and simply","and simply using","simply using it","using it linking","it linking a","linking a program","a library without","library without changing","changing the library","library is in","is in some","in some sense","some sense simply","sense simply using","simply using the","library and is","and is analogous","is analogous to","analogous to running","to running a","running a utility","a utility program","utility program or","program or application","or application program","application program however","program however in","however in a","in a textual","a textual and","textual and legal","and legal sense","legal sense the","sense the linked","the linked executable","linked executable is","executable is a","is a combined","original library and","library and the","and the ordinary","public license treats","license treats it","treats it as","it as such","as such because","such because of","of this blurred","this blurred distinction","blurred distinction using","distinction using the","using the ordinary","license for libraries","for libraries did","libraries did not","did not effectively","not effectively promote","effectively promote software","promote software sharing","software sharing because","sharing because most","because most developers","most developers did","developers did not","did not use","use the libraries","the libraries we","libraries we concluded","we concluded that","concluded that weaker","that weaker conditions","weaker conditions might","conditions might promote","might promote sharing","promote sharing better","sharing better however","better however unrestricted","however unrestricted linking","unrestricted linking of","linking of non","free programs would","programs would deprive","would deprive the","deprive the users"]},{"licenseTexts":["GNU LESSER GENERAL PUBLIC LICENSE\n\nVersion 2.1, February 1999\n\nCopyright (C) 1991, 1999 Free Software Foundation, Inc.\n\n51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n\nEveryone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.\n\n[This is the first released version of the Lesser GPL. It also counts as the successor of the GNU Library Public License, version 2, hence the version number 2.1.]\n\nPreamble\n\nThe licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public Licenses are intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users.\n\nThis license, the Lesser General Public License, applies to some specially designated software packages--typically libraries--of the Free Software Foundation and other authors who decide to use it. You can use it too, but we suggest you first think carefully about whether this license or the ordinary General Public License is the better strategy to use in any particular case, based on the explanations below.\n\nWhen we speak of free software, we are referring to freedom of use, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish); that you receive source code or can get it if you want it; that you can change the software and use pieces of it in new free programs; and that you are informed that you can do these things.\n\nTo protect your rights, we need to make restrictions that forbid distributors to deny you these rights or to ask you to surrender these rights. These restrictions translate to certain responsibilities for you if you distribute copies of the library or if you modify it.\n\nFor example, if you distribute copies of the library, whether gratis or for a fee, you must give the recipients all the rights that we gave you. You must make sure that they, too, receive or can get the source code. If you link other code with the library, you must provide complete object files to the recipients, so that they can relink them with the library after making changes to the library and recompiling it. And you must show them these terms so they know their rights.\n\nWe protect your rights with a two-step method: (1) we copyright the library, and (2) we offer you this license, which gives you legal permission to copy, distribute and/or modify the library.\n\nTo protect each distributor, we want to make it very clear that there is no warranty for the free library. Also, if the library is modified by someone else and passed on, the recipients should know that what they have is not the original version, so that the original author's reputation will not be affected by problems that might be introduced by others.\n\nFinally, software patents pose a constant threat to the existence of any free program. We wish to make sure that a company cannot effectively restrict the users of a free program by obtaining a restrictive license from a patent holder. Therefore, we insist that any patent license obtained for a version of the library must be consistent with the full freedom of use specified in this license.\n\nMost GNU software, including some libraries, is covered by the ordinary GNU General Public License. This license, the GNU Lesser General Public License, applies to certain designated libraries, and is quite different from the ordinary General Public License. We use this license for certain libraries in order to permit linking those libraries into non-free programs.\n\nWhen a program is linked with a library, whether statically or using a shared library, the combination of the two is legally speaking a combined work, a derivative of the original library. The ordinary General Public License therefore permits such linking only if the entire combination fits its criteria of freedom. The Lesser General Public License permits more lax criteria for linking other code with the library.\n\nWe call this license the \"Lesser\" General Public License because it does Less to protect the user's freedom than the ordinary General Public License. It also provides other free software developers Less of an advantage over competing non-free programs. These disadvantages are the reason we use the ordinary General Public License for many libraries. However, the Lesser license provides advantages in certain special circumstances.\n\nFor example, on rare occasions, there may be a special need to encourage the widest possible use of a certain library, so that it becomes a de-facto standard. To achieve this, non-free programs must be allowed to use the library. A more frequent case is that a free library does the same job as widely used non-free libraries. In this case, there is little to gain by limiting the free library to free software only, so we use the Lesser General Public License.\n\nIn other cases, permission to use a particular library in non-free programs enables a greater number of people to use a large body of free software. For example, permission to use the GNU C Library in non-free programs enables many more people to use the whole GNU operating system, as well as its variant, the GNU/Linux operating system.\n\nAlthough the Lesser General Public License is Less protective of the users' freedom, it does ensure that the user of a program that is linked with the Library has the freedom and the wherewithal to run that program using a modified version of the Library.\n\nThe precise terms and conditions for copying, distribution and modification follow. Pay close attention to the difference between a \"work based on the library\" and a \"work that uses the library\". The former contains code derived from the library, whereas the latter must be combined with the library in order to run.\n\nTERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION\n\n   0. This License Agreement applies to any software library or other program which contains a notice placed by the copyright holder or other authorized party saying it may be distributed under the terms of this Lesser General Public License (also called \"this License\"). Each licensee is addressed as \"you\".\n\n   A \"library\" means a collection of software functions and/or data prepared so as to be conveniently linked with application programs (which use some of those functions and data) to form executables.\n\n   The \"Library\", below, refers to any such software library or work which has been distributed under these terms. A \"work based on the Library\" means either the Library or any derivative work under copyright law: that is to say, a work containing the Library or a portion of it, either verbatim or with modifications and/or translated straightforwardly into another language. (Hereinafter, translation is included without limitation in the term \"modification\".)\n\n   \"Source code\" for a work means the preferred form of the work for making modifications to it. For a library, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the library.\n\n   Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running a program using the Library is not restricted, and output from such a program is covered only if its contents constitute a work based on the Library (independent of the use of the Library in a tool for writing it). Whether that is true depends on what the Library does and what the program that uses the Library does.\n\n   1. You may copy and distribute verbatim copies of the Library's complete source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and distribute a copy of this License along with the Library.\n\n   You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee.\n\n   2. You may modify your copy or copies of the Library or any portion of it, thus forming a work based on the Library, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions:\n\n      a) The modified work must itself be a software library.\n\n      b) You must cause the files modified to carry prominent notices stating that you changed the files and the date of any change.\n\n      c) You must cause the whole of the work to be licensed at no charge to all third parties under the terms of this License.\n\n      d) If a facility in the modified Library refers to a function or a table of data to be supplied by an application program that uses the facility, other than as an argument passed when the facility is invoked, then you must make a good faith effort to ensure that, in the event an application does not supply such function or table, the facility still operates, and performs whatever part of its purpose remains meaningful.\n\n   (For example, a function in a library to compute square roots has a purpose that is entirely well-defined independent of the application. Therefore, Subsection 2d requires that any application-supplied function or table used by this function must be optional: if the application does not supply it, the square root function must still compute square roots.)\n\n   These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Library, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Library, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it.\n\n   Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Library.\n\n   In addition, mere aggregation of another work not based on the Library with the Library (or with a work based on the Library) on a volume of a storage or distribution medium does not bring the other work under the scope of this License.\n\n   3. You may opt to apply the terms of the ordinary GNU General Public License instead of this License to a given copy of the Library. To do this, you must alter all the notices that refer to this License, so that they refer to the ordinary GNU General Public License, version 2, instead of to this License. (If a newer version than version 2 of the ordinary GNU General Public License has appeared, then you can specify that version instead if you wish.) Do not make any other change in these notices.\n\n   Once this change is made in a given copy, it is irreversible for that copy, so the ordinary GNU General Public License applies to all subsequent copies and derivative works made from that copy.\n\n   This option is useful when you wish to copy part of the code of the Library into a program that is not a library.\n\n   4. You may copy and distribute the Library (or a portion or derivative of it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange.\n\n   If distribution of object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place satisfies the requirement to distribute the source code, even though third parties are not compelled to copy the source along with the object code.\n\n   5. A program that contains no derivative of any portion of the Library, but is designed to work with the Library by being compiled or linked with it, is called a \"work that uses the Library\". Such a work, in isolation, is not a derivative work of the Library, and therefore falls outside the scope of this License.\n\n   However, linking a \"work that uses the Library\" with the Library creates an executable that is a derivative of the Library (because it contains portions of the Library), rather than a \"work that uses the library\". The executable is therefore covered by this License. Section 6 states terms for distribution of such executables.\n\n   When a \"work that uses the Library\" uses material from a header file that is part of the Library, the object code for the work may be a derivative work of the Library even though the source code is not. Whether this is true is especially significant if the work can be linked without the Library, or if the work is itself a library. The threshold for this to be true is not precisely defined by law.\n\n   If such an object file uses only numerical parameters, data structure layouts and accessors, and small macros and small inline functions (ten lines or less in length), then the use of the object file is unrestricted, regardless of whether it is legally a derivative work. (Executables containing this object code plus portions of the Library will still fall under Section 6.)\n\n   Otherwise, if the work is a derivative of the Library, you may distribute the object code for the work under the terms of Section 6. Any executables containing that work also fall under Section 6, whether or not they are linked directly with the Library itself.\n\n   6. As an exception to the Sections above, you may also combine or link a \"work that uses the Library\" with the Library to produce a work containing portions of the Library, and distribute that work under terms of your choice, provided that the terms permit modification of the work for the customer's own use and reverse engineering for debugging such modifications.\n\n   You must give prominent notice with each copy of the work that the Library is used in it and that the Library and its use are covered by this License. You must supply a copy of this License. If the work during execution displays copyright notices, you must include the copyright notice for the Library among them, as well as a reference directing the user to the copy of this License. Also, you must do one of these things:\n\n      a) Accompany the work with the complete corresponding machine-readable source code for the Library including whatever changes were used in the work (which must be distributed under Sections 1 and 2 above); and, if the work is an executable linked with the Library, with the complete machine-readable \"work that uses the Library\", as object code and/or source code, so that the user can modify the Library and then relink to produce a modified executable containing the modified Library. (It is understood that the user who changes the contents of definitions files in the Library will not necessarily be able to recompile the application to use the modified definitions.)\n\n      b) Use a suitable shared library mechanism for linking with the Library. A suitable mechanism is one that (1) uses at run time a copy of the library already present on the user's computer system, rather than copying library functions into the executable, and (2) will operate properly with a modified version of the library, if the user installs one, as long as the modified version is interface-compatible with the version that the work was made with.\n\n      c) Accompany the work with a written offer, valid for at least three years, to give the same user the materials specified in Subsection 6a, above, for a charge no more than the cost of performing this distribution.\n\n      d) If distribution of the work is made by offering access to copy from a designated place, offer equivalent access to copy the above specified materials from the same place.\n\n      e) Verify that the user has already received a copy of these materials or that you have already sent this user a copy.\n\n   For an executable, the required form of the \"work that uses the Library\" must include any data and utility programs needed for reproducing the executable from it. However, as a special exception, the materials to be distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable.\n\n   It may happen that this requirement contradicts the license restrictions of other proprietary libraries that do not normally accompany the operating system. Such a contradiction means you cannot use both them and the Library together in an executable that you distribute.\n\n   7. You may place library facilities that are a work based on the Library side-by-side in a single library together with other library facilities not covered by this License, and distribute such a combined library, provided that the separate distribution of the work based on the Library and of the other library facilities is otherwise permitted, and provided that you do these two things:\n\n      a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities. This must be distributed under the terms of the Sections above.\n\n      b) Give prominent notice with the combined library of the fact that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work.\n\n   8. You may not copy, modify, sublicense, link with, or distribute the Library except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense, link with, or distribute the Library is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance.\n\n   9. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Library or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Library (or any work based on the Library), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Library or works based on it.\n\n   10. Each time you redistribute the Library (or any work based on the Library), the recipient automatically receives a license from the original licensor to copy, distribute, link with or modify the Library subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties with this License.\n\n   11. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Library at all. For example, if a patent license would not permit royalty-free redistribution of the Library by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Library.\n\n   If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply, and the section as a whole is intended to apply in other circumstances.\n\n   It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice.\n\n   This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License.\n\n   12. If the distribution and/or use of the Library is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Library under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License.\n\n   13. The Free Software Foundation may publish revised and/or new versions of the Lesser General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.\n\n   Each version is given a distinguishing version number. If the Library specifies a version number of this License which applies to it and \"any later version\", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Library does not specify a license version number, you may choose any version ever published by the Free Software Foundation.\n\n   14. If you wish to incorporate parts of the Library into other free programs whose distribution conditions are incompatible with these, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally.\n\n   NO WARRANTY\n\n   15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE LIBRARY \"AS IS\" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.\n\n   16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS\n\nHow to Apply These Terms to Your New Libraries\n\nIf you develop a new library, and you want it to be of the greatest possible use to the public, we recommend making it free software that everyone can redistribute and change. You can do so by permitting redistribution under these terms (or, alternatively, under the terms of the ordinary General Public License).\n\nTo apply these terms, attach the following notices to the library. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the \"copyright\" line and a pointer to where the full notice is found.\n\n\u003cone line to give the library's name and an idea of what it does.\u003e\n\nCopyright (C) \u003cyear\u003e \u003cname of author\u003e\n\nThis library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.\n\nThis library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.\n\nYou should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n\nAlso add information on how to contact you by electronic and paper mail.\n\nYou should also get your employer (if you work as a programmer) or your school, if any, to sign a \"copyright disclaimer\" for the library, if necessary. Here is a sample; alter the names:\n\nYoyodyne, Inc., hereby disclaims all copyright interest in\n\nthe library `Frob' (a library for tweaking knobs) written\n\nby James Random Hacker.\n\n\u003c signature of Ty Coon \u003e , 1 April 1990\n\nTy Coon, President of Vice\n\nThat's all there is to it!"],"licenseIds":["LGPL-2.1-or-later","LGPL-2.1-only","LGPL-2.1+","LGPL-2.1"],"keywords":["2 1 february","1 february 1999","february 1999 copyright","c 1991 1999","1991 1999 free","1999 free software","the lesser gpl","lesser gpl it","gpl it also","it also counts","also counts as","counts as the","as the successor","the successor of","successor of the","gnu library public","library public license","version 2 hence","2 hence the","hence the version","2 1 preamble","1 preamble the","specially designated software","designated software packages","software packages typically","packages typically libraries","typically libraries of","software foundation and","foundation and other","and other authors","other authors who","authors who decide","who decide to","use it too","it too but","too but we","but we suggest","we suggest you","suggest you first","you first think","first think carefully","think carefully about","carefully about whether","about whether this","whether this license","or the ordinary","is the better","the better strategy","better strategy to","strategy to use","in any particular","any particular case","particular case based","case based on","on the explanations","the explanations below","explanations below when","below when we","to freedom of","of use not","use not price","software and use","and use pieces","you are informed","are informed that","informed that you","that forbid distributors","forbid distributors to","distributors to deny","to surrender these","surrender these rights","these rights these","you link other","link other code","rights with a","with a two","a two step","two step method","step method 1","method 1 we","1 we copyright","we copyright the","and 2 we","2 we offer","we offer you","library to protect","to protect each","protect each distributor","each distributor we","distributor we want","make it very","it very clear","very clear that","clear that there","free library also","library also if","also if the","passed on the","the recipients should","recipients should know","should know that","author s reputation","s reputation will","reputation will not","affected by problems","by problems that","problems that might","that might be","might be introduced","be introduced by","by others finally","others finally software","finally software patents","software patents pose","patents pose a","pose a constant","a constant threat","constant threat to","threat to the","to the existence","existence of any","of any free","free program we","program we wish","wish to make","sure that a","that a company","a company cannot","company cannot effectively","cannot effectively restrict","effectively restrict the","restrict the users","users of a","free program by","program by obtaining","by obtaining a","obtaining a restrictive","a restrictive license","restrictive license from","from a patent","a patent holder","patent holder therefore","holder therefore we","therefore we insist","we insist that","insist that any","patent license obtained","license obtained for","obtained for a","library must be","must be consistent","with the full","the full freedom","full freedom of","of use specified","use specified in","this license most","license most gnu","designated libraries and","libraries and is","and is quite","public license we","license we use","we use this","license for certain","for certain libraries","certain libraries in","libraries in order","order to permit","permit linking those","linking those libraries","those libraries into","libraries into non","into non free","free programs when","programs when a","when a program","program is linked","linked with a","a library whether","library whether statically","whether statically or","statically or using","or using a","using a shared","a shared library","shared library the","library the combination","of the two","the two is","two is legally","is legally speaking","legally speaking a","speaking a combined","original library the","library the ordinary","public license therefore","license therefore permits","therefore permits such","permits such linking"]},{"licenseTexts":["GNU LESSER GENERAL PUBLIC LICENSE\n\nVersion 3, 29 June 2007\n\nCopyright (C) 2007 Free Software Foundation, Inc. \u003chttps://fsf.org/\u003e\n\nEveryone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.\n\nThis version of the GNU Lesser General Public License incorporates the terms and conditions of version 3 of the GNU General Public License, supplemented by the additional permissions listed below.\n\n   0. Additional Definitions.\n\n      \n\n      As used herein, \"this License\" refers to version 3 of the GNU Lesser General Public License, and the \"GNU GPL\" refers to version 3 of the GNU General Public License.\n\n      \n\n      \"The Library\" refers to a covered work governed by this License, other than an Application or a Combined Work as defined below.\n\n      \n\n      An \"Application\" is any work that makes use of an interface provided by the Library, but which is not otherwise based on the Library. Defining a subclass of a class defined by the Library is deemed a mode of using an interface provided by the Library.\n\n      \n\n      A \"Combined Work\" is a work produced by combining or linking an Application with the Library. The particular version of the Library with which the Combined Work was made is also called the \"Linked Version\".\n\n      \n\n      The \"Minimal Corresponding Source\" for a Combined Work means the Corresponding Source for the Combined Work, excluding any source code for portions of the Combined Work that, considered in isolation, are based on the Application, and not on the Linked Version.\n\n      \n\n      The \"Corresponding Application Code\" for a Combined Work means the object code and/or source code for the Application, including any data and utility programs needed for reproducing the Combined Work from the Application, but excluding the System Libraries of the Combined Work.\n\n   1. Exception to Section 3 of the GNU GPL.\n\n   You may convey a covered work under sections 3 and 4 of this License without being bound by section 3 of the GNU GPL.\n\n   2. Conveying Modified Versions.\n\n   If you modify a copy of the Library, and, in your modifications, a facility refers to a function or data to be supplied by an Application that uses the facility (other than as an argument passed when the facility is invoked), then you may convey a copy of the modified version:\n\n      a) under this License, provided that you make a good faith effort to ensure that, in the event an Application does not supply the function or data, the facility still operates, and performs whatever part of its purpose remains meaningful, or\n\n      b) under the GNU GPL, with none of the additional permissions of this License applicable to that copy.\n\n   3. Object Code Incorporating Material from Library Header Files.\n\n   The object code form of an Application may incorporate material from a header file that is part of the Library. You may convey such object code under terms of your choice, provided that, if the incorporated material is not limited to numerical parameters, data structure layouts and accessors, or small macros, inline functions and templates (ten or fewer lines in length), you do both of the following:\n\n      a) Give prominent notice with each copy of the object code that the Library is used in it and that the Library and its use are covered by this License.\n\n      b) Accompany the object code with a copy of the GNU GPL and this license document.\n\n   4. Combined Works.\n\n   You may convey a Combined Work under terms of your choice that, taken together, effectively do not restrict modification of the portions of the Library contained in the Combined Work and reverse engineering for debugging such modifications, if you also do each of the following:\n\n      a) Give prominent notice with each copy of the Combined Work that the Library is used in it and that the Library and its use are covered by this License.\n\n      b) Accompany the Combined Work with a copy of the GNU GPL and this license document.\n\n      c) For a Combined Work that displays copyright notices during execution, include the copyright notice for the Library among these notices, as well as a reference directing the user to the copies of the GNU GPL and this license document.\n\n      d) Do one of the following:\n\n         0) Convey the Minimal Corresponding Source under the terms of this License, and the Corresponding Application Code in a form suitable for, and under terms that permit, the user to recombine or relink the Application with a modified version of the Linked Version to produce a modified Combined Work, in the manner specified by section 6 of the GNU GPL for conveying Corresponding Source.\n\n         1) Use a suitable shared library mechanism for linking with the Library. A suitable mechanism is one that (a) uses at run time a copy of the Library already present on the user's computer system, and (b) will operate properly with a modified version of the Library that is interface-compatible with the Linked Version.\n\n      e) Provide Installation Information, but only if you would otherwise be required to provide such information under section 6 of the GNU GPL, and only to the extent that such information is necessary to install and execute a modified version of the Combined Work produced by recombining or relinking the Application with a modified version of the Linked Version. (If you use option 4d0, the Installation Information must accompany the Minimal Corresponding Source and Corresponding Application Code. If you use option 4d1, you must provide the Installation Information in the manner specified by section 6 of the GNU GPL for conveying Corresponding Source.)\n\n   5. Combined Libraries.\n\n   You may place library facilities that are a work based on the Library side by side in a single library together with other library facilities that are not Applications and are not covered by this License, and convey such a combined library under terms of your choice, if you do both of the following:\n\n      a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities, conveyed under the terms of this License.\n\n      b) Give prominent notice with the combined library that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work.\n\n   6. Revised Versions of the GNU Lesser General Public License.\n\n   The Free Software Foundation may publish revised and/or new versions of the GNU Lesser General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.\n\n   Each version is given a distinguishing version number. If the Library as you received it specifies that a certain numbered version of the GNU Lesser General Public License \"or any later version\" applies to it, you have the option of following the terms and conditions either of that published version or of any later version published by the Free Software Foundation. If the Library as you received it does not specify a version number of the GNU Lesser General Public License, you may choose any version of the GNU Lesser General Public License ever published by the Free Software Foundation.\n\n   If the Library as you received it specifies that a proxy can decide whether future versions of the GNU Lesser General Public License shall apply, that proxy's public statement of acceptance of any version is permanent authorization for you to choose that version for the Library."],"licenseIds":["LGPL-3.0-or-later","LGPL-3.0-only","LGPL-3.0+","LGPL-3.0"],"keywords":["allowed this version","public license incorporates","incorporates the terms","conditions of version","public license supplemented","license supplemented by","supplemented by the","by the additional","additional permissions listed","permissions listed below","listed below 0","below 0 additional","0 additional definitions","additional definitions as","definitions as used","as used herein","used herein this","and the gnu","gnu gpl refers","gpl refers to","the library refers","covered work governed","this license other","other than an","than an application","an application or","application or a","or a combined","combined work as","defined below an","below an application","an application is","application is any","is any work","work that makes","that makes use","library but which","the library defining","library defining a","defining a subclass","a subclass of","subclass of a","of a class","a class defined","class defined by","library is deemed","is deemed a","deemed a mode","a mode of","mode of using","of using an","using an interface","library a combined","combined work is","a work produced","produced by combining","by combining or","combining or linking","or linking an","linking an application","an application with","application with the","library the particular","the particular version","library with which","with which the","which the combined","combined work was","was made is","made is also","is also called","also called the","called the linked","version the minimal","for the combined","combined work excluding","work excluding any","excluding any source","code for portions","for portions of","work that considered","that considered in","considered in isolation","in isolation are","isolation are based","on the application","the application and","application and not","not on the","on the linked","version the corresponding","application code for","means the object","for the application","the application including","application including any","including any data","reproducing the combined","combined work from","from the application","the application but","application but excluding","but excluding the","excluding the system","combined work 1","work 1 exception","1 exception to","exception to section","gnu gpl you","work under sections","license without being","without being bound","being bound by","bound by section","gnu gpl 2","gpl 2 conveying","2 conveying modified","conveying modified versions","you modify a","modify a copy","library and in","and in your","your modifications a","modifications a facility","a facility refers","facility refers to","an application that","version a under","not supply the","supply the function","the function or","data the facility","remains meaningful or","meaningful or b","b under the","gnu gpl with","gpl with none","with none of","additional permissions of","permissions of this","applicable to that","to that copy","that copy 3","copy 3 object","3 object code","object code incorporating","code incorporating material","incorporating material from","material from library","from library header","library header files","header files the","files the object","form of an","of an application","an application may","application may incorporate","may incorporate material","incorporate material from","may convey such","convey such object","object code under","code under terms","if the incorporated","the incorporated material","incorporated material is","material is not","limited to numerical","to numerical parameters","and accessors or","accessors or small","or small macros","small macros inline","macros inline functions","inline functions and","functions and templates","and templates ten","templates ten or","ten or fewer","or fewer lines","fewer lines in","lines in length","in length you","length you do","object code that","license document 4","document 4 combined","4 combined works","combined works you","convey a combined","combined work under","choice that taken","that taken together","taken together effectively","together effectively do","effectively do not","not restrict modification","restrict modification of","of the portions","the portions of"]},{"licenseTexts":["Lesser General Public License For Linguistic Resources\n\nPreamble\n\nThe licenses for most data are designed to take away your freedom to share and change it. By contrast, this License is intended to guarantee your freedom to share and change free data--to make sure the data are free for all their users.\n\nThis License, the Lesser General Public License for Linguistic Resources, applies to some specially designated linguistic resources -- typically lexicons and grammars.\n\nTERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION\n\n   0. This License Agreement applies to any Linguistic Resource which contains a notice placed by the copyright holder or other authorized party saying it may be distributed under the terms of this Lesser General Public License for Linguistic Resources (also called \"this License\"). Each licensee is addressed as \"you\".\n\n   A \"linguistic resource\" means a collection of data about language prepared so as to be used with application programs.\n\n   The \"Linguistic Resource\", below, refers to any such work which has been distributed under these terms. A \"work based on the Linguistic Resource\" means either the Linguistic Resource or any derivative work under copyright law: that is to say, a work containing the Linguistic Resource or a portion of it, either verbatim or with modifications and/or translated straightforwardly into another language. (Hereinafter, translation is included without limitation in the term \"modification\".)\n\n   \"Legible form\" for a linguistic resource means the preferred form of the resource for making modifications to it.\n\n   Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running a program using the Linguistic Resource is not restricted, and output from such a program is covered only if its contents constitute a work based on the Linguistic Resource (independent of the use of the Linguistic Resource in a tool for writing it). Whether that is true depends on what the program that uses the Linguistic Resource does.\n\n   1. You may copy and distribute verbatim copies of the Linguistic Resource as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and distribute a copy of this License along with the Linguistic Resource.\n\n   You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee.\n\n   2. You may modify your copy or copies of the Linguistic Resource or any portion of it, thus forming a work based on the Linguistic Resource, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions:\n\n      a) The modified work must itself be a linguistic resource.\n\n      b) You must cause the files modified to carry prominent notices stating that you changed the files and the date of any change.\n\n      c) You must cause the whole of the work to be licensed at no charge to all third parties under the terms of this License.\n\n   These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Linguistic Resource, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Linguistic Resource, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it.\n\n   Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Linguistic Resource.\n\n   In addition, mere aggregation of another work not based on the Linguistic Resource with the Linguistic Resource (or with a work based on the Linguistic Resource) on a volume of a storage or distribution medium does not bring the other work under the scope of this License.\n\n   3. A program that contains no derivative of any portion of the Linguistic Resource, but is designed to work with the Linguistic Resource (or an encrypted form of the Linguistic Resource) by reading it or being compiled or linked with it, is called a \"work that uses the Linguistic Resource\". Such a work, in isolation, is not a derivative work of the Linguistic Resource, and therefore falls outside the scope of this License.\n\n   However, combining a \"work that uses the Linguistic Resource\" with the Linguistic Resource (or an encrypted form of the Linguistic Resource) creates a package that is a derivative of the Linguistic Resource (because it contains portions of the Linguistic Resource), rather than a \"work that uses the Linguistic Resource\". If the package is a derivative of the Linguistic Resource, you may distribute the package under the terms of Section 4. Any works containing that package also fall under Section 4.\n\n   4. As an exception to the Sections above, you may also combine a \"work that uses the Linguistic Resource\" with the Linguistic Resource (or an encrypted form of the Linguistic Resource) to produce a package containing portions of the Linguistic Resource, and distribute that package under terms of your choice, provided that the terms permit modification of the package for the customer's own use and reverse engineering for debugging such modifications.\n\n   You must give prominent notice with each copy of the package that the Linguistic Resource is used in it and that the Linguistic Resource and its use are covered by this License. You must supply a copy of this License. If the package during execution displays copyright notices, you must include the copyright notice for the Linguistic Resource among them, as well as a reference directing the user to the copy of this License. Also, you must do one of these things:\n\n      a) Accompany the package with the complete corresponding machine-readable legible form of the Linguistic Resource including whatever changes were used in the package (which must be distributed under Sections 1 and 2 above); and, if the package contains an encrypted form of the Linguistic Resource, with the complete machine-readable \"work that uses the Linguistic Resource\", as object code and/or source code, so that the user can modify the Linguistic Resource and then encrypt it to produce a modified package containing the modified Linguistic Resource.\n\n      b) Use a suitable mechanism for combining with the Linguistic Resource. A suitable mechanism is one that will operate properly with a modified version of the Linguistic Resource, if the user installs one, as long as the modified version is interface-compatible with the version that the package was made with.\n\n      c) Accompany the package with a written offer, valid for at least three years, to give the same user the materials specified in Subsection 4a, above, for a charge no more than the cost of performing this distribution.\n\n      d) If distribution of the package is made by offering access to copy from a designated place, offer equivalent access to copy the above specified materials from the same place.\n\n      e) Verify that the user has already received a copy of these materials or that you have already sent this user a copy.\n\n   If the package includes an encrypted form of the Linguistic Resource, the required form of the \"work that uses the Linguistic Resource\" must include any data and utility programs needed for reproducing the package from it. However, as a special exception, the materials to be distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable.\n\n   It may happen that this requirement contradicts the license restrictions of proprietary libraries that do not normally accompany the operating system. Such a contradiction means you cannot use both them and the Linguistic Resource together in a package that you distribute.\n\n   5. You may not copy, modify, sublicense, link with, or distribute the Linguistic Resource except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense, link with, or distribute the Linguistic Resource is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance.\n\n   6. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Linguistic Resource or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Linguistic Resource (or any work based on the Linguistic Resource), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Linguistic Resource or works based on it.\n\n   7. Each time you redistribute the Linguistic Resource (or any work based on the Linguistic Resource), the recipient automatically receives a license from the original licensor to copy, distribute, link with or modify the Linguistic Resource subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties with this License.\n\n   8. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Linguistic Resource at all. For example, if a patent license would not permit royalty-free redistribution of the Linguistic Resource by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Linguistic Resource.\n\n   If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply, and the section as a whole is intended to apply in other circumstances.\n\n   It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free resource distribution system which is implemented by public license practices. Many people have made generous contributions to the wide range of data distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute resources through any other system and a licensee cannot impose that choice.\n\n   This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License.\n\n   9. If the distribution and/or use of the Linguistic Resource is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Linguistic Resource under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License.\n\n   10. The Free Software Foundation may publish revised and/or new versions of the Lesser General Public License for Linguistic Resources from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.\n\n   Each version is given a distinguishing version number. If the Linguistic Resource specifies a version number of this License which applies to it and \"any later version\", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Linguistic Resource does not specify a license version number, you may choose any version ever published by the Free Software Foundation.\n\n   11. If you wish to incorporate parts of the Linguistic Resource into other free programs whose distribution conditions are incompatible with these, write to the author to ask for permission.\n\n   NO WARRANTY\n\n   12. BECAUSE THE LINGUISTIC RESOURCE IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE LINGUISTIC RESOURCE, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE LINGUISTIC RESOURCE \"AS IS\" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE LINGUISTIC RESOURCE IS WITH YOU. SHOULD THE LINGUISTIC RESOURCE PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.\n\n   13. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE LINGUISTIC RESOURCE AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE LINGUISTIC RESOURCE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE LINGUISTIC RESOURCE TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\nEND OF TERMS AND CONDITIONS"],"licenseIds":["LGPLLR"],"keywords":["linguistic resources preamble","resources preamble the","for most data","most data are","data are designed","by contrast this","contrast this license","change free data","free data to","data to make","sure the data","the data are","data are free","are free for","for all their","all their users","their users this","linguistic resources applies","resources applies to","specially designated linguistic","designated linguistic resources","linguistic resources typically","resources typically lexicons","typically lexicons and","lexicons and grammars","and grammars terms","grammars terms and","to any linguistic","any linguistic resource","linguistic resource which","resource which contains","linguistic resources also","resources also called","you a linguistic","resource means a","of data about","data about language","about language prepared","language prepared so","used with application","application programs the","programs the linguistic","linguistic resource below","resource below refers","such work which","resource means either","either the linguistic","containing the linguistic","resource or a","term modification legible","modification legible form","legible form for","for a linguistic","resource means the","of the resource","the resource for","resource for making","to it activities","it activities other","using the linguistic","resource is not","linguistic resource independent","resource independent of","resource in a","resource does 1","resource as you","resource and copy","be a linguistic","resource b you","license these requirements","from the linguistic","resource and can","resource the distribution","resource in addition","resource or with","linguistic resource on","resource on a","license 3 a","3 a program","linguistic resource but","resource but is","resource by reading","by reading it","reading it or","it or being","or being compiled","linguistic resource such","resource such a","resource and therefore","license however combining","however combining a","combining a work","linguistic resource creates","resource creates a","creates a package","package that is","linguistic resource because","resource because it","linguistic resource rather","resource rather than","package is a","the package under","package under the","4 any works","any works containing","works containing that","containing that package","that package also","package also fall","4 4 as","4 as an","also combine a","combine a work","resource to produce","produce a package","a package containing","package containing portions","resource and distribute","distribute that package","that package under","package under terms","the package for","package for the","the package that","package that the","resource is used","resource and its","the package during","package during execution","linguistic resource among","resource among them","machine readable legible","readable legible form","legible form of","resource including whatever","in the package","the package which","package which must","the package contains","package contains an","contains an encrypted","resource as object","resource and then","and then encrypt","then encrypt it","encrypt it to","it to produce","a modified package","modified package containing","package containing the","the modified linguistic","modified linguistic resource","resource b use","suitable mechanism for","mechanism for combining","for combining with","combining with the","linguistic resource a","resource a suitable","one that will","that will operate","the package was","package was made","in subsection 4a","subsection 4a above","4a above for","package is made","a copy if","copy if the","includes an encrypted","resource the required","linguistic resource must","resource must include","reproducing the package","the package from","package from it","restrictions of proprietary","of proprietary libraries","and the linguistic","linguistic resource together","resource together in","together in a","in a package","package that you","you distribute 5","distribute 5 you","linguistic resource except","resource except as","resource is void","full compliance 6","compliance 6 you","6 you are","resource or its","distributing the linguistic","resource you indicate","modifying the linguistic","resource or works","on it 7","it 7 each","7 each time"]},{"licenseTexts":["Lucent Public License Version 1.0\n\nTHE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS PUBLIC LICENSE (\"AGREEMENT\"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.\n\n   1. DEFINITIONS\n\n   \"Contribution\" means:\n\n      a. in the case of \u003cORGANIZATION\u003e (\" \u003cOWNER\u003e \"), the Original Program, and\n\n      b. in the case of each Contributor,\n\n         i. changes to the Program, and\n\n         ii. additions to the Program; where such changes and/or additions to the Program originate from and are \"Contributed\" by that particular Contributor.\n\n         A Contribution is \"Contributed\" by a Contributor only (i) if it was added to the Program by such Contributor itself or anyone acting on such Contributor's behalf, and (ii) the Contributor explicitly consents, in accordance with Section 3C, to characterization of the changes and/or additions as Contributions. Contributions do not include additions to the Program which: (i) are separate modules of software distributed in conjunction with the Program under their own license agreement, and (ii) are not derivative works of the Program.\n\n         \"Contributor\" means \u003cOWNER\u003e and any other entity that has Contributed a Contribution to the Program.\n\n         \"Distributor\" means a Recipient that distributes the Program, modifications to the Program, or any part thereof.\n\n         \"Licensed Patents\" mean patent claims licensable by a Contributor which are necessarily infringed by the use or sale of its Contribution alone or when combined with the Program.\n\n         \"Original Program\" means the original version of the software accompanying this Agreement as released by \u003cOWNER\u003e , including source code, object code and documentation, if any.\n\n         \"Program\" means the Original Program and Contributions or any part thereof\n\n         \"Recipient\" means anyone who receives the Program under this Agreement, including all Contributors.\n\n   2. GRANT OF RIGHTS\n\n      a. Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide, royalty-free copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, distribute and sublicense the Contribution of such Contributor, if any, and such derivative works, in source code and object code form.\n\n      b. Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide, royalty-free patent license under Licensed Patents to make, use, sell, offer to sell, import and otherwise transfer the Contribution of such Contributor, if any, in source code and object code form. The patent license granted by a Contributor shall also apply to the combination of the Contribution of that Contributor and the Program if, at the time the Contribution is added by the Contributor, such addition of the Contribution causes such combination to be covered by the Licensed Patents. The patent license granted by a Contributor shall not apply to (i) any other combinations which include the Contribution, nor to (ii) Contributions of other Contributors. No hardware per se is licensed hereunder.\n\n      c. Recipient understands that although each Contributor grants the licenses to its Contributions set forth herein, no assurances are provided by any Contributor that the Program does not infringe the patent or other intellectual property rights of any other entity. Each Contributor disclaims any liability to Recipient for claims brought by any other entity based on infringement of intellectual property rights or otherwise. As a condition to exercising the rights and licenses granted hereunder, each Recipient hereby assumes sole responsibility to secure any other intellectual property rights needed, if any. For example, if a third party patent license is required to allow Recipient to distribute the Program, it is Recipient's responsibility to acquire that license before distributing the Program.\n\n      d. Each Contributor represents that to its knowledge it has sufficient copyright rights in its Contribution, if any, to grant the copyright license set forth in this Agreement.\n\n   3. REQUIREMENTS\n\n      A. Distributor may choose to distribute the Program in any form under this Agreement or under its own license agreement, provided that:\n\n         1. it complies with the terms and conditions of this Agreement;\n\n         2. if the Program is distributed in source code or other tangible form, a copy of this Agreement or Distributor's own license agreement is included with each copy of the Program; and\n\n         3. if distributed under Distributor's own license agreement, such license agreement:\n\n            a. effectively disclaims on behalf of all Contributors all warranties and conditions, express and implied, including warranties or conditions of title and non-infringement, and implied warranties or conditions of merchantability and fitness for a particular purpose;\n\n            b. effectively excludes on behalf of all Contributors all liability for damages, including direct, indirect, special, incidental and consequential damages, such as lost profits; and\n\n            c. states that any provisions which differ from this Agreement are offered by that Contributor alone and not by any other party.\n\n      B. Each Distributor must include the following in a conspicuous location in the Program:\n\n      Copyright (C) \u003cYEAR\u003e, \u003cORGANIZATION\u003e and others. All Rights Reserved.\n\n      C. In addition, each Contributor must identify itself as the originator of its Contribution, if any, and indicate its consent to characterization of its additions and/or changes as a Contribution, in a manner that reasonably allows subsequent Recipients to identify the originator of the Contribution. Once consent is granted, it may not thereafter be revoked.\n\n   4. COMMERCIAL DISTRIBUTION\n\n   Commercial distributors of software may accept certain responsibilities with respect to end users, business partners and the like. While this license is intended to facilitate the commercial use of the Program, the Distributor who includes the Program in a commercial product offering should do so in a manner which does not create potential liability for Contributors. Therefore, if a Distributor includes the Program in a commercial product offering, such Distributor (\"Commercial Distributor\") hereby agrees to defend and indemnify every Contributor (\"Indemnified Contributor\") against any losses, damages and costs (collectively \"Losses\") arising from claims, lawsuits and other legal actions brought by a third party against the Indemnified Contributor to the extent caused by the acts or omissions of such Commercial Distributor in connection with its distribution of the Program in a commercial product offering. The obligations in this section do not apply to any claims or Losses relating to any actual or alleged intellectual property infringement. In order to qualify, an Indemnified Contributor must: a) promptly notify the Commercial Distributor in writing of such claim, and b) allow the Commercial Distributor to control, and cooperate with the Commercial Distributor in, the defense and any related settlement negotiations. The Indemnified Contributor may participate in any such claim at its own expense.\n\n   For example, a Distributor might include the Program in a commercial product offering, Product X. That Distributor is then a Commercial Distributor. If that Commercial Distributor then makes performance claims, or offers warranties related to Product X, those performance claims and warranties are such Commercial Distributor's responsibility alone. Under this section, the Commercial Distributor would have to defend claims against the Contributors related to those performance claims and warranties, and if a court requires any Contributor to pay any damages as a result, the Commercial Distributor must pay those damages.\n\n   5. NO WARRANTY\n\n   EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED ON AN \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely responsible for determining the appropriateness of using and distributing the Program and assumes all risks associated with its exercise of rights under this Agreement, including but not limited to the risks and costs of program errors, compliance with applicable laws, damage to or loss of data, programs or equipment, and unavailability or interruption of operations.\n\n   6. DISCLAIMER OF LIABILITY\n\n   EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\n   7. GENERAL\n\n   If any provision of this Agreement is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this Agreement, and without further action by the parties hereto, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.\n\n   If Recipient institutes patent litigation against a Contributor with respect to a patent applicable to software (including a cross-claim or counterclaim in a lawsuit), then any patent licenses granted by that Contributor to such Recipient under this Agreement shall terminate as of the date such litigation is filed. In addition, if Recipient institutes patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Program itself (excluding combinations of the Program with other software or hardware) infringes such Recipient's patent(s), then such Recipient's rights granted under Section 2(b) shall terminate as of the date such litigation is filed.\n\n   All Recipient's rights under this Agreement shall terminate if it fails to comply with any of the material terms or conditions of this Agreement and does not cure such failure in a reasonable period of time after becoming aware of such noncompliance. If all Recipient's rights under this Agreement terminate, Recipient agrees to cease use and distribution of the Program as soon as reasonably practicable. However, Recipient's obligations under this Agreement and any licenses granted by Recipient relating to the Program shall continue and survive.\n\n   \u003cOWNER\u003e may publish new versions (including revisions) of this Agreement from time to time. Each new version of the Agreement will be given a distinguishing version number. The Program (including Contributions) may always be distributed subject to the version of the Agreement under which it was received. In addition, after a new version of the Agreement is published, Contributor may elect to distribute the Program (including its Contributions) under the new version. No one other than \u003cOWNER\u003e has the right to modify this Agreement. Except as expressly stated in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to the intellectual property of any Contributor under this Agreement, whether expressly, by implication, estoppel or otherwise. All rights in the Program not expressly granted under this Agreement are reserved.\n\n   This Agreement is governed by the laws of the State of \u003cSTATE\u003e and the intellectual property laws of the United States of America. No party to this Agreement will bring a legal action under this Agreement more than one year after the cause of action arose. Each party waives its rights to a jury trial in any resulting litigation."],"licenseIds":["LPL-1.0"],"keywords":["case of organization","of organization owner","organization owner the","owner the original","and are contributed","are contributed by","contributed by that","contributed by a","a contributor only","contributor only i","only i if","i if it","behalf and ii","ii the contributor","as contributions contributions","contributions contributions do","contributor means owner","means owner and","owner and any","released by owner","by owner including","owner including source","c year organization","year organization and","organization and others","any and indicate","and indicate its","indicate its consent","its consent to","consent to characterization","characterization of its","of its additions","its additions and","or changes as","changes as a","a contribution in","the contribution once","contribution once consent","and survive owner","survive owner may","owner may publish","other than owner","than owner has","owner has the","state of state","of state and","state and the","the case of organization","case of organization owner","of organization owner the","organization owner the original","owner the original program","from and are contributed","and are contributed by","are contributed by that","contributed by that particular","contributor a contribution is","contribution is contributed by","is contributed by a","contributed by a contributor","by a contributor only","a contributor only i","contributor only i if","only i if it","i if it was","s behalf and ii","behalf and ii the","and ii the contributor","ii the contributor explicitly","additions as contributions contributions","as contributions contributions do","contributions contributions do not","program contributor means owner","contributor means owner and","means owner and any","owner and any other","as released by owner","released by owner including","by owner including source","owner including source code","copyright c year organization","c year organization and","year organization and others","organization and others all","contribution if any and","if any and indicate","any and indicate its","and indicate its consent","indicate its consent to","its consent to characterization","consent to characterization of","to characterization of its","characterization of its additions","of its additions and","its additions and or","and or changes as","or changes as a","changes as a contribution","as a contribution in","a contribution in a","of the contribution once","the contribution once consent","contribution once consent is","continue and survive owner","and survive owner may","survive owner may publish","owner may publish new","one other than owner","other than owner has","than owner has the","owner has the right","the state of state","state of state and","of state and the","state and the intellectual","in the case of organization","the case of organization owner","case of organization owner the","of organization owner the original","organization owner the original program","owner the original program and","originate from and are contributed","from and are contributed by","and are contributed by that","are contributed by that particular","contributed by that particular contributor","particular contributor a contribution is","contributor a contribution is contributed","a contribution is contributed by","contribution is contributed by a","is contributed by a contributor","contributed by a contributor only","by a contributor only i","a contributor only i if","contributor only i if it","only i if it was","i if it was added","contributor s behalf and ii","s behalf and ii the","behalf and ii the contributor","and ii the contributor explicitly","ii the contributor explicitly consents","or additions as contributions contributions","additions as contributions contributions do","as contributions contributions do not","contributions contributions do not include","the program contributor means owner","program contributor means owner and","contributor means owner and any","means owner and any other","owner and any other entity","agreement as released by owner","as released by owner including","released by owner including source","by owner including source code","owner including source code object","the program copyright c year","program copyright c year organization","copyright c year organization and","c year organization and others","year organization and others all","organization and others all rights","its contribution if any and","contribution if any and indicate","if any and indicate its","any and indicate its consent","and indicate its consent to","indicate its consent to characterization","its consent to characterization of","consent to characterization of its","to characterization of its additions","characterization of its additions and","of its additions and or","its additions and or changes","additions and or changes as","and or changes as a","or changes as a contribution","changes as a contribution in","as a contribution in a","a contribution in a manner","originator of the contribution once","of the contribution once consent","the contribution once consent is","contribution once consent is granted","shall continue and survive owner","continue and survive owner may","and survive owner may publish","survive owner may publish new","owner may publish new versions","no one other than owner","one other than owner has","other than owner has the","than owner has the right","owner has the right to","of the state of state","the state of state and","state of state and the","of state and the intellectual","state and the intellectual property"]},{"licenseTexts":["Lucent Public License Version 1.02\n\nTHE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS PUBLIC LICENSE (\"AGREEMENT\"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.\n\n   1. DEFINITIONS\n\n   \"Contribution\" means:\n\n      a. in the case of Lucent Technologies Inc. (\"LUCENT\"), the Original Program, and\n\n      b. in the case of each Contributor,\n\n         i. changes to the Program, and\n\n         ii. additions to the Program;\n\n         where such changes and/or additions to the Program were added to the Program by such Contributor itself or anyone acting on such Contributor's behalf, and the Contributor explicitly consents, in accordance with Section 3C, to characterization of the changes and/or additions as Contributions.\n\n      \"Contributor\" means LUCENT and any other entity that has Contributed a Contribution to the Program.\n\n      \"Distributor\" means a Recipient that distributes the Program, modifications to the Program, or any part thereof.\n\n      \"Licensed Patents\" mean patent claims licensable by a Contributor which are necessarily infringed by the use or sale of its Contribution alone or when combined with the Program.\n\n      \"Original Program\" means the original version of the software accompanying this Agreement as released by LUCENT, including source code, object code and documentation, if any.\n\n      \"Program\" means the Original Program and Contributions or any part thereof\n\n      \"Recipient\" means anyone who receives the Program under this Agreement, including all Contributors.\n\n   2. GRANT OF RIGHTS\n\n      a. Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide, royalty-free copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, distribute and sublicense the Contribution of such Contributor, if any, and such derivative works, in source code and object code form.\n\n      b. Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide, royalty-free patent license under Licensed Patents to make, use, sell, offer to sell, import and otherwise transfer the Contribution of such Contributor, if any, in source code and object code form. The patent license granted by a Contributor shall also apply to the combination of the Contribution of that Contributor and the Program if, at the time the Contribution is added by the Contributor, such addition of the Contribution causes such combination to be covered by the Licensed Patents. The patent license granted by a Contributor shall not apply to (i) any other combinations which include the Contribution, nor to (ii) Contributions of other Contributors. No hardware per se is licensed hereunder.\n\n      c. Recipient understands that although each Contributor grants the licenses to its Contributions set forth herein, no assurances are provided by any Contributor that the Program does not infringe the patent or other intellectual property rights of any other entity. Each Contributor disclaims any liability to Recipient for claims brought by any other entity based on infringement of intellectual property rights or otherwise. As a condition to exercising the rights and licenses granted hereunder, each Recipient hereby assumes sole responsibility to secure any other intellectual property rights needed, if any. For example, if a third party patent license is required to allow Recipient to distribute the Program, it is Recipient's responsibility to acquire that license before distributing the Program.\n\n      d. Each Contributor represents that to its knowledge it has sufficient copyright rights in its Contribution, if any, to grant the copyright license set forth in this Agreement.\n\n   3. REQUIREMENTS\n\n      A. Distributor may choose to distribute the Program in any form under this Agreement or under its own license agreement, provided that:\n\n         1. it complies with the terms and conditions of this Agreement;\n\n         2. if the Program is distributed in source code or other tangible form, a copy of this Agreement or Distributor's own license agreement is included with each copy of the Program; and\n\n         3. if distributed under Distributor's own license agreement, such license agreement:\n\n            a. effectively disclaims on behalf of all Contributors all warranties and conditions, express and implied, including warranties or conditions of title and non-infringement, and implied warranties or conditions of merchantability and fitness for a particular purpose;\n\n            b. effectively excludes on behalf of all Contributors all liability for damages, including direct, indirect, special, incidental and consequential damages, such as lost profits; and\n\n            c. states that any provisions which differ from this Agreement are offered by that Contributor alone and not by any other party.\n\n      B. Each Distributor must include the following in a conspicuous location in the Program:\n\n      Copyright (C) 2003, Lucent Technologies Inc. and others. All Rights Reserved.\n\n      C. In addition, each Contributor must identify itself as the originator of its Contribution in a manner that reasonably allows subsequent Recipients to identify the originator of the Contribution. Also, each Contributor must agree that the additions and/or changes are intended to be a Contribution. Once a Contribution is contributed, it may not thereafter be revoked.\n\n   4. COMMERCIAL DISTRIBUTION\n\n   Commercial distributors of software may accept certain responsibilities with respect to end users, business partners and the like. While this license is intended to facilitate the commercial use of the Program, the Distributor who includes the Program in a commercial product offering should do so in a manner which does not create potential liability for Contributors. Therefore, if a Distributor includes the Program in a commercial product offering, such Distributor (\"Commercial Distributor\") hereby agrees to defend and indemnify every Contributor (\"Indemnified Contributor\") against any losses, damages and costs (collectively \"Losses\") arising from claims, lawsuits and other legal actions brought by a third party against the Indemnified Contributor to the extent caused by the acts or omissions of such Commercial Distributor in connection with its distribution of the Program in a commercial product offering. The obligations in this section do not apply to any claims or Losses relating to any actual or alleged intellectual property infringement. In order to qualify, an Indemnified Contributor must: a) promptly notify the Commercial Distributor in writing of such claim, and b) allow the Commercial Distributor to control, and cooperate with the Commercial Distributor in, the defense and any related settlement negotiations. The Indemnified Contributor may participate in any such claim at its own expense.\n\n   For example, a Distributor might include the Program in a commercial product offering, Product X. That Distributor is then a Commercial Distributor. If that Commercial Distributor then makes performance claims, or offers warranties related to Product X, those performance claims and warranties are such Commercial Distributor's responsibility alone. Under this section, the Commercial Distributor would have to defend claims against the Contributors related to those performance claims and warranties, and if a court requires any Contributor to pay any damages as a result, the Commercial Distributor must pay those damages.\n\n   5. NO WARRANTY\n\n   EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED ON AN \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely responsible for determining the appropriateness of using and distributing the Program and assumes all risks associated with its exercise of rights under this Agreement, including but not limited to the risks and costs of program errors, compliance with applicable laws, damage to or loss of data, programs or equipment, and unavailability or interruption of operations.\n\n   6. DISCLAIMER OF LIABILITY\n\n   EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\n   7. EXPORT CONTROL\n\n   Recipient agrees that Recipient alone is responsible for compliance with the United States export administration regulations (and the export control laws and regulation of any other countries).\n\n   8. GENERAL\n\n   If any provision of this Agreement is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this Agreement, and without further action by the parties hereto, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.\n\n   If Recipient institutes patent litigation against a Contributor with respect to a patent applicable to software (including a cross-claim or counterclaim in a lawsuit), then any patent licenses granted by that Contributor to such Recipient under this Agreement shall terminate as of the date such litigation is filed. In addition, if Recipient institutes patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Program itself (excluding combinations of the Program with other software or hardware) infringes such Recipient's patent(s), then such Recipient's rights granted under Section 2(b) shall terminate as of the date such litigation is filed.\n\n   All Recipient's rights under this Agreement shall terminate if it fails to comply with any of the material terms or conditions of this Agreement and does not cure such failure in a reasonable period of time after becoming aware of such noncompliance. If all Recipient's rights under this Agreement terminate, Recipient agrees to cease use and distribution of the Program as soon as reasonably practicable. However, Recipient's obligations under this Agreement and any licenses granted by Recipient relating to the Program shall continue and survive.\n\n   LUCENT may publish new versions (including revisions) of this Agreement from time to time. Each new version of the Agreement will be given a distinguishing version number. The Program (including Contributions) may always be distributed subject to the version of the Agreement under which it was received. In addition, after a new version of the Agreement is published, Contributor may elect to distribute the Program (including its Contributions) under the new version. No one other than LUCENT has the right to modify this Agreement. Except as expressly stated in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to the intellectual property of any Contributor under this Agreement, whether expressly, by implication, estoppel or otherwise. All rights in the Program not expressly granted under this Agreement are reserved.\n\n   This Agreement is governed by the laws of the State of New York and the intellectual property laws of the United States of America. No party to this Agreement will bring a legal action under this Agreement more than one year after the cause of action arose. Each party waives its rights to a jury trial in any resulting litigation."],"licenseIds":["LPL-1.02"],"keywords":["version 1 02","1 02 the","02 the accompanying","case of lucent","technologies inc lucent","inc lucent the","lucent the original","the program were","program were added","behalf and the","as contributions contributor","contributions contributor means","contributor means lucent","means lucent and","lucent and any","released by lucent","by lucent including","lucent including source","c 2003 lucent","2003 lucent technologies","technologies inc and","inc and others","the contribution also","contribution also each","also each contributor","contributor must agree","must agree that","that the additions","the additions and","or changes are","changes are intended","be a contribution","a contribution once","contribution once a","once a contribution","is contributed it","contributed it may","damages 7 export","7 export control","export control recipient","control recipient agrees","recipient agrees that","agrees that recipient","recipient alone is","alone is responsible","other countries 8","countries 8 general","8 general if","and survive lucent","survive lucent may","lucent may publish","other than lucent","than lucent has","lucent has the","license version 1 02","version 1 02 the","1 02 the accompanying","02 the accompanying program","the case of lucent","case of lucent technologies","of lucent technologies inc","lucent technologies inc lucent","technologies inc lucent the","inc lucent the original","lucent the original program","to the program were","the program were added","program were added to","were added to the","s behalf and the","behalf and the contributor","and the contributor explicitly","additions as contributions contributor","as contributions contributor means","contributions contributor means lucent","contributor means lucent and","means lucent and any","lucent and any other","as released by lucent","released by lucent including","by lucent including source","lucent including source code","program copyright c 2003","copyright c 2003 lucent","c 2003 lucent technologies","2003 lucent technologies inc","lucent technologies inc and","technologies inc and others","inc and others all","its contribution in a","of the contribution also","the contribution also each","contribution also each contributor","also each contributor must","each contributor must agree","contributor must agree that","must agree that the","agree that the additions","that the additions and","the additions and or","and or changes are","or changes are intended","changes are intended to","are intended to be","intended to be a","to be a contribution","be a contribution once","a contribution once a","contribution once a contribution","once a contribution is","contribution is contributed it","is contributed it may","contributed it may not","such damages 7 export","damages 7 export control","7 export control recipient","export control recipient agrees","control recipient agrees that","recipient agrees that recipient","agrees that recipient alone","that recipient alone is","recipient alone is responsible","alone is responsible for","is responsible for compliance","any other countries 8","other countries 8 general","countries 8 general if","8 general if any","continue and survive lucent","and survive lucent may","survive lucent may publish","lucent may publish new","one other than lucent","other than lucent has","than lucent has the","lucent has the right","public license version 1 02","license version 1 02 the","version 1 02 the accompanying","1 02 the accompanying program","02 the accompanying program is","in the case of lucent","the case of lucent technologies","case of lucent technologies inc","of lucent technologies inc lucent","lucent technologies inc lucent the","technologies inc lucent the original","inc lucent the original program","lucent the original program and","additions to the program were","to the program were added","the program were added to","program were added to the","were added to the program","contributor s behalf and the","s behalf and the contributor","behalf and the contributor explicitly","and the contributor explicitly consents","or additions as contributions contributor","additions as contributions contributor means","as contributions contributor means lucent","contributions contributor means lucent and","contributor means lucent and any","means lucent and any other","lucent and any other entity","agreement as released by lucent","as released by lucent including","released by lucent including source","by lucent including source code","lucent including source code object","the program copyright c 2003","program copyright c 2003 lucent","copyright c 2003 lucent technologies","c 2003 lucent technologies inc","2003 lucent technologies inc and","lucent technologies inc and others","technologies inc and others all","inc and others all rights","originator of its contribution in","of its contribution in a","its contribution in a manner","originator of the contribution also","of the contribution also each","the contribution also each contributor","contribution also each contributor must","also each contributor must agree","each contributor must agree that","contributor must agree that the","must agree that the additions","agree that the additions and","that the additions and or","the additions and or changes","additions and or changes are","and or changes are intended","or changes are intended to","changes are intended to be","are intended to be a","intended to be a contribution","to be a contribution once","be a contribution once a"]},{"licenseTexts":["LaTeX Project Public License\n\nLPPL Version 1.0 1999-03-01 Copyright 1999 LaTeX3 Project\n\nEveryone is permitted to copy and distribute verbatim copies of this license document, but modification is not allowed.\n\nPreamble\n\nThe LaTeX Project Public License (LPPL) is the license under which the base LaTeX distribution is distributed. As described below you may use this licence for any software that you wish to distribute.\n\nIt may be particularly suitable if your software is TeX related (such as a LaTeX package file) but it may be used for any software, even if it is unrelated to TeX.\n\nTo use this license, the files of your distribution should have an explicit copyright notice giving your name and the year, together with a reference to this license.\n\nA typical example would be\n\n%% pig.sty\n\n%% Copyright 2001 M. Y. Name\n\n% This program can redistributed and/or modified under the terms\n\n% of the LaTeX Project Public License Distributed from CTAN\n\n% archives in directory macros/latex/base/lppl.txt; either\n\n% version 1 of the License, or (at your option) any later version.\n\nGiven such a notice in the file, the conditions of this document would apply, with:\n\n`The Program' referring to the software `pig.sty' and `The Copyright Holder' referring to the person `M. Y. Name'.\n\nTo see a real example, see the file legal.txt which carries the copyright notice for the base latex distribution.\n\nThis license gives terms under which files of The Program may be distributed and modified. Individual files may have specific further constraints on modification, but no file should have restrictions on distribution other than those specified below.\n\nThis is to ensure that a distributor wishing to distribute a complete unmodified copy of The Program need only check the conditions in this file, and does not need to check every file in The Program for extra restrictions. If you do need to modify the distribution terms of some files, do not refer to this license, instead distribute The Program under a different license. You may use the parts of the text of LPPL as a model for your own license, but your license should not directly refer to the LPPL or otherwise give the impression that The Program is distributed under the LPPL.\n\nThe LaTeX Project Public License\n\n================================\n\nTerms And Conditions For Copying, Distribution And Modification\n\n===============================================================\n\nWARRANTY\n\n========\n\nThere is no warranty for The Program, to the extent permitted by applicable law. Except when otherwise stated in writing, The Copyright Holder provides The Program `as is' without warranty of any kind, either expressed or implied, including, but not limited to, the implied warranties of merchantability and fitness for a particular purpose. The entire risk as to the quality and performance of the program is with you. Should The Program prove defective, you assume the cost of all necessary servicing, repair or correction.\n\nIn no event unless required by applicable law or agreed to in writing will The Copyright Holder, or any of the individual authors named in the source for The Program, be liable to you for damages, including any general, special, incidental or consequential damages arising out of any use of The Program or out of inability to use The Program (including but not limited to loss of data or data being rendered inaccurate or losses sustained by you or by third parties as a result of a failure of The Program to operate with any other programs), even if such holder or other party has been advised of the possibility of such damages.\n\nDISTRIBUTION\n\n============\n\nRedistribution of unchanged files is allowed provided that all files that make up the distribution of The Program are distributed. In particular this means that The Program has to be distributed including its documentation if documentation was part of the original distribution.\n\nThe distribution of The Program will contain a prominent file listing all the files covered by this license.\n\nIf you receive only some of these files from someone, complain!\n\nThe distribution of changed versions of certain files included in the The Program, and the reuse of code from The Program, are allowed under the following restrictions:\n\n   * It is allowed only if the legal notice in the file does not expressly forbid it. See note below, under \"Conditions on individual files\".\n\n   * You rename the file before you make any changes to it, unless the file explicitly says that renaming is not required. Any such changed files must be distributed under a license that forbids distribution of those files, and any files derived from them, under the names used by the original files in the distribution of The Program.\n\n   * You change any `identification string' in The Program to clearly indicate that the file is not part of the standard system.\n\n   * If The Program includes an `error report address' so that errors may be reported to The Copyright Holder, or other specified addresses, this address must be changed in any modified versions of The Program, so that reports for files not maintained by the original program maintainers are directed to the maintainers of the changed files.\n\n   * You acknowledge the source and authorship of the original version in the modified file.\n\n   * You also distribute the unmodified version of the file or alternatively provide sufficient information so that the user of your modified file can be reasonably expected to be able to obtain an original, unmodified copy of The Program. For example, you may specify a URL to a site that you expect will freely provide the user with a copy of The Program (either the version on which your modification is based, or perhaps a later version).\n\n   * If The Program is intended to be used with, or is based on, LaTeX, then files with the following file extensions which have special meaning in LaTeX Software, have special modification rules under the license:\n\n      - Files with extension `.ins' (installation files): these files may not be modified at all because they contain the legal notices that are placed in the generated files.\n\n      - Files with extension `.fd' (LaTeX font definitions files): these files are allowed to be modified without changing the name, but only to enable use of all available fonts and to prevent attempts to access unavailable fonts. However, modified files are not allowed to be distributed in place of original files.\n\n      - Files with extension `.cfg' (configuration files): these files can be created or modified to enable easy configuration of the system. The documentation in cfgguide.tex in the base LaTeX distribution describes when it makes sense to modify or generate such files.\n\nThe above restrictions are not intended to prohibit, and hence do not apply to, the updating, by any method, of a file so that it becomes identical to the latest version of that file in The Program.\n\n========================================================================\n\nNOTES\n\n=====\n\nWe believe that these requirements give you the freedom you to make modifications that conform with whatever technical specifications you wish, whilst maintaining the availability, integrity and reliability of The Program. If you do not see how to achieve your goal whilst adhering to these requirements then read the document cfgguide.tex in the base LaTeX distribution for suggestions.\n\nBecause of the portability and exchangeability aspects of systems like LaTeX, The LaTeX3 Project deprecates the distribution of non-standard versions of components of LaTeX or of generally available contributed code for them but such distributions are permitted under the above restrictions.\n\nThe document modguide.tex in the base LaTeX distribution details the reasons for the legal requirements detailed above. Even if The Program is unrelated to LaTeX, the argument in modguide.tex may still apply, and should be read before a modified version of The Program is distributed.\n\nConditions on individual files\n\n==============================\n\nThe individual files may bear additional conditions which supersede the general conditions on distribution and modification contained in this file. If there are any such files, the distribution of The Program will contain a prominent file that lists all the exceptional files.\n\nTypical examples of files with more restrictive modification conditions would be files that contain the text of copyright notices.\n\n   * The conditions on individual files differ only in the extent of *modification* that is allowed.\n\n   * The conditions on *distribution* are the same for all the files. Thus a (re)distributor of a complete, unchanged copy of The Program need meet only the conditions in this file; it is not necessary to check the header of every file in the distribution to check that a distribution meets these requirements."],"licenseIds":["LPPL-1.0"],"keywords":["1 0 1999","0 1999 03","1999 03 01","03 01 copyright","but modification is","distributed as described","described below you","this licence for","that you wish","to distribute it","distribute it may","software is tex","latex package file","package file but","file but it","any software even","it is unrelated","to tex to","tex to use","license the files","your distribution should","distribution should have","should have an","have an explicit","copyright notice giving","notice giving your","giving your name","the year together","year together with","with a reference","license a typical","a typical example","typical example would","example would be","would be pig","be pig sty","pig sty copyright","sty copyright 2001","this program can","program can redistributed","can redistributed and","public license distributed","license distributed from","distributed from ctan","from ctan archives","ctan archives in","archives in directory","in directory macros","directory macros latex","macros latex base","latex base lppl","base lppl txt","lppl txt either","txt either version","version 1 of","later version given","version given such","this document would","the software pig","software pig sty","pig sty and","sty and the","y name to","name to see","to see a","see a real","a real example","real example see","example see the","file legal txt","legal txt which","txt which carries","which carries the","carries the copyright","for the base","latex distribution this","distribution this license","license gives terms","gives terms under","under which files","which files of","and modified individual","modified individual files","files may have","may have specific","have specific further","specific further constraints","further constraints on","constraints on modification","on modification but","modification but no","no file should","should have restrictions","have restrictions on","restrictions on distribution","on distribution other","distribution other than","than those specified","those specified below","specified below this","below this is","ensure that a","that a distributor","program need only","need only check","only check the","file and does","does not need","need to check","to check every","check every file","program for extra","for extra restrictions","extra restrictions if","restrictions if you","you do need","do need to","need to modify","modify the distribution","the distribution terms","terms of some","of some files","some files do","this license instead","license instead distribute","instead distribute the","use the parts","text of lppl","of lppl as","lppl as a","should not directly","not directly refer","directly refer to","impression that the","lppl the latex","and modification warranty","modification warranty there","of the individual","the individual authors","individual authors named","authors named in","program be liable","or by third","of a failure","such damages distribution","damages distribution redistribution","distribution redistribution of","redistribution of unchanged","of unchanged files","unchanged files is","files is allowed","is allowed provided","allowed provided that","that all files","files that make","make up the","up the distribution","program are distributed","are distributed in","particular this means","program has to","has to be","be distributed including","distributed including its","including its documentation","its documentation if","if documentation was","documentation was part","was part of","original distribution the","distribution the distribution","prominent file listing","file listing all","the files covered","files covered by","if you receive","you receive only","receive only some","only some of","these files from","files from someone","from someone complain","someone complain the","complain the distribution","distribution of changed","of changed versions","changed versions of","versions of certain","of certain files","certain files included","the the program","and the reuse","the reuse of","reuse of code","of code from","program are allowed","are allowed under","following restrictions it","restrictions it is","allowed only if"]},{"licenseTexts":["The LaTeX Project Public License\n\n=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-\n\nLPPL Version 1.1 1999-07-10 Copyright 1999 LaTeX3 Project\n\nEveryone is allowed to distribute verbatim copies of this license document, but modification of it is not allowed.\n\nPREAMBLE\n\n========\n\nThe LaTeX Project Public License (LPPL) is the license under which the base LaTeX distribution is distributed.\n\nYou may use this license for any program that you have written and wish to distribute. This license may be particularly suitable if your program is TeX-related (such as a LaTeX package), but you may use it even if your program is unrelated to TeX. The section `WHETHER AND HOW TO DISTRIBUTE PROGRAMS UNDER THIS LICENSE', below, gives instructions, examples, and recommendations for authors who are considering distributing their programs under this license.\n\nIn this license document, `The Program' refers to any program distributed under this license.\n\nThis license gives conditions under which The Program may be distributed and conditions under which modified versions of The Program may be distributed. Individual files of The Program may bear supplementary and/or superseding conditions on modification of themselves and on the distribution of modified versions of themselves, but *no* file of The Program may bear supplementary or superseding conditions on the distribution of an unmodified copy of the file. A distributor wishing to distribute a complete, unmodified copy of The Program therefore needs to check the conditions only in this license and nowhere else.\n\nActivities other than distribution and/or modification of The Program are not covered by this license; they are outside its scope. In particular, the act of running The Program is not restricted.\n\nWe, the LaTeX3 Project, believe that the conditions below give you the freedom to make and distribute modified versions of The Program that conform with whatever technical specifications you wish while maintaining the availability, integrity, and reliability of The Program. If you do not see how to achieve your goal while meeting these conditions, then read the document `cfgguide.tex' in the base LaTeX distribution for suggestions.\n\nCONDITIONS ON DISTRIBUTION AND MODIFICATION\n\n===========================================\n\nYou may distribute a complete, unmodified copy of The Program. Distribution of only part of The Program is not allowed.\n\nYou may not modify in any way a file of The Program that bears a legal notice forbidding modification of that file.\n\nYou may distribute a modified file of The Program if, and only if, the following eight conditions are met:\n\n   1. You must meet any additional conditions borne by the file on the distribution of a modified version of the file as described below in the subsection `Additional Conditions on Individual Files of The Program'.\n\n   2. If the file is a LaTeX software file, then you must meet any applicable additional conditions on the distribution of a modified version of the file that are described below in the subsection `Additional Conditions on LaTeX Software Files'.\n\n   3. You must not distribute the modified file with the filename of the original file.\n\n   4. In the modified file, you must acknowledge the authorship and name of the original file, and the name (if any) of the program which contains it.\n\n   5. You must change any identification string in the file to indicate clearly that the modified file is not part of The Program.\n\n   6. You must change any addresses in the modified file for the reporting of errors in the file or in The Program generally to ensure that reports for files no longer maintained by the original maintainers will be directed to the maintainers of the modified files.\n\n   7. You must distribute the modified file under a license that forbids distribution both of the modified file and of any files derived from the modified file with the filename of the original file.\n\n   8. You must do either (A) or (B):\n\n      (A) distribute a copy of The Program (that is, a complete, unmodified copy of The Program) together with the modified file; if your distribution of the modified file is made by offering access to copy the modified file from a designated place, then offering equivalent access to copy The Program from the same place meets this condition, even though third parties are not compelled to copy The Program along with the modified file;\n\n      (B) provide to those who receive the modified file information that is sufficient for them to obtain a copy of The Program; for example, you may provide a Uniform Resource Locator (URL) for a site that you expect will provide them with a copy of The Program free of charge (either the version from which your modification is derived, or perhaps a later version).\n\nNote that in the above, `distribution' of a file means making the file available to others by any means. This includes, for instance, installing the file on any machine in such a way that the file is accessible by users other than yourself. `Modification' of a file means any procedure that produces a derivative file under any applicable law -- that is, a file containing the original file or a significant portion of it, either verbatim or with modifications and/or translated into another language.\n\nChanging the name of a file is considered to be a modification of the file.\n\nThe distribution conditions in this license do not have to be applied to files that have been modified in accordance with the above conditions. Note, however, that Condition 7. does apply to any such modified file.\n\nThe conditions above are not intended to prohibit, and hence do not apply to, the updating, by any method, of a file so that it becomes identical to the latest version of that file of The Program.\n\nA Recommendation on Modification Without Distribution\n\n-----------------------------------------------------\n\nIt is wise never to modify a file of The Program, even for your own personal use, without also meeting the above eight conditions for distributing the modified file. While you might intend that such modified files will never be distributed, often this will happen by accident -- you may forget that you have modified the file; or it may not occur to you when allowing others to access the modified file that you are thus distributing it and violating the conditions of this license. It is usually in your best interest to keep your copy of The Program identical with the public one. Many programs provide ways to control the behavior of that program without altering its licensed files.\n\nAdditional Conditions on Individual Files of The Program\n\n--------------------------------------------------------\n\nAn individual file of The Program may bear additional conditions that supplement and/or supersede the conditions in this license if, and only if, such additional conditions exclusively concern modification of the file or distribution of a modified version of the file. The conditions on individual files of The Program therefore may differ only with respect to the kind and extent of modification of those files that is allowed, and with respect to the distribution of modified versions of those files.\n\nAdditional Conditions on LaTeX Software Files\n\n---------------------------------------------\n\nIf a file of The Program is intended to be used with LaTeX (that is, if it is a LaTeX software file), then the following additional conditions, which supplement and/or supersede the conditions above, apply to the file according to its filename extension:\n\n   - You may not modify any file with filename extension `.ins' since these are installation files containing the legal notices that are placed in the files they generate.\n\n   - You may distribute modified versions of files with filename extension `.fd' (LaTeX font definition files) under the standard conditions of the LPPL as described above. You may also distribute such modified LaTeX font definition files with their original names provided that:\n\n      (1) the only changes to the original files either enable use of available fonts or prevent attempts to access unavailable fonts;\n\n      (2) you also distribute the original, unmodified files (TeX input paths can be used to control which set of LaTeX font definition files is actually used by TeX).\n\n   - You may distribute modified versions of files with filename extension `.cfg' (configuration files) with their original names. The Program may (and usually will) specify the range of commands that are allowed in a particular configuration file.\n\nBecause of portability and exchangeability issues in LaTeX software, The LaTeX3 Project deprecates the distribution of modified versions of components of LaTeX or of generally available contributed code for them, but such distribution can meet the conditions of this license.\n\nNO WARRANTY\n\n===========\n\nThere is no warranty for The Program. Except when otherwise stated in writing, The Copyright Holder provides The Program `as is', without warranty of any kind, either expressed or implied, including, but not limited to, the implied warranties of merchantability and fitness for a particular purpose. The entire risk as to the quality and performance of The Program is with you. Should The Program prove defective, you assume the cost of all necessary servicing, repair, or correction.\n\nIn no event unless agreed to in writing will The Copyright Holder, or any author named in the files of The Program, or any other party who may distribute and/or modify The Program as permitted below, be liable to you for damages, including any general, special, incidental or consequential damages arising out of any use of The Program or out of inability to use The Program (including, but not limited to, loss of data, data being rendered inaccurate, or losses sustained by anyone as a result of any failure of The Program to operate with any other programs), even if The Copyright Holder or said author or said other party has been advised of the possibility of such damages.\n\nWHETHER AND HOW TO DISTRIBUTE PROGRAMS UNDER THIS LICENSE\n\n=========================================================\n\nThis section contains important instructions, examples, and recommendations for authors who are considering distributing their programs under this license. These authors are addressed as `you' in this section.\n\nChoosing This License or Another License\n\n----------------------------------------\n\nIf for any part of your program you want or need to use *distribution* conditions that differ from those in this license, then do not refer to this license anywhere in your program but instead distribute your program under a different license. You may use the text of this license as a model for your own license, but your license should not refer to the LPPL or otherwise give the impression that your program is distributed under the LPPL.\n\nThe document `modguide.tex' in the base LaTeX distribution explains the motivation behind the conditions of this license. It explains, for example, why distributing LaTeX under the GNU General Public License (GPL) was considered inappropriate. Even if your program is unrelated to LaTeX, the discussion in `modguide.tex' may still be relevant, and authors intending to distribute their programs under any license are encouraged to read it.\n\nHow to Use This License\n\n-----------------------\n\nTo use this license, place in each of the files of your program both an explicit copyright notice including your name and the year and also a statement that the distribution and/or modification of the file is constrained by the conditions in this license.\n\nHere is an example of such a notice and statement:\n\n%% pig.dtx\n\n%% Copyright 2001 M. Y. Name\n\n%\n\n% This program may be distributed and/or modified under the\n\n% conditions of the LaTeX Project Public License, either version 1.1\n\n% of this license or (at your option) any later version.\n\n% The latest version of this license is in\n\n% http://www.latex-project.org/lppl.txt\n\n% and version 1.1 or later is part of all distributions of LaTeX\n\n% version 1999/06/01 or later.\n\n%\n\n% This program consists of the files pig.dtx and pig.ins\n\nGiven such a notice and statement in a file, the conditions given in this license document would apply, with `The Program' referring to the two files `pig.dtx' and `pig.ins', and `The Copyright Holder' referring to the person `M. Y. Name'.\n\nImportant Recommendations\n\n-------------------------\n\nDefining What Constitutes The Program\n\nThe LPPL requires that distributions of The Program contain all the files of The Program. It is therefore important that you provide a way for the licensee to determine which files constitute The Program. This could, for example, be achieved by explicitly listing all the files of The Program near the copyright notice of each file or by using a line like\n\n% This program consists of all files listed in manifest.txt.\n\nin that place. In the absence of an unequivocal list it might be impossible for the licensee to determine what is considered by you to comprise The Program.\n\nNoting Exceptional Files\n\nIf The Program contains any files bearing additional conditions on modification, or on distribution of modified versions, of those files (other than those listed in `Additional Conditions on LaTeX Software Files'), then it is recommended that The Program contain a prominent file that defines the exceptional conditions, and either lists the exceptional files or defines one or more categories of exceptional files.\n\nFiles containing the text of a license (such as this file) are often examples of files bearing more restrictive conditions on modification. LaTeX configuration files (with filename extension `.cfg') are examples of files bearing less restrictive conditions on the distribution of a modified version of the file. The additional conditions on LaTeX software given above are examples of declaring a category of files bearing exceptional additional conditions."],"licenseIds":["LPPL-1.1"],"keywords":["1 1 1999","1 1999 07","1999 07 10","07 10 copyright","10 copyright 1999","file is considered","as permitted below","permitted below be","below be liable","1 or later","version 1999 06","1999 06 01","06 01 or","lppl version 1 1","version 1 1 1999","1 1 1999 07","1 1999 07 10","1999 07 10 copyright","07 10 copyright 1999","10 copyright 1999 latex3","of a file is","a file is considered","file is considered to","program as permitted below","as permitted below be","permitted below be liable","below be liable to","either version 1 1","1 1 of this","and version 1 1","1 1 or later","1 or later is","latex version 1999 06","version 1999 06 01","1999 06 01 or","06 01 or later","license lppl version 1 1","lppl version 1 1 1999","version 1 1 1999 07","1 1 1999 07 10","1 1999 07 10 copyright","1999 07 10 copyright 1999","07 10 copyright 1999 latex3","10 copyright 1999 latex3 project","name of a file is","of a file is considered","a file is considered to","file is considered to be","the program as permitted below","program as permitted below be","as permitted below be liable","permitted below be liable to","below be liable to you","license either version 1 1","either version 1 1 of","version 1 1 of this","1 1 of this license","1 of this license or","txt and version 1 1","and version 1 1 or","version 1 1 or later","1 1 or later is","1 or later is part","of latex version 1999 06","latex version 1999 06 01","version 1999 06 01 or","1999 06 01 or later","06 01 or later this"]},{"licenseTexts":["The LaTeX Project Public License\n\n=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-\n\nLPPL Version 1.2 1999-09-03 Copyright 1999 LaTeX3 Project\n\nEveryone is allowed to distribute verbatim copies of this license document, but modification of it is not allowed.\n\nPREAMBLE\n\n========\n\nThe LaTeX Project Public License (LPPL) is the license under which the base LaTeX distribution is distributed.\n\nYou may use this license for any program that you have written and wish to distribute. This license may be particularly suitable if your program is TeX-related (such as a LaTeX package), but you may use it even if your program is unrelated to TeX. The section `WHETHER AND HOW TO DISTRIBUTE PROGRAMS UNDER THIS LICENSE', below, gives instructions, examples, and recommendations for authors who are considering distributing their programs under this license.\n\nIn this license document, `The Program' refers to any program distributed under this license.\n\nThis license gives conditions under which The Program may be distributed and conditions under which modified versions of The Program may be distributed. Individual files of The Program may bear supplementary and/or superseding conditions on modification of themselves and on the distribution of modified versions of themselves, but *no* file of The Program may bear supplementary or superseding conditions on the distribution of an unmodified copy of the file. A distributor wishing to distribute a complete, unmodified copy of The Program therefore needs to check the conditions only in this license and nowhere else.\n\nActivities other than distribution and/or modification of The Program are not covered by this license; they are outside its scope. In particular, the act of running The Program is not restricted.\n\nWe, the LaTeX3 Project, believe that the conditions below give you the freedom to make and distribute modified versions of The Program that conform with whatever technical specifications you wish while maintaining the availability, integrity, and reliability of The Program. If you do not see how to achieve your goal while meeting these conditions, then read the document `cfgguide.tex' in the base LaTeX distribution for suggestions.\n\nCONDITIONS ON DISTRIBUTION AND MODIFICATION\n\n===========================================\n\nYou may distribute a complete, unmodified copy of The Program. Distribution of only part of The Program is not allowed.\n\nYou may not modify in any way a file of The Program that bears a legal notice forbidding modification of that file.\n\nYou may distribute a modified file of The Program if, and only if, the following eight conditions are met:\n\n   1. You must meet any additional conditions borne by the file on the distribution of a modified version of the file as described below in the subsection `Additional Conditions on Individual Files of The Program'.\n\n   2. If the file is a LaTeX software file, then you must meet any applicable additional conditions on the distribution of a modified version of the file that are described below in the subsection `Additional Conditions on LaTeX Software Files'.\n\n   3. You must not distribute the modified file with the filename of the original file.\n\n   4. In the modified file, you must acknowledge the authorship and name of the original file, and the name (if any) of the program which contains it.\n\n   5. You must change any identification string in the file to indicate clearly that the modified file is not part of The Program.\n\n   6. You must change any addresses in the modified file for the reporting of errors in the file or in The Program generally to ensure that reports for files no longer maintained by the original maintainers will be directed to the maintainers of the modified files.\n\n   7. You must distribute the modified file under a license that forbids distribution both of the modified file and of any files derived from the modified file with the filename of the original file.\n\n   8. You must do either (A) or (B):\n\n      (A) distribute a copy of The Program (that is, a complete, unmodified copy of The Program) together with the modified file; if your distribution of the modified file is made by offering access to copy the modified file from a designated place, then offering equivalent access to copy The Program from the same place meets this condition, even though third parties are not compelled to copy The Program along with the modified file;\n\n      (B) provide to those who receive the modified file information that is sufficient for them to obtain a copy of The Program; for example, you may provide a Uniform Resource Locator (URL) for a site that you expect will provide them with a copy of The Program free of charge (either the version from which your modification is derived, or perhaps a later version).\n\nNote that in the above, `distribution' of a file means making the file available to others by any means. This includes, for instance, installing the file on any machine in such a way that the file is accessible by users other than yourself. `Modification' of a file means any procedure that produces a derivative file under any applicable law -- that is, a file containing the original file or a significant portion of it, either verbatim or with modifications and/or translated into another language.\n\nChanging the name of a file (other than as necessitated by the file conventions of the target file systems) is considered to be a modification of the file.\n\nThe distribution conditions in this license do not have to be applied to files that have been modified in accordance with the above conditions. Note, however, that Condition 7. does apply to any such modified file.\n\nThe conditions above are not intended to prohibit, and hence do not apply to, the updating, by any method, of a file so that it becomes identical to the latest version of that file of The Program.\n\nA Recommendation on Modification Without Distribution -----------------------------------------------------\n\nIt is wise never to modify a file of The Program, even for your own personal use, without also meeting the above eight conditions for distributing the modified file. While you might intend that such modified files will never be distributed, often this will happen by accident -- you may forget that you have modified the file; or it may not occur to you when allowing others to access the modified file that you are thus distributing it and violating the conditions of this license. It is usually in your best interest to keep your copy of The Program identical with the public one. Many programs provide ways to control the behavior of that program without altering its licensed files.\n\nAdditional Conditions on Individual Files of The Program --------------------------------------------------------\n\nAn individual file of The Program may bear additional conditions that supplement and/or supersede the conditions in this license if, and only if, such additional conditions exclusively concern modification of the file or distribution of a modified version of the file. The conditions on individual files of The Program therefore may differ only with respect to the kind and extent of modification of those files that is allowed, and with respect to the distribution of modified versions of those files.\n\nAdditional Conditions on LaTeX Software Files\n\n---------------------------------------------\n\nIf a file of The Program is intended to be used with LaTeX (that is, if it is a LaTeX software file), then the following additional conditions, which supplement and/or supersede the conditions above, apply to the file according to its filename extension:\n\n   - You may not modify any file with filename extension `.ins' since these are installation files containing the legal notices that are placed in the files they generate.\n\n   - You may distribute modified versions of files with filename extension `.fd' (LaTeX font definition files) under the standard conditions of the LPPL as described above. You may also distribute such modified LaTeX font definition files with their original names provided that:\n\n      (1) the only changes to the original files either enable use of available fonts or prevent attempts to access unavailable fonts;\n\n      (2) you also distribute the original, unmodified files (TeX input paths can be used to control which set of LaTeX font definition files is actually used by TeX).\n\n   - You may distribute modified versions of files with filename extension `.cfg' (configuration files) with their original names. The Program may (and usually will) specify the range of commands that are allowed in a particular configuration file.\n\nBecause of portability and exchangeability issues in LaTeX software, The LaTeX3 Project deprecates the distribution of modified versions of components of LaTeX or of generally available contributed code for them, but such distribution can meet the conditions of this license.\n\nNO WARRANTY\n\n===========\n\nThere is no warranty for The Program. Except when otherwise stated in writing, The Copyright Holder provides The Program `as is', without warranty of any kind, either expressed or implied, including, but not limited to, the implied warranties of merchantability and fitness for a particular purpose. The entire risk as to the quality and performance of The Program is with you. Should The Program prove defective, you assume the cost of all necessary servicing, repair, or correction.\n\nIn no event unless agreed to in writing will The Copyright Holder, or any author named in the files of The Program, or any other party who may distribute and/or modify The Program as permitted above, be liable to you for damages, including any general, special, incidental or consequential damages arising out of any use of The Program or out of inability to use The Program (including, but not limited to, loss of data, data being rendered inaccurate, or losses sustained by anyone as a result of any failure of The Program to operate with any other programs), even if The Copyright Holder or said author or said other party has been advised of the possibility of such damages.\n\nWHETHER AND HOW TO DISTRIBUTE PROGRAMS UNDER THIS LICENSE =========================================================\n\nThis section contains important instructions, examples, and recommendations for authors who are considering distributing their programs under this license. These authors are addressed as `you' in this section.\n\nChoosing This License or Another License\n\n----------------------------------------\n\nIf for any part of your program you want or need to use *distribution* conditions that differ from those in this license, then do not refer to this license anywhere in your program but instead distribute your program under a different license. You may use the text of this license as a model for your own license, but your license should not refer to the LPPL or otherwise give the impression that your program is distributed under the LPPL.\n\nThe document `modguide.tex' in the base LaTeX distribution explains the motivation behind the conditions of this license. It explains, for example, why distributing LaTeX under the GNU General Public License (GPL) was considered inappropriate. Even if your program is unrelated to LaTeX, the discussion in `modguide.tex' may still be relevant, and authors intending to distribute their programs under any license are encouraged to read it.\n\nHow to Use This License\n\n-----------------------\n\nTo use this license, place in each of the files of your program both an explicit copyright notice including your name and the year and also a statement that the distribution and/or modification of the file is constrained by the conditions in this license.\n\nHere is an example of such a notice and statement:\n\n%% pig.dtx\n\n%% Copyright 2001 M. Y. Name\n\n%\n\n% This program may be distributed and/or modified under the\n\n% conditions of the LaTeX Project Public License, either version 1.2\n\n% of this license or (at your option) any later version.\n\n% The latest version of this license is in\n\n% http://www.latex-project.org/lppl.txt\n\n% and version 1.2 or later is part of all distributions of LaTeX\n\n% version 1999/12/01 or later.\n\n%\n\n% This program consists of the files pig.dtx and pig.ins\n\nGiven such a notice and statement in a file, the conditions given in this license document would apply, with `The Program' referring to the two files `pig.dtx' and `pig.ins', and `The Copyright Holder' referring to the person `M. Y. Name'.\n\nImportant Recommendations\n\n-------------------------\n\nDefining What Constitutes The Program\n\nThe LPPL requires that distributions of The Program contain all the files of The Program. It is therefore important that you provide a way for the licensee to determine which files constitute The Program. This could, for example, be achieved by explicitly listing all the files of The Program near the copyright notice of each file or by using a line like\n\n% This program consists of all files listed in manifest.txt.\n\nin that place. In the absence of an unequivocal list it might be impossible for the licensee to determine what is considered by you to comprise The Program.\n\nNoting Exceptional Files If The Program contains any files bearing additional conditions on modification, or on distribution of modified versions, of those files (other than those listed in `Additional Conditions on LaTeX Software Files'), then it is recommended that The Program contain a prominent file that defines the exceptional conditions, and either lists the exceptional files or defines one or more categories of exceptional files.\n\nFiles containing the text of a license (such as this file) are often examples of files bearing more restrictive conditions on modification. LaTeX configuration files (with filename extension `.cfg') are examples of files bearing less restrictive conditions on the distribution of a modified version of the file. The additional conditions on LaTeX software given above are examples of declaring a category of files bearing exceptional additional conditions."],"licenseIds":["LPPL-1.2"],"keywords":["1 2 1999","2 1999 09","1999 09 03","09 03 copyright","03 copyright 1999","a file other","file other than","than as necessitated","as necessitated by","necessitated by the","the file conventions","file conventions of","conventions of the","of the target","the target file","target file systems","file systems is","systems is considered","1 2 of","2 or later","version 1999 12","1999 12 01","lppl version 1 2","version 1 2 1999","1 2 1999 09","2 1999 09 03","1999 09 03 copyright","09 03 copyright 1999","03 copyright 1999 latex3","of a file other","a file other than","file other than as","other than as necessitated","than as necessitated by","as necessitated by the","necessitated by the file","by the file conventions","the file conventions of","file conventions of the","conventions of the target","of the target file","the target file systems","target file systems is","file systems is considered","systems is considered to","either version 1 2","version 1 2 of","1 2 of this","and version 1 2","1 2 or later","2 or later is","latex version 1999 12","version 1999 12 01","1999 12 01 or","license lppl version 1 2","lppl version 1 2 1999","version 1 2 1999 09","1 2 1999 09 03","2 1999 09 03 copyright","1999 09 03 copyright 1999","09 03 copyright 1999 latex3","03 copyright 1999 latex3 project","name of a file other","of a file other than","a file other than as","file other than as necessitated","other than as necessitated by","than as necessitated by the","as necessitated by the file","necessitated by the file conventions","by the file conventions of","the file conventions of the","file conventions of the target","conventions of the target file","of the target file systems","the target file systems is","target file systems is considered","file systems is considered to","systems is considered to be","license either version 1 2","either version 1 2 of","version 1 2 of this","1 2 of this license","txt and version 1 2","and version 1 2 or","version 1 2 or later","1 2 or later is","2 or later is part","of latex version 1999 12","latex version 1999 12 01","version 1999 12 01 or","1999 12 01 or later"]},{"licenseTexts":["The LaTeX Project Public License\n\n=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-\n\nLPPL Version 1.3a 2004-10-01 Copyright 1999 2002-04 LaTeX3 Project\n\nEveryone is allowed to distribute verbatim copies of this license document, but modification of it is not allowed.\n\nPREAMBLE\n\n========\n\nThe LaTeX Project Public License (LPPL) is the primary license under which the the LaTeX kernel and the base LaTeX packages are distributed.\n\nYou may use this license for any work of which you hold the copyright and which you wish to distribute. This license may be particularly suitable if your work is TeX-related (such as a LaTeX package), but you may use it with small modifications even if your work is unrelated to TeX.\n\nThe section `WHETHER AND HOW TO DISTRIBUTE WORKS UNDER THIS LICENSE', below, gives instructions, examples, and recommendations for authors who are considering distributing their works under this license.\n\nThis license gives conditions under which a work may be distributed and modified, as well as conditions under which modified versions of that work may be distributed.\n\nWe, the LaTeX3 Project, believe that the conditions below give you the freedom to make and distribute modified versions of your work that conform with whatever technical specifications you wish while maintaining the availability, integrity, and reliability of that work. If you do not see how to achieve your goal while meeting these conditions, then read the document `cfgguide.tex' and `modguide.tex' in the base LaTeX distribution for suggestions.\n\nDEFINITIONS\n\n===========\n\nIn this license document the following terms are used:\n\n`Work' Any work being distributed under this License. `Derived Work' Any work that under any applicable law is derived from the Work.\n\n`Modification' Any procedure that produces a Derived Work under any applicable law -- for example, the production of a file containing an original file associated with the Work or a significant portion of such a file, either verbatim or with modifications and/or translated into another language.\n\n`Modify' To apply any procedure that produces a Derived Work under any applicable law. `Distribution' Making copies of the Work available from one person to another, in whole or in part. Distribution includes (but is not limited to) making any electronic components of the Work accessible by file transfer protocols such as FTP or HTTP or by shared file systems such as Sun's Network File System (NFS).\n\n`Compiled Work' A version of the Work that has been processed into a form where it is directly usable on a computer system. This processing may include using installation facilities provided by the Work, transformations of the Work, copying of components of the Work, or other activities. Note that modification of any installation facilities provided by the Work constitutes modification of the Work.\n\n`Current Maintainer' A person or persons nominated as such within the Work. If there is no such explicit nomination then it is the `Copyright Holder' under any applicable law.\n\n`Base Interpreter' A program or process that is normally needed for running or interpreting a part or the whole of the Work. A Base Interpreter may depend on external components but these are not considered part of the Base Interpreter provided that each external component clearly identifies itself whenever it is used interactively. Unless explicitly specified when applying the license to the Work, the only applicable Base Interpreter is a \"LaTeX-Format\".\n\nCONDITIONS ON DISTRIBUTION AND MODIFICATION\n\n===========================================\n\n   1. Activities other than distribution and/or modification of the Work are not covered by this license; they are outside its scope. In particular, the act of running the Work is not restricted and no requirements are made concerning any offers of support for the Work.\n\n   2. You may distribute a complete, unmodified copy of the Work as you received it. Distribution of only part of the Work is considered modification of the Work, and no right to distribute such a Derived Work may be assumed under the terms of this clause.\n\n   3. You may distribute a Compiled Work that has been generated from a complete, unmodified copy of the Work as distributed under Clause 2 above, as long as that Compiled Work is distributed in such a way that the recipients may install the Compiled Work on their system exactly as it would have been installed if they generated a Compiled Work directly from the Work.\n\n   4. If you are the Current Maintainer of the Work, you may, without restriction, modify the Work, thus creating a Derived Work. You may also distribute the Derived Work without restriction, including Compiled Works generated from the Derived Work. Derived Works distributed in this manner by the Current Maintainer are considered to be updated versions of the Work.\n\n   5. If you are not the Current Maintainer of the Work, you may modify your copy of the Work, thus creating a Derived Work based on the Work, and compile this Derived Work, thus creating a Compiled Work based on the Derived Work.\n\n   6. If you are not the Current Maintainer of the Work, you may distribute a Derived Work provided the following conditions are met for every component of the Work unless that component clearly states in the copyright notice that it is exempt from that condition. Only the Current Maintainer is allowed to add such statements of exemption to a component of the Work.\n\n      a. If a component of this Derived Work can be a direct replacement for a component of the Work when that component is used with the Base Interpreter, then, wherever this component of the Work identifies itself to the user when used interactively with that Base Interpreter, the replacement component of this Derived Work clearly and unambiguously identifies itself as a modified version of this component to the user when used interactively with that Base Interpreter.\n\n      b. Every component of the Derived Work contains prominent notices detailing the nature of the changes to that component, or a prominent reference to another file that is distributed as part of the Derived Work and that contains a complete and accurate log of the changes.\n\n      c. No information in the Derived Work implies that any persons, including (but not limited to) the authors of the original version of the Work, provide any support, including (but not limited to) the reporting and handling of errors, to recipients of the Derived Work unless those persons have stated explicitly that they do provide such support for the Derived Work.\n\n      d. You distribute at least one of the following with the Derived Work:\n\n         1. A complete, unmodified copy of the Work; if your distribution of a modified component is made by offering access to copy the modified component from a designated place, then offering equivalent access to copy the Work from the same or some similar place meets this condition, even though third parties are not compelled to copy the Work along with the modified component;\n\n         2. Information that is sufficient to obtain a complete, unmodified copy of the Work.\n\n   7. If you are not the Current Maintainer of the Work, you may distribute a Compiled Work generated from a Derived Work, as long as the Derived Work is distributed to all recipients of the Compiled Work, and as long as the conditions of Clause 6, above, are met with regard to the Derived Work.\n\n   8. The conditions above are not intended to prohibit, and hence do not apply to, the modification, by any method, of any component so that it becomes identical to an updated version of that component of the Work as it is distributed by the Current Maintainer under Clause 4, above.\n\n   9. Distribution of the Work or any Derived Work in an alternative format, where the Work or that Derived Work (in whole or in part) is then produced by applying some process to that format, does not relax or nullify any sections of this license as they pertain to the results of applying that process.\n\n   10.\n\n      a. A Derived Work may be distributed under a different license provided that license itself honors the conditions listed in Clause 6 above, in regard to the Work, though it does not have to honor the rest of the conditions in this license.\n\n      b. If a Derived Work is distributed under this license, that Derived Work must provide sufficient documentation as part of itself to allow each recipient of that Derived Work to honor the restrictions in Clause 6 above, concerning changes from the Work.\n\n   11. This license places no restrictions on works that are unrelated to the Work, nor does this license place any restrictions on aggregating such works with the Work by any means.\n\n   12. Nothing in this license is intended to, or may be used to, prevent complete compliance by all parties with all applicable laws.\n\nNO WARRANTY\n\n===========\n\nThere is no warranty for the Work. Except when otherwise stated in writing, the Copyright Holder provides the Work `as is', without warranty of any kind, either expressed or implied, including, but not limited to, the implied warranties of merchantability and fitness for a particular purpose. The entire risk as to the quality and performance of the Work is with you. Should the Work prove defective, you assume the cost of all necessary servicing, repair, or correction.\n\nIn no event unless required by applicable law or agreed to in writing will The Copyright Holder, or any author named in the components of the Work, or any other party who may distribute and/or modify the Work as permitted above, be liable to you for damages, including any general, special, incidental or consequential damages arising out of any use of the Work or out of inability to use the Work (including, but not limited to, loss of data, data being rendered inaccurate, or losses sustained by anyone as a result of any failure of the Work to operate with any other programs), even if the Copyright Holder or said author or said other party has been advised of the possibility of such damages.\n\nMAINTENANCE OF THE WORK\n\n=======================\n\nThe Work has the status `author-maintained' if the Copyright Holder explicitly and prominently states near the primary copyright notice in the Work that the Work can only be maintained by the Copyright Holder or simply that is `author-maintained'.\n\nThe Work has the status `maintained' if there is a Current Maintainer who has indicated in the Work that they are willing to receive error reports for the Work (for example, by supplying a valid e-mail address). It is not required for the Current Maintainer to acknowledge or act upon these error reports.\n\nThe Work changes from status `maintained' to `unmaintained' if there is no Current Maintainer, or the person stated to be Current Maintainer of the work cannot be reached through the indicated means of communication for a period of six months, and there are no other significant signs of active maintenance.\n\nYou can become the Current Maintainer of the Work by agreement with any existing Current Maintainer to take over this role.\n\nIf the Work is unmaintained, you can become the Current Maintainer of the Work through the following steps:\n\n   1. Make a reasonable attempt to trace the Current Maintainer (and the Copyright Holder, if the two differ) through the means of an Internet or similar search.\n\n   2. If this search is successful, then enquire whether the Work is still maintained.\n\n      a. If it is being maintained, then ask the Current Maintainer to update their communication data within one month.\n\n      b. If the search is unsuccessful or no action to resume active maintenance is taken by the Current Maintainer, then announce within the pertinent community your intention to take over maintenance. (If the Work is a LaTeX work, this could be done, for example, by posting to comp.text.tex.)\n\n      3a. If the Current Maintainer is reachable and agrees to pass maintenance of the Work to you, then this takes effect immediately upon announcement.\n\n      b. If the Current Maintainer is not reachable and the Copyright Holder agrees that maintenance of the Work be passed to you, then this takes effect immediately upon announcement.\n\n   4. If you make an `intention announcement' as described in 2b. above and after three months your intention is challenged neither by the Current Maintainer nor by the Copyright Holder nor by other people, then you may arrange for the Work to be changed so as to name you as the (new) Current Maintainer.\n\n   5. If the previously unreachable Current Maintainer becomes reachable once more within three months of a change completed under the terms of 3b) or 4), then that Current Maintainer must become or remain the Current Maintainer upon request provided they then update their communication data within one month.\n\nA change in the Current Maintainer does not, of itself, alter the fact that the Work is distributed under the LPPL license.\n\nIf you become the Current Maintainer of the Work, you should immediately provide, within the Work, a prominent and unambiguous statement of your status as Current Maintainer. You should also announce your new status to the same pertinent community as in 2b) above.\n\nWHETHER AND HOW TO DISTRIBUTE WORKS UNDER THIS LICENSE\n\n======================================================\n\nThis section contains important instructions, examples, and recommendations for authors who are considering distributing their works under this license. These authors are addressed as `you' in this section.\n\nChoosing This License or Another License\n\n----------------------------------------\n\nIf for any part of your work you want or need to use *distribution* conditions that differ significantly from those in this license, then do not refer to this license anywhere in your work but, instead, distribute your work under a different license. You may use the text of this license as a model for your own license, but your license should not refer to the LPPL or otherwise give the impression that your work is distributed under the LPPL.\n\nThe document `modguide.tex' in the base LaTeX distribution explains the motivation behind the conditions of this license. It explains, for example, why distributing LaTeX under the GNU General Public License (GPL) was considered inappropriate. Even if your work is unrelated to LaTeX, the discussion in `modguide.tex' may still be relevant, and authors intending to distribute their works under any license are encouraged to read it.\n\nA Recommendation on Modification Without Distribution\n\n-----------------------------------------------------\n\nIt is wise never to modify a component of the Work, even for your own personal use, without also meeting the above conditions for distributing the modified component. While you might intend that such modifications will never be distributed, often this will happen by accident -- you may forget that you have modified that component; or it may not occur to you when allowing others to access the modified version that you are thus distributing it and violating the conditions of this license in ways that could have legal implications and, worse, cause problems for the community. It is therefore usually in your best interest to keep your copy of the Work identical with the public one. Many works provide ways to control the behavior of that work without altering any of its licensed components.\n\nHow to Use This License\n\n-----------------------\n\nTo use this license, place in each of the components of your work both an explicit copyright notice including your name and the year the work was authored and/or last substantially modified. Include also a statement that the distribution and/or modification of that component is constrained by the conditions in this license.\n\nHere is an example of such a notice and statement:\n\n%% pig.dtx\n\n%% Copyright 2003 M. Y. Name\n\n%\n\n% This work may be distributed and/or modified under the\n\n% conditions of the LaTeX Project Public License, either version 1.3\n\n% of this license or (at your option) any later version.\n\n% The latest version of this license is in\n\n% http://www.latex-project.org/lppl.txt\n\n% and version 1.3 or later is part of all distributions of LaTeX\n\n% version 2003/12/01 or later.\n\n%\n\n% This work has the LPPL maintenance status \" maintained \".\n\n%\n\n% This Current Maintainer of this work is M. Y. Name .\n\n%\n\n% This work consists of the files pig.dtx and pig.ins\n\n% and the derived file pig.sty .\n\nGiven such a notice and statement in a file, the conditions given in this license document would apply, with the `Work' referring to the three files `pig.dtx', `pig.ins', and `pig.sty' (the last being generated from `pig.dtx' using `pig.ins'), the `Base Interpreter' referring to any \"LaTeX-Format\", and both `Copyright Holder' and `Current Maintainer' referring to the person `M. Y. Name'.\n\nIf you do not want the Maintenance section of LPPL to apply to your Work, change \"maintained\" above into \"author-maintained\". However, we recommend that you use \"maintained\" as the Maintenance section was added in order to ensure that your Work remains useful to the community even when you can no longer maintain and support it yourself.\n\nImportant Recommendations\n\n-------------------------\n\nDefining What Constitutes the Work\n\nThe LPPL requires that distributions of the Work contain all the files of the Work. It is therefore important that you provide a way for the licensee to determine which files constitute the Work. This could, for example, be achieved by explicitly listing all the files of the Work near the copyright notice of each file or by using a line such as:\n\n% This work consists of all files listed in manifest.txt.\n\nin that place. In the absence of an unequivocal list it might be impossible for the licensee to determine what is considered by you to comprise the Work and, in such a case, the licensee would be entitled to make reasonable conjectures as to which files comprise the Work."],"licenseIds":["LPPL-1.3a"],"keywords":["version 1 3a","1 3a 2004","3a 2004 10","2004 10 01","10 01 copyright","1999 2002 04","2002 04 latex3","04 latex3 project","which the the","the the latex","use it with","it with small","with small modifications","small modifications even","modifications even if","latex format conditions","format conditions on","simply that is","that is author","dtx copyright 2003","copyright 2003 m","2003 m y","latex version 2003","version 2003 12","2003 12 01","status maintained this","maintained this current","this current maintainer","it yourself important","yourself important recommendations","lppl version 1 3a","version 1 3a 2004","1 3a 2004 10","3a 2004 10 01","2004 10 01 copyright","10 01 copyright 1999","01 copyright 1999 2002","copyright 1999 2002 04","1999 2002 04 latex3","2002 04 latex3 project","04 latex3 project everyone","under which the the","which the the latex","the the latex kernel","may use it with","use it with small","it with small modifications","with small modifications even","small modifications even if","modifications even if your","a latex format conditions","latex format conditions on","format conditions on distribution","this license that derived","or simply that is","simply that is author","that is author maintained","pig dtx copyright 2003","dtx copyright 2003 m","copyright 2003 m y","2003 m y name","of latex version 2003","latex version 2003 12","version 2003 12 01","2003 12 01 or","maintenance status maintained this","status maintained this current","maintained this current maintainer","this current maintainer of","support it yourself important","it yourself important recommendations","yourself important recommendations defining","license lppl version 1 3a","lppl version 1 3a 2004","version 1 3a 2004 10","1 3a 2004 10 01","3a 2004 10 01 copyright","2004 10 01 copyright 1999","10 01 copyright 1999 2002","01 copyright 1999 2002 04","copyright 1999 2002 04 latex3","1999 2002 04 latex3 project","2002 04 latex3 project everyone","04 latex3 project everyone is","license under which the the","under which the the latex","which the the latex kernel","the the latex kernel and","you may use it with","may use it with small","use it with small modifications","it with small modifications even","with small modifications even if","small modifications even if your","modifications even if your work","is a latex format conditions","a latex format conditions on","latex format conditions on distribution","format conditions on distribution and","work is distributed under this","distributed under this license that","under this license that derived","this license that derived work","holder or simply that is","or simply that is author","simply that is author maintained","that is author maintained the","statement pig dtx copyright 2003","pig dtx copyright 2003 m","dtx copyright 2003 m y","copyright 2003 m y name","2003 m y name this","distributions of latex version 2003","of latex version 2003 12","latex version 2003 12 01","version 2003 12 01 or","2003 12 01 or later","lppl maintenance status maintained this","maintenance status maintained this current","status maintained this current maintainer","maintained this current maintainer of","this current maintainer of this","and support it yourself important","support it yourself important recommendations","it yourself important recommendations defining","yourself important recommendations defining what"]},{"licenseTexts":["The LaTeX Project Public License\n\n=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-\n\nLPPL Version 1.3c 2008-05-04 Copyright 1999 2002-2008 LaTeX3 Project\n\nEveryone is allowed to distribute verbatim copies of this license document, but modification of it is not allowed.\n\nPREAMBLE\n\n========\n\nThe LaTeX Project Public License (LPPL) is the primary license under which the LaTeX kernel and the base LaTeX packages are distributed.\n\nYou may use this license for any work of which you hold the copyright and which you wish to distribute. This license may be particularly suitable if your work is TeX-related (such as a LaTeX package), but it is written in such a way that you can use it even if your work is unrelated to TeX.\n\nThe section `WHETHER AND HOW TO DISTRIBUTE WORKS UNDER THIS LICENSE', below, gives instructions, examples, and recommendations for authors who are considering distributing their works under this license.\n\nThis license gives conditions under which a work may be distributed and modified, as well as conditions under which modified versions of that work may be distributed.\n\nWe, the LaTeX3 Project, believe that the conditions below give you the freedom to make and distribute modified versions of your work that conform with whatever technical specifications you wish while maintaining the availability, integrity, and reliability of that work. If you do not see how to achieve your goal while meeting these conditions, then read the document `cfgguide.tex' and `modguide.tex' in the base LaTeX distribution for suggestions.\n\nDEFINITIONS\n\n===========\n\nIn this license document the following terms are used:\n\n`Work' Any work being distributed under this License. `Derived Work' Any work that under any applicable law is derived from the Work.\n\n`Modification' Any procedure that produces a Derived Work under any applicable law -- for example, the production of a file containing an original file associated with the Work or a significant portion of such a file, either verbatim or with modifications and/or translated into another language.\n\n`Modify' To apply any procedure that produces a Derived Work under any applicable law. `Distribution' Making copies of the Work available from one person to another, in whole or in part. Distribution includes (but is not limited to) making any electronic components of the Work accessible by file transfer protocols such as FTP or HTTP or by shared file systems such as Sun's Network File System (NFS).\n\n`Compiled Work' A version of the Work that has been processed into a form where it is directly usable on a computer system. This processing may include using installation facilities provided by the Work, transformations of the Work, copying of components of the Work, or other activities. Note that modification of any installation facilities provided by the Work constitutes modification of the Work.\n\n`Current Maintainer' A person or persons nominated as such within the Work. If there is no such explicit nomination then it is the `Copyright Holder' under any applicable law.\n\n`Base Interpreter' A program or process that is normally needed for running or interpreting a part or the whole of the Work.\n\nA Base Interpreter may depend on external components but these are not considered part of the Base Interpreter provided that each external component clearly identifies itself whenever it is used interactively. Unless explicitly specified when applying the license to the Work, the only applicable Base Interpreter is a `LaTeX-Format' or in the case of files belonging to the `LaTeX-format' a program implementing the `TeX language'.\n\nCONDITIONS ON DISTRIBUTION AND MODIFICATION\n\n===========================================\n\n   1. Activities other than distribution and/or modification of the Work are not covered by this license; they are outside its scope. In particular, the act of running the Work is not restricted and no requirements are made concerning any offers of support for the Work.\n\n   2. You may distribute a complete, unmodified copy of the Work as you received it. Distribution of only part of the Work is considered modification of the Work, and no right to distribute such a Derived Work may be assumed under the terms of this clause.\n\n   3. You may distribute a Compiled Work that has been generated from a complete, unmodified copy of the Work as distributed under Clause 2 above, as long as that Compiled Work is distributed in such a way that the recipients may install the Compiled Work on their system exactly as it would have been installed if they generated a Compiled Work directly from the Work.\n\n   4. If you are the Current Maintainer of the Work, you may, without restriction, modify the Work, thus creating a Derived Work. You may also distribute the Derived Work without restriction, including Compiled Works generated from the Derived Work. Derived Works distributed in this manner by the Current Maintainer are considered to be updated versions of the Work.\n\n   5. If you are not the Current Maintainer of the Work, you may modify your copy of the Work, thus creating a Derived Work based on the Work, and compile this Derived Work, thus creating a Compiled Work based on the Derived Work.\n\n   6. If you are not the Current Maintainer of the Work, you may distribute a Derived Work provided the following conditions are met for every component of the Work unless that component clearly states in the copyright notice that it is exempt from that condition. Only the Current Maintainer is allowed to add such statements of exemption to a component of the Work.\n\n      a. If a component of this Derived Work can be a direct replacement for a component of the Work when that component is used with the Base Interpreter, then, wherever this component of the Work identifies itself to the user when used interactively with that Base Interpreter, the replacement component of this Derived Work clearly and unambiguously identifies itself as a modified version of this component to the user when used interactively with that Base Interpreter.\n\n      b. Every component of the Derived Work contains prominent notices detailing the nature of the changes to that component, or a prominent reference to another file that is distributed as part of the Derived Work and that contains a complete and accurate log of the changes.\n\n      c. No information in the Derived Work implies that any persons, including (but not limited to) the authors of the original version of the Work, provide any support, including (but not limited to) the reporting and handling of errors, to recipients of the Derived Work unless those persons have stated explicitly that they do provide such support for the Derived Work.\n\n      d. You distribute at least one of the following with the Derived Work:\n\n         1. A complete, unmodified copy of the Work; if your distribution of a modified component is made by offering access to copy the modified component from a designated place, then offering equivalent access to copy the Work from the same or some similar place meets this condition, even though third parties are not compelled to copy the Work along with the modified component;\n\n         2. Information that is sufficient to obtain a complete, unmodified copy of the Work.\n\n   7. If you are not the Current Maintainer of the Work, you may distribute a Compiled Work generated from a Derived Work, as long as the Derived Work is distributed to all recipients of the Compiled Work, and as long as the conditions of Clause 6, above, are met with regard to the Derived Work.\n\n   8. The conditions above are not intended to prohibit, and hence do not apply to, the modification, by any method, of any component so that it becomes identical to an updated version of that component of the Work as it is distributed by the Current Maintainer under Clause 4, above.\n\n   9. Distribution of the Work or any Derived Work in an alternative format, where the Work or that Derived Work (in whole or in part) is then produced by applying some process to that format, does not relax or nullify any sections of this license as they pertain to the results of applying that process.\n\n   10.\n\n      a. A Derived Work may be distributed under a different license provided that license itself honors the conditions listed in Clause 6 above, in regard to the Work, though it does not have to honor the rest of the conditions in this license.\n\n      b. If a Derived Work is distributed under a different license, that Derived Work must provide sufficient documentation as part of itself to allow each recipient of that Derived Work to honor the restrictions in Clause 6 above, concerning changes from the Work.\n\n   11. This license places no restrictions on works that are unrelated to the Work, nor does this license place any restrictions on aggregating such works with the Work by any means.\n\n   12. Nothing in this license is intended to, or may be used to, prevent complete compliance by all parties with all applicable laws.\n\nNO WARRANTY\n\n===========\n\nThere is no warranty for the Work. Except when otherwise stated in writing, the Copyright Holder provides the Work `as is', without warranty of any kind, either expressed or implied, including, but not limited to, the implied warranties of merchantability and fitness for a particular purpose. The entire risk as to the quality and performance of the Work is with you. Should the Work prove defective, you assume the cost of all necessary servicing, repair, or correction.\n\nIn no event unless required by applicable law or agreed to in writing will The Copyright Holder, or any author named in the components of the Work, or any other party who may distribute and/or modify the Work as permitted above, be liable to you for damages, including any general, special, incidental or consequential damages arising out of any use of the Work or out of inability to use the Work (including, but not limited to, loss of data, data being rendered inaccurate, or losses sustained by anyone as a result of any failure of the Work to operate with any other programs), even if the Copyright Holder or said author or said other party has been advised of the possibility of such damages.\n\nMAINTENANCE OF THE WORK\n\n=======================\n\nThe Work has the status `author-maintained' if the Copyright Holder explicitly and prominently states near the primary copyright notice in the Work that the Work can only be maintained by the Copyright Holder or simply that it is `author-maintained'.\n\nThe Work has the status `maintained' if there is a Current Maintainer who has indicated in the Work that they are willing to receive error reports for the Work (for example, by supplying a valid e-mail address). It is not required for the Current Maintainer to acknowledge or act upon these error reports.\n\nThe Work changes from status `maintained' to `unmaintained' if there is no Current Maintainer, or the person stated to be Current Maintainer of the work cannot be reached through the indicated means of communication for a period of six months, and there are no other significant signs of active maintenance.\n\nYou can become the Current Maintainer of the Work by agreement with any existing Current Maintainer to take over this role.\n\nIf the Work is unmaintained, you can become the Current Maintainer of the Work through the following steps:\n\n   1. Make a reasonable attempt to trace the Current Maintainer (and the Copyright Holder, if the two differ) through the means of an Internet or similar search.\n\n   2. If this search is successful, then enquire whether the Work is still maintained.\n\n      a. If it is being maintained, then ask the Current Maintainer to update their communication data within one month.\n\n      b. If the search is unsuccessful or no action to resume active maintenance is taken by the Current Maintainer, then announce within the pertinent community your intention to take over maintenance. (If the Work is a LaTeX work, this could be done, for example, by posting to comp.text.tex.)\n\n      3a. If the Current Maintainer is reachable and agrees to pass maintenance of the Work to you, then this takes effect immediately upon announcement.\n\n      b. If the Current Maintainer is not reachable and the Copyright Holder agrees that maintenance of the Work be passed to you, then this takes effect immediately upon announcement.\n\n   4. If you make an `intention announcement' as described in 2b. above and after three months your intention is challenged neither by the Current Maintainer nor by the Copyright Holder nor by other people, then you may arrange for the Work to be changed so as to name you as the (new) Current Maintainer.\n\n   5. If the previously unreachable Current Maintainer becomes reachable once more within three months of a change completed under the terms of 3b) or 4), then that Current Maintainer must become or remain the Current Maintainer upon request provided they then update their communication data within one month.\n\nA change in the Current Maintainer does not, of itself, alter the fact that the Work is distributed under the LPPL license.\n\nIf you become the Current Maintainer of the Work, you should immediately provide, within the Work, a prominent and unambiguous statement of your status as Current Maintainer. You should also announce your new status to the same pertinent community as in 2b) above.\n\nWHETHER AND HOW TO DISTRIBUTE WORKS UNDER THIS LICENSE\n\n======================================================\n\nThis section contains important instructions, examples, and recommendations for authors who are considering distributing their works under this license. These authors are addressed as `you' in this section.\n\nChoosing This License or Another License\n\n----------------------------------------\n\nIf for any part of your work you want or need to use *distribution* conditions that differ significantly from those in this license, then do not refer to this license anywhere in your work but, instead, distribute your work under a different license. You may use the text of this license as a model for your own license, but your license should not refer to the LPPL or otherwise give the impression that your work is distributed under the LPPL.\n\nThe document `modguide.tex' in the base LaTeX distribution explains the motivation behind the conditions of this license. It explains, for example, why distributing LaTeX under the GNU General Public License (GPL) was considered inappropriate. Even if your work is unrelated to LaTeX, the discussion in `modguide.tex' may still be relevant, and authors intending to distribute their works under any license are encouraged to read it.\n\nA Recommendation on Modification Without Distribution\n\n-----------------------------------------------------\n\nIt is wise never to modify a component of the Work, even for your own personal use, without also meeting the above conditions for distributing the modified component. While you might intend that such modifications will never be distributed, often this will happen by accident -- you may forget that you have modified that component; or it may not occur to you when allowing others to access the modified version that you are thus distributing it and violating the conditions of this license in ways that could have legal implications and, worse, cause problems for the community. It is therefore usually in your best interest to keep your copy of the Work identical with the public one. Many works provide ways to control the behavior of that work without altering any of its licensed components.\n\nHow to Use This License\n\n-----------------------\n\nTo use this license, place in each of the components of your work both an explicit copyright notice including your name and the year the work was authored and/or last substantially modified. Include also a statement that the distribution and/or modification of that component is constrained by the conditions in this license.\n\nHere is an example of such a notice and statement:\n\n%% pig.dtx\n\n%% Copyright 2005 M. Y. Name\n\n%\n\n% This work may be distributed and/or modified under the\n\n% conditions of the LaTeX Project Public License, either version 1.3\n\n% of this license or (at your option) any later version.\n\n% The latest version of this license is in\n\n% http://www.latex-project.org/lppl.txt\n\n% and version 1.3 or later is part of all distributions of LaTeX\n\n% version 2005/12/01 or later.\n\n%\n\n% This work has the LPPL maintenance status \" maintained \".\n\n%\n\n% The Current Maintainer of this work is M. Y. Name .\n\n%\n\n% This work consists of the files pig.dtx and pig.ins\n\n% and the derived file pig.sty .\n\nGiven such a notice and statement in a file, the conditions given in this license document would apply, with the `Work' referring to the three files `pig.dtx', `pig.ins', and `pig.sty' (the last being generated from `pig.dtx' using `pig.ins'), the `Base Interpreter' referring to any `LaTeX-Format', and both `Copyright Holder' and `Current Maintainer' referring to the person `M. Y. Name'.\n\nIf you do not want the Maintenance section of LPPL to apply to your Work, change `maintained' above into `author-maintained'. However, we recommend that you use `maintained', as the Maintenance section was added in order to ensure that your Work remains useful to the community even when you can no longer maintain and support it yourself.\n\nDerived Works That Are Not Replacements\n\n---------------------------------------\n\nSeveral clauses of the LPPL specify means to provide reliability and stability for the user community. They therefore concern themselves with the case that a Derived Work is intended to be used as a (compatible or incompatible) replacement of the original Work. If this is not the case (e.g., if a few lines of code are reused for a completely different task), then clauses 6b and 6d shall not apply.\n\nImportant Recommendations\n\n-------------------------\n\nDefining What Constitutes the Work\n\nThe LPPL requires that distributions of the Work contain all the files of the Work. It is therefore important that you provide a way for the licensee to determine which files constitute the Work. This could, for example, be achieved by explicitly listing all the files of the Work near the copyright notice of each file or by using a line such as:\n\n% This work consists of all files listed in manifest.txt.\n\nin that place. In the absence of an unequivocal list it might be impossible for the licensee to determine what is considered by you to comprise the Work and, in such a case, the licensee would be entitled to make reasonable conjectures as to which files comprise the Work."],"licenseIds":["LPPL-1.3c"],"keywords":["version 1 3c","1 3c 2008","3c 2008 05","2008 05 04","05 04 copyright","04 copyright 1999","1999 2002 2008","2002 2008 latex3","2008 latex3 project","which the latex","package but it","but it is","it is written","written in such","latex format or","format or in","case of files","of files belonging","files belonging to","to the latex","the latex format","latex format a","format a program","a program implementing","program implementing the","implementing the tex","the tex language","tex language conditions","language conditions on","different license that","simply that it","it is author","dtx copyright 2005","copyright 2005 m","2005 m y","latex version 2005","version 2005 12","2005 12 01","status maintained the","maintained the current","it yourself derived","yourself derived works","derived works that","are not replacements","not replacements several","replacements several clauses","several clauses of","clauses of the","the lppl specify","lppl specify means","specify means to","to provide reliability","provide reliability and","reliability and stability","and stability for","stability for the","the user community","user community they","community they therefore","they therefore concern","therefore concern themselves","concern themselves with","themselves with the","with the case","the case that","case that a","that a derived","work is intended","be used as","as a compatible","a compatible or","compatible or incompatible","or incompatible replacement","incompatible replacement of","original work if","not the case","the case e","case e g","e g if","g if a","if a few","of code are","code are reused","are reused for","reused for a","for a completely","a completely different","completely different task","different task then","task then clauses","then clauses 6b","clauses 6b and","6b and 6d","and 6d shall","6d shall not","not apply important","apply important recommendations","lppl version 1 3c","version 1 3c 2008","1 3c 2008 05","3c 2008 05 04","2008 05 04 copyright","05 04 copyright 1999","04 copyright 1999 2002","copyright 1999 2002 2008","1999 2002 2008 latex3","2002 2008 latex3 project","2008 latex3 project everyone","under which the latex","which the latex kernel","latex package but it","package but it is","but it is written","it is written in","is written in such","written in such a","a way that you","way that you can","that you can use","can use it even","a latex format or","latex format or in","format or in the","the case of files","case of files belonging","of files belonging to","files belonging to the","belonging to the latex","to the latex format","the latex format a","latex format a program","format a program implementing","a program implementing the","program implementing the tex","implementing the tex language","the tex language conditions","tex language conditions on","language conditions on distribution","is distributed under a","a different license that","different license that derived","or simply that it","simply that it is","that it is author","it is author maintained","pig dtx copyright 2005","dtx copyright 2005 m","copyright 2005 m y","2005 m y name","of latex version 2005","latex version 2005 12","version 2005 12 01","2005 12 01 or","maintenance status maintained the","status maintained the current","maintained the current maintainer","support it yourself derived","it yourself derived works","yourself derived works that","derived works that are","works that are not","that are not replacements","are not replacements several","not replacements several clauses","replacements several clauses of","several clauses of the","clauses of the lppl","of the lppl specify","the lppl specify means","lppl specify means to","specify means to provide","means to provide reliability","to provide reliability and","provide reliability and stability","reliability and stability for","and stability for the","stability for the user","for the user community","the user community they","user community they therefore","community they therefore concern","they therefore concern themselves","therefore concern themselves with","concern themselves with the","themselves with the case","with the case that","the case that a","case that a derived","that a derived work","derived work is intended","work is intended to","to be used as","be used as a","used as a compatible","as a compatible or","a compatible or incompatible","compatible or incompatible replacement","or incompatible replacement of","incompatible replacement of the","replacement of the original"]},{"licenseTexts":["Copyright (C) 2007, 2008, 2009, 2010 Karl Berry.\n\nCopyright (C) 1988, 1994, 2007 Stephen Gilmore.\n\nCopyright (C) 1994, 1995, 1996 Torsten Martinsen.\n\nPermission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies.\n\nPermission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided that the entire resulting derived work is distributed under the terms of a permission notice identical to this one.\n\nPermission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions."],"licenseIds":["Latex2e"],"keywords":["c 2007 2008","2007 2008 2009","2008 2009 2010","2009 2010 karl","2010 karl berry","karl berry copyright","berry copyright c","c 1988 1994","1988 1994 2007","1994 2007 stephen","2007 stephen gilmore","stephen gilmore copyright","gilmore copyright c","1994 1995 1996","1995 1996 torsten","1996 torsten martinsen","torsten martinsen permission","martinsen permission is","this manual provided","manual provided the","this manual under","manual under the","this one permission","one permission is","and distribute translations","translations of this","this manual into","manual into another","another language under","language under the","conditions for modified","copyright c 2007 2008","c 2007 2008 2009","2007 2008 2009 2010","2008 2009 2010 karl","2009 2010 karl berry","2010 karl berry copyright","karl berry copyright c","berry copyright c 1988","copyright c 1988 1994","c 1988 1994 2007","1988 1994 2007 stephen","1994 2007 stephen gilmore","2007 stephen gilmore copyright","stephen gilmore copyright c","gilmore copyright c 1994","c 1994 1995 1996","1994 1995 1996 torsten","1995 1996 torsten martinsen","1996 torsten martinsen permission","torsten martinsen permission is","martinsen permission is granted","copies of this manual","of this manual provided","this manual provided the","manual provided the copyright","versions of this manual","of this manual under","this manual under the","manual under the conditions","to this one permission","this one permission is","one permission is granted","copy and distribute translations","and distribute translations of","distribute translations of this","translations of this manual","of this manual into","this manual into another","manual into another language","into another language under","another language under the","language under the above","under the above conditions","above conditions for modified","conditions for modified versions","copyright c 2007 2008 2009","c 2007 2008 2009 2010","2007 2008 2009 2010 karl","2008 2009 2010 karl berry","2009 2010 karl berry copyright","2010 karl berry copyright c","karl berry copyright c 1988","berry copyright c 1988 1994","copyright c 1988 1994 2007","c 1988 1994 2007 stephen","1988 1994 2007 stephen gilmore","1994 2007 stephen gilmore copyright","2007 stephen gilmore copyright c","stephen gilmore copyright c 1994","gilmore copyright c 1994 1995","copyright c 1994 1995 1996","c 1994 1995 1996 torsten","1994 1995 1996 torsten martinsen","1995 1996 torsten martinsen permission","1996 torsten martinsen permission is","torsten martinsen permission is granted","martinsen permission is granted to","verbatim copies of this manual","copies of this manual provided","of this manual provided the","this manual provided the copyright","manual provided the copyright notice","modified versions of this manual","versions of this manual under","of this manual under the","this manual under the conditions","manual under the conditions for","identical to this one permission","to this one permission is","this one permission is granted","one permission is granted to","to copy and distribute translations","copy and distribute translations of","and distribute translations of this","distribute translations of this manual","translations of this manual into","of this manual into another","this manual into another language","manual into another language under","into another language under the","another language under the above","language under the above conditions","under the above conditions for","the above conditions for modified","above conditions for modified versions"]},{"licenseTexts":["Copyright (C) 2001 Leptonica. All rights reserved.\n\nThis software is distributed in the hope that it will be useful, but with NO WARRANTY OF ANY KIND.\n\nNo author or distributor accepts responsibility to anyone for the consequences of using this software, or for whether it serves any particular purpose or works at all, unless he or she says so in writing. Everyone is granted permission to copy, modify and redistribute this source code, for commercial or non-commercial purposes, with the following restrictions:\n\n   (1) the origin of this source code must not be misrepresented;\n\n   (2) modified versions must be plainly marked as such; and\n\n   (3) this notice may not be removed or altered from any source or modified source distribution."],"licenseIds":["Leptonica"],"keywords":["c 2001 leptonica","2001 leptonica all","leptonica all rights","useful but with","but with no","any kind no","kind no author","software or for","unless he or","or she says","she says so","and redistribute this","redistribute this source","commercial purposes with","purposes with the","misrepresented 2 modified","2 modified versions","modified versions must","such and 3","and 3 this","or modified source","modified source distribution","copyright c 2001 leptonica","c 2001 leptonica all","2001 leptonica all rights","leptonica all rights reserved","be useful but with","useful but with no","but with no warranty","of any kind no","any kind no author","kind no author or","of using this software","using this software or","this software or for","software or for whether","all unless he or","unless he or she","he or she says","or she says so","she says so in","modify and redistribute this","and redistribute this source","redistribute this source code","this source code for","source code for commercial","non commercial purposes with","commercial purposes with the","purposes with the following","with the following restrictions","be misrepresented 2 modified","misrepresented 2 modified versions","2 modified versions must","modified versions must be","as such and 3","such and 3 this","and 3 this notice","any source or modified","source or modified source","or modified source distribution","copyright c 2001 leptonica all","c 2001 leptonica all rights","2001 leptonica all rights reserved","leptonica all rights reserved this","reserved this software is distributed","will be useful but with","be useful but with no","useful but with no warranty","but with no warranty of","warranty of any kind no","of any kind no author","any kind no author or","kind no author or distributor","consequences of using this software","of using this software or","using this software or for","this software or for whether","software or for whether it","at all unless he or","all unless he or she","unless he or she says","he or she says so","or she says so in","she says so in writing","copy modify and redistribute this","modify and redistribute this source","and redistribute this source code","redistribute this source code for","this source code for commercial","source code for commercial or","or non commercial purposes with","non commercial purposes with the","commercial purposes with the following","purposes with the following restrictions","with the following restrictions 1","not be misrepresented 2 modified","be misrepresented 2 modified versions","misrepresented 2 modified versions must","2 modified versions must be","modified versions must be plainly","marked as such and 3","as such and 3 this","such and 3 this notice","and 3 this notice may","from any source or modified","any source or modified source","source or modified source distribution"]},{"licenseTexts":["Licence Libre du Québec – Permissive (LiLiQ-P)\n\nVersion 1.1\n\n   1. Préambule\n\n   Cette licence s'applique à tout logiciel distribué dont le titulaire du droit d'auteur précise qu'il est sujet aux termes de la Licence Libre du Québec – Permissive (LiLiQ-P) (ci-après appelée la « licence »).\n\n   2. Définitions\n\n   Dans la présente licence, à moins que le contexte n'indique un sens différent, on entend par:\n\n   « concédant » : le titulaire du droit d'auteur sur le logiciel, ou toute personne dûment autorisée par ce dernier à accorder la présente licence;\n\n   « contributeur » : le titulaire du droit d'auteur ou toute personne autorisée par ce dernier à soumettre au concédant une contribution. Un contributeur dont sa contribution est incorporée au logiciel est considéré comme un concédant en regard de sa contribution;\n\n   « contribution » : tout logiciel original, ou partie de logiciel original soumis et destiné à être incorporé dans le logiciel;\n\n   « distribution » : le fait de délivrer une copie du logiciel;\n\n   « licencié » : toute personne qui possède une copie du logiciel et qui exerce les droits concédés par la licence;\n\n   « logiciel » : une œuvre protégée par le droit d'auteur, telle qu'un programme d'ordinateur et sa documentation, pour laquelle le titulaire du droit d'auteur a précisé qu'elle est sujette aux termes de la présente licence;\n\n   « logiciel dérivé » : tout logiciel original réalisé par un licencié, autre que le logiciel ou un logiciel modifié, qui produit ou reproduit la totalité ou une partie importante du logiciel;\n\n   « logiciel modifié » : toute modification par un licencié de l'un des fichiers source du logiciel ou encore tout nouveau fichier source qui incorpore le logiciel ou une partie importante de ce dernier.\n\n   3. Licence de droit d'auteur\n\n   Sous réserve des termes de la licence, le concédant accorde au licencié une licence non exclusive et libre de redevances lui permettant d'exercer les droits suivants sur le logiciel :\n\n      1  Produire ou reproduire la totalité ou une partie importante;\n\n      2  Exécuter ou représenter la totalité ou une partie importante en public;\n\n      3  Publier la totalité ou une partie importante;\n\n      4  Sous-licencier sous une autre licence libre, approuvée ou certifiée par la Free Software Foundation ou l'Open Source Initiative.\n\n   \n\n   Cette licence est accordée sans limite territoriale et sans limite de temps.\n\n   L'exercice complet de ces droits est sujet à la distribution par le concédant du code source du logiciel, lequel doit être sous une forme permettant d'y apporter des modifications. Le concédant peut aussi distribuer le logiciel accompagné d'une offre de distribuer le code source du logiciel, sans frais supplémentaires, autres que ceux raisonnables afin de permettre la livraison du code source. Cette offre doit être valide pendant une durée raisonnable.\n\n   4. Distribution\n\n   Le licencié peut distribuer des copies du logiciel, d'un logiciel modifié ou dérivé, sous réserve de respecter les conditions suivantes :\n\n   \n\n      1  Le logiciel doit être accompagné d'un exemplaire de cette licence;\n\n      2  Si le logiciel a été modifié, le licencié doit en faire la mention, de préférence dans chacun des fichiers modifiés dont la nature permet une telle mention;\n\n      3  Les étiquettes ou mentions faisant état des droits d'auteur, des marques de commerce, des garanties ou de la paternité concernant le logiciel ne doivent pas être modifiées ou supprimées, à moins que ces étiquettes ou mentions ne soient inapplicables à un logiciel modifié ou dérivé donné.\n\n   \n\n   5.\n\n   Contributions\n\n   Sous réserve d'une entente distincte, toute contribution soumise par un contributeur au concédant pour inclusion dans le logiciel sera soumise aux termes de cette licence.\n\n   6. Marques de commerce\n\n   La licence n'accorde aucune permission particulière qui permettrait d'utiliser les marques de commerce du concédant, autre que celle requise permettant d'identifier la provenance du logiciel.\n\n   7. Garanties\n\n   Sauf mention contraire, le concédant distribue le logiciel sans aucune garantie, aux risques et périls de l'acquéreur de la copie du logiciel, et ce, sans assurer que le logiciel puisse répondre à un besoin particulier ou puisse donner un résultat quelconque.\n\n   Sans lier le concédant d'une quelconque manière, rien n'empêche un licencié d'offrir ou d'exclure des garanties ou du support.\n\n   8. Responsabilité\n\n   Le licencié est responsable de tout préjudice résultant de l'exercice des droits accordés par la licence.\n\n   Le concédant ne saurait être tenu responsable de dommages subis par le licencié ou par des tiers, pour quelque cause que ce soit en lien avec la licence et les droits qui y sont accordés.\n\n   9. Résiliation\n\n   La présente licence est automatiquement résiliée dès que les droits qui y sont accordés ne sont pas exercés conformément aux termes qui y sont stipulés.\n\n   Toutefois, si le défaut est corrigé dans un délai de 30 jours de sa prise de connaissance par la personne en défaut, et qu'il s'agit du premier défaut, la licence est accordée de nouveau.\n\n   Pour tout défaut subséquent, le consentement exprès du concédant est nécessaire afin que la licence soit accordée de nouveau.\n\n   10. Version de la licence\n\n   Le Centre de services partagés du Québec, ses ayants cause ou toute personne qu'il désigne, peuvent diffuser des versions révisées ou modifiées de cette licence. Chaque version recevra un numéro unique. Si un logiciel est déjà soumis aux termes d'une version spécifique, c'est seulement cette version qui liera les parties à la licence.\n\n   Le concédant peut aussi choisir de concéder la licence sous la version actuelle ou toute version ultérieure, auquel cas le licencié peut choisir sous quelle version la licence lui est accordée.\n\n   11. Divers\n\n   Dans la mesure où le concédant est un ministère, un organisme public ou une personne morale de droit public, créés en vertu d'une loi de l'Assemblée nationale du Québec, la licence est régie par le droit applicable au Québec et en cas de contestation, les tribunaux du Québec seront seuls compétents.\n\n   La présente licence peut être distribuée sans conditions particulières. Toutefois, une version modifiée doit être distribuée sous un nom différent. Toute référence au Centre de services partagés du Québec, et, le cas échéant, ses ayant cause, doit être retirée, autre que celle permettant d'identifier la provenance de la licence."],"licenseIds":["LiLiQ-P-1.1"],"keywords":["liliq p version","p version 1","liliq p ci","p ci apr","partie importante 4","importante 4 sous","4 sous licencier","sous licencier sous","licencier sous une","sous une autre","une autre licence","autre licence libre","source initiative cette","initiative cette licence","riv donn 5","donn 5 contributions","tenu responsable de","responsable de dommages","de dommages subis","dommages subis par","licence est automatiquement","est automatiquement r","automatiquement r sili","sili e d","e d s","permissive liliq p version","liliq p version 1","p version 1 1","permissive liliq p ci","liliq p ci apr","p ci apr s","une partie importante 4","partie importante 4 sous","importante 4 sous licencier","4 sous licencier sous","sous licencier sous une","licencier sous une autre","sous une autre licence","une autre licence libre","autre licence libre approuv","open source initiative cette","source initiative cette licence","initiative cette licence est","d riv donn 5","riv donn 5 contributions","donn 5 contributions sous","tre tenu responsable de","tenu responsable de dommages","responsable de dommages subis","de dommages subis par","dommages subis par le","sente licence est automatiquement","licence est automatiquement r","est automatiquement r sili","automatiquement r sili e","r sili e d","sili e d s","e d s que","bec permissive liliq p version","permissive liliq p version 1","liliq p version 1 1","p version 1 1 1","bec permissive liliq p ci","permissive liliq p ci apr","liliq p ci apr s","p ci apr s appel","ou une partie importante 4","une partie importante 4 sous","partie importante 4 sous licencier","importante 4 sous licencier sous","4 sous licencier sous une","sous licencier sous une autre","licencier sous une autre licence","sous une autre licence libre","une autre licence libre approuv","autre licence libre approuv e","l open source initiative cette","open source initiative cette licence","source initiative cette licence est","initiative cette licence est accord","ou d riv donn 5","d riv donn 5 contributions","riv donn 5 contributions sous","donn 5 contributions sous r","saurait tre tenu responsable de","tre tenu responsable de dommages","tenu responsable de dommages subis","responsable de dommages subis par","de dommages subis par le","dommages subis par le licenci","subis par le licenci ou","pr sente licence est automatiquement","sente licence est automatiquement r","licence est automatiquement r sili","est automatiquement r sili e","automatiquement r sili e d","r sili e d s","sili e d s que","e d s que les"]},{"licenseTexts":["Licence Libre du Québec – Réciprocité (LiLiQ-R)\n\nVersion 1.1\n\n   1. Préambule\n\n   Cette licence s'applique à tout logiciel distribué dont le titulaire du droit d'auteur précise qu'il est sujet aux termes de la Licence Libre du Québec – Réciprocité (LiLiQ-R) (ci-après appelée la « licence »).\n\n   2. Définitions\n\n   Dans la présente licence, à moins que le contexte n'indique un sens différent, on entend par:\n\n   « concédant » : le titulaire du droit d'auteur sur le logiciel, ou toute personne dûment autorisée par ce dernier à accorder la présente licence;\n\n   « contributeur » : le titulaire du droit d'auteur ou toute personne autorisée par ce dernier à soumettre au concédant une contribution. Un contributeur dont sa contribution est incorporée au logiciel est considéré comme un concédant en regard de sa contribution;\n\n   « contribution » : tout logiciel original, ou partie de logiciel original soumis et destiné à être incorporé dans le logiciel;\n\n   « distribution » : le fait de délivrer une copie du logiciel;\n\n   « licencié » : toute personne qui possède une copie du logiciel et qui exerce les droits concédés par la licence;\n\n   « logiciel » : une œuvre protégée par le droit d'auteur, telle qu'un programme d'ordinateur et sa documentation, pour laquelle le titulaire du droit d'auteur a précisé qu'elle est sujette aux termes de la présente licence;\n\n   « logiciel dérivé » : tout logiciel original réalisé par un licencié, autre que le logiciel ou un logiciel modifié, qui produit ou reproduit la totalité ou une partie importante du logiciel;\n\n   « logiciel modifié » : toute modification par un licencié de l'un des fichiers source du logiciel ou encore tout nouveau fichier source qui incorpore le logiciel ou une partie importante de ce dernier.\n\n   3. Licence de droit d'auteur\n\n   Sous réserve des termes de la licence, le concédant accorde au licencié une licence non exclusive et libre de redevances lui permettant d'exercer les droits suivants sur le logiciel :\n\n      1  Produire ou reproduire la totalité ou une partie importante;\n\n      2  Exécuter ou représenter la totalité ou une partie importante en public;\n\n      3  Publier la totalité ou une partie importante.\n\n   \n\n   Cette licence est accordée sans limite territoriale et sans limite de temps.\n\n   L'exercice complet de ces droits est sujet à la distribution par le concédant du code source du logiciel, lequel doit être sous une forme permettant d'y apporter des modifications. Le concédant peut aussi distribuer le logiciel accompagné d'une offre de distribuer le code source du logiciel, sans frais supplémentaires, autres que ceux raisonnables afin de permettre la livraison du code source. Cette offre doit être valide pendant une durée raisonnable.\n\n   4. Distribution\n\n   Le licencié peut distribuer des copies du logiciel, d'un logiciel modifié ou dérivé, sous réserve de respecter les conditions suivantes :\n\n      1  Le logiciel doit être accompagné d'un exemplaire de cette licence;\n\n      2  Si le logiciel a été modifié, le licencié doit en faire la mention, de préférence dans chacun des fichiers modifiés dont la nature permet une telle mention;\n\n      3  Les étiquettes ou mentions faisant état des droits d'auteur, des marques de commerce, des garanties ou de la paternité concernant le logiciel ne doivent pas être modifiées ou supprimées, à moins que ces étiquettes ou mentions ne soient inapplicables à un logiciel modifié ou dérivé donné.\n\n   4.1. Réciprocité\n\n   Chaque fois que le licencié distribue le logiciel, le concédant offre au récipiendaire une concession sur le logiciel selon les termes de la présente licence. Le licencié doit offrir une concession selon les termes de la présente licence pour tout logiciel modifié qu'il distribue.\n\n   Chaque fois que le licencié distribue le logiciel ou un logiciel modifié, ce dernier doit assumer l'obligation d'en distribuer le code source, de la manière prévue au troisième alinéa de l'article 3.\n\n   4.2. Compatibilité\n\n   Dans la mesure où le licencié souhaite distribuer un logiciel modifié combiné à un logiciel assujetti à une licence compatible, mais dont il ne serait pas possible d'en respecter les termes, le concédant offre, en plus de la présente concession, une concession selon les termes de cette licence compatible.\n\n   Un licencié qui est titulaire exclusif du droit d'auteur sur le logiciel assujetti à une licence compatible ne peut pas se prévaloir de cette offre. Il en est de même pour toute autre personne dûment autorisée à sous-licencier par le titulaire exclusif du droit d'auteur sur le logiciel assujetti à une licence compatible.\n\n   Est considérée comme une licence compatible toute licence libre approuvée ou certifiée par la Free Software Foundation ou l'Open Source Initiative, dont le niveau de réciprocité est comparable ou supérieur à celui de la présente licence, sans toutefois être moindre, notamment :\n\n      1  Common Development and Distribution License (CDDL-1.0)\n\n      2  Common Public License Version 1.0 (CPL-1.0)\n\n      3  Contrat de licence de logiciel libre CeCILL, version 2.1 (CECILL-2.1)\n\n      4  Contrat de licence de logiciel libre CeCILL-C (CECILL-C)\n\n      5  Eclipse Public License - v 1.0 (EPL-1.0)\n\n      6  European Union Public License, version 1.1 (EUPL v. 1.1)\n\n      7  Licence Libre du Québec – Réciprocité forte version 1.1 (LiLiQ-R+ 1.1)\n\n      8  GNU General Public License Version 2 (GNU GPLv2)\n\n      9  GNU General Public License Version 3 (GNU GPLv3)\n\n      10  GNU Lesser General Public License Version 2.1 (GNU LGPLv2.1)\n\n      11  GNU Lesser General Public License Version 3 (GNU LGPLv3)\n\n      12  Mozilla Public License Version 2.0 (MPL-2.0)\n\n   5. Contributions\n\n   Sous réserve d'une entente distincte, toute contribution soumise par un contributeur au concédant pour inclusion dans le logiciel sera soumise aux termes de cette licence.\n\n   6. Marques de commerce\n\n   La licence n'accorde aucune permission particulière qui permettrait d'utiliser les marques de commerce du concédant, autre que celle requise permettant d'identifier la provenance du logiciel.\n\n   7. Garanties\n\n   Sauf mention contraire, le concédant distribue le logiciel sans aucune garantie, aux risques et périls de l'acquéreur de la copie du logiciel, et ce, sans assurer que le logiciel puisse répondre à un besoin particulier ou puisse donner un résultat quelconque.\n\n   Sans lier le concédant d'une quelconque manière, rien n'empêche un licencié d'offrir ou d'exclure des garanties ou du support.\n\n   8. Responsabilité\n\n   Le licencié est responsable de tout préjudice résultant de l'exercice des droits accordés par la licence.\n\n   Le concédant ne saurait être tenu responsable du préjudice subi par le licencié ou par des tiers, pour quelque cause que ce soit en lien avec la licence et les droits qui y sont accordés.\n\n   9. Résiliation\n\n   La présente licence est résiliée de plein droit dès que les droits qui y sont accordés ne sont pas exercés conformément aux termes qui y sont stipulés.\n\n   Toutefois, si le défaut est corrigé dans un délai de 30 jours de sa prise de connaissance par la personne en défaut, et qu'il s'agit du premier défaut, la licence est accordée de nouveau.\n\n   Pour tout défaut subséquent, le consentement exprès du concédant est nécessaire afin que la licence soit accordée de nouveau.\n\n   10. Version de la licence\n\n   Le Centre de services partagés du Québec, ses ayants cause ou toute personne qu'il désigne, peuvent diffuser des versions révisées ou modifiées de cette licence. Chaque version recevra un numéro unique. Si un logiciel est déjà soumis aux termes d'une version spécifique, c'est seulement cette version qui liera les parties à la licence.\n\n   Le concédant peut aussi choisir de concéder la licence sous la version actuelle ou toute version ultérieure, auquel cas le licencié peut choisir sous quelle version la licence lui est accordée.\n\n   11. Divers\n\n   Dans la mesure où le concédant est un ministère, un organisme public ou une personne morale de droit public, créés en vertu d'une loi de l'Assemblée nationale du Québec, la licence est régie par le droit applicable au Québec et en cas de contestation, les tribunaux du Québec seront seuls compétents.\n\n   La présente licence peut être distribuée sans conditions particulières. Toutefois, une version modifiée doit être distribuée sous un nom différent. Toute référence au Centre de services partagés du Québec, et, le cas échéant, ses ayant droit, doit être retirée, autre que celle permettant d'identifier la provenance de la licence."],"licenseIds":["LiLiQ-R-1.1"],"keywords":["logiciel modifi qu","modifi qu il","logiciel modifi ce","modifi ce dernier","logiciel modifi combin","modifi combin un","est comparable ou","comparable ou sup","ou sup rieur","sup rieur celui","rieur celui de","1 common development","license cddl 1","cddl 1 0","0 2 common","2 common public","1 0 3","0 3 contrat","3 contrat de","2 1 4","1 4 contrat","4 contrat de","libre cecill c","cecill c cecill","c cecill c","cecill c 5","c 5 eclipse","5 eclipse public","0 6 european","6 european union","1 1 7","1 7 licence","7 licence libre","ciprocit forte version","forte version 1","1 1 liliq","1 liliq r","liliq r 1","r 1 1","1 1 8","1 8 gnu","8 gnu general","gnu gplv2 9","gplv2 9 gnu","9 gnu general","gnu gplv3 10","gplv3 10 gnu","10 gnu lesser","2 1 gnu","1 gnu lgplv2","gnu lgplv2 1","lgplv2 1 11","1 11 gnu","11 gnu lesser","3 gnu lgplv3","gnu lgplv3 12","lgplv3 12 mozilla","12 mozilla public","2 0 mpl","0 mpl 2","2 0 5","0 5 contributions","ses ayant droit","ayant droit doit","droit doit tre","ciprocit liliq r version","ciprocit liliq r ci","tout logiciel modifi qu","logiciel modifi qu il","modifi qu il distribue","distribue le logiciel ou","un logiciel modifi ce","logiciel modifi ce dernier","modifi ce dernier doit","un logiciel modifi combin","logiciel modifi combin un","modifi combin un logiciel","ciprocit est comparable ou","est comparable ou sup","comparable ou sup rieur","ou sup rieur celui","sup rieur celui de","rieur celui de la","notamment 1 common development","1 common development and","distribution license cddl 1","license cddl 1 0","cddl 1 0 2","1 0 2 common","0 2 common public","2 common public license","cpl 1 0 3","1 0 3 contrat","0 3 contrat de","3 contrat de licence","cecill 2 1 4","2 1 4 contrat","1 4 contrat de","4 contrat de licence","logiciel libre cecill c","libre cecill c cecill","cecill c cecill c","c cecill c 5","cecill c 5 eclipse","c 5 eclipse public","5 eclipse public license","epl 1 0 6","1 0 6 european","0 6 european union","6 european union public","v 1 1 7","1 1 7 licence","1 7 licence libre","7 licence libre du","r ciprocit forte version","ciprocit forte version 1","forte version 1 1","version 1 1 liliq","1 1 liliq r","1 liliq r 1","liliq r 1 1","r 1 1 8","1 1 8 gnu","1 8 gnu general","8 gnu general public","2 gnu gplv2 9","gnu gplv2 9 gnu","gplv2 9 gnu general","9 gnu general public","3 gnu gplv3 10","gnu gplv3 10 gnu","gplv3 10 gnu lesser","10 gnu lesser general","version 2 1 gnu","2 1 gnu lgplv2","1 gnu lgplv2 1","gnu lgplv2 1 11","lgplv2 1 11 gnu","1 11 gnu lesser","11 gnu lesser general","version 3 gnu lgplv3","3 gnu lgplv3 12","gnu lgplv3 12 mozilla","lgplv3 12 mozilla public","12 mozilla public license","version 2 0 mpl","2 0 mpl 2","0 mpl 2 0","mpl 2 0 5","2 0 5 contributions","0 5 contributions sous","ant ses ayant droit","ses ayant droit doit","ayant droit doit tre","droit doit tre retir","r ciprocit liliq r version","ciprocit liliq r version 1","r ciprocit liliq r ci","ciprocit liliq r ci apr","pour tout logiciel modifi qu","tout logiciel modifi qu il","logiciel modifi qu il distribue","modifi qu il distribue chaque","licenci distribue le logiciel ou","distribue le logiciel ou un","ou un logiciel modifi ce","un logiciel modifi ce dernier","logiciel modifi ce dernier doit","modifi ce dernier doit assumer","distribuer un logiciel modifi combin","un logiciel modifi combin un","logiciel modifi combin un logiciel","modifi combin un logiciel assujetti","r ciprocit est comparable ou","ciprocit est comparable ou sup","est comparable ou sup rieur","comparable ou sup rieur celui","ou sup rieur celui de","sup rieur celui de la","rieur celui de la pr","moindre notamment 1 common development","notamment 1 common development and","1 common development and distribution","and distribution license cddl 1","distribution license cddl 1 0","license cddl 1 0 2","cddl 1 0 2 common","1 0 2 common public","0 2 common public license","2 common public license version","0 cpl 1 0 3","cpl 1 0 3 contrat","1 0 3 contrat de","0 3 contrat de licence","3 contrat de licence de","1 cecill 2 1 4","cecill 2 1 4 contrat","2 1 4 contrat de","1 4 contrat de licence","4 contrat de licence de"]},{"licenseTexts":["Licence Libre du Québec – Réciprocité forte (LiLiQ-R+)\n\nVersion 1.1\n\n   1. Préambule\n\n   Cette licence s'applique à tout logiciel distribué dont le titulaire du droit d'auteur précise qu'il est sujet aux termes de la Licence Libre du Québec – Réciprocité forte (LiLiQ-R+) (ci-après appelée la « licence »).\n\n   2. Définitions\n\n   Dans la présente licence, à moins que le contexte n'indique un sens différent, on entend par:\n\n   « concédant » : le titulaire du droit d'auteur sur le logiciel, ou toute personne dûment autorisée par ce dernier à accorder la présente licence;\n\n   « contributeur » : le titulaire du droit d'auteur ou toute personne autorisée par ce dernier à soumettre au concédant une contribution. Un contributeur dont sa contribution est incorporée au logiciel est considéré comme un concédant en regard de sa contribution;\n\n   « contribution » : tout logiciel original, ou partie de logiciel original soumis et destiné à être incorporé dans le logiciel;\n\n   « distribution » : le fait de délivrer une copie du logiciel;\n\n   « licencié » : toute personne qui possède une copie du logiciel et qui exerce les droits concédés par la licence;\n\n   « logiciel » : une œuvre protégée par le droit d'auteur, telle qu'un programme d'ordinateur et sa documentation, pour laquelle le titulaire du droit d'auteur a précisé qu'elle est sujette aux termes de la présente licence;\n\n   « logiciel dérivé » : tout logiciel original réalisé par un licencié, autre que le logiciel ou un logiciel modifié, qui produit ou reproduit la totalité ou une partie importante du logiciel;\n\n   « logiciel modifié » : toute modification par un licencié de l'un des fichiers source du logiciel ou encore tout nouveau fichier source qui incorpore le logiciel ou une partie importante de ce dernier.\n\n   3. Licence de droit d'auteur\n\n   Sous réserve des termes de la licence, le concédant accorde au licencié une licence non exclusive et libre de redevances lui permettant d'exercer les droits suivants sur le logiciel:\n\n      1 Produire ou reproduire la totalité ou une partie importante;\n\n      2 Exécuter ou représenter la totalité ou une partie importante en public;\n\n      3 Publier la totalité ou une partie importante.\n\n   Cette licence est accordée sans limite territoriale et sans limite de temps.\n\n   L'exercice complet de ces droits est sujet à la distribution par le concédant du code source du logiciel, lequel doit être sous une forme permettant d'y apporter des modifications. Le concédant peut aussi distribuer le logiciel accompagné d'une offre de distribuer le code source du logiciel, sans frais supplémentaires, autres que ceux raisonnables afin de permettre la livraison du code source. Cette offre doit être valide pendant une durée raisonnable.\n\n   4. Distribution\n\n   Le licencié peut distribuer des copies du logiciel, d'un logiciel modifié ou dérivé, sous réserve de respecter les conditions suivantes :\n\n      1 Le logiciel doit être accompagné d'un exemplaire de cette licence;\n\n      2 Si le logiciel a été modifié, le licencié doit en faire la mention, de préférence dans chacun des fichiers modifiés dont la nature permet une telle mention;\n\n      3 Les étiquettes ou mentions faisant état des droits d'auteur, des marques de commerce, des garanties ou de la paternité concernant le logiciel ne doivent pas être modifiées ou supprimées, à moins que ces étiquettes ou mentions ne soient inapplicables à un logiciel modifié ou dérivé donné.\n\n   4.1. Réciprocité\n\n   Chaque fois que le licencié distribue le logiciel, le concédant offre au récipiendaire une concession sur le logiciel selon les termes de la présente licence. Le licencié doit offrir une concession selon les termes de la présente licence pour tout logiciel modifié ou dérivé qu'il distribue.\n\n   Chaque fois que le licencié distribue le logiciel, un logiciel modifié, ou un logiciel dérivé, ce dernier doit assumer l'obligation d'en distribuer le code source, de la manière prévue au troisième alinéa de l'article 3.\n\n   4.2. Compatibilité\n\n   Dans la mesure où le licencié souhaite distribuer un logiciel modifié ou dérivé combiné à un logiciel assujetti à une licence compatible, mais dont il ne serait pas possible d'en respecter les termes, le concédant offre, en plus de la présente concession, une concession selon les termes de cette licence compatible.\n\n   Un licencié qui est titulaire exclusif du droit d'auteur sur le logiciel assujetti à une licence compatible ne peut pas se prévaloir de cette offre. Il en est de même pour toute autre personne dûment autorisée à sous-licencier par le titulaire exclusif du droit d'auteur sur le logiciel assujetti à une licence compatible.\n\n   Est considérée comme une licence compatible toute licence libre approuvée ou certifiée par la Free Software Foundation ou l'Open Source Initiative, dont le niveau de réciprocité est comparable à celui de la présente licence, sans toutefois être moindre, notamment:\n\n      1 Common Public License Version 1.0 (CPL-1.0)\n\n      2 Contrat de licence de logiciel libre CeCILL, version 2.1 (CECILL-2.1)\n\n      3 Eclipse Public License - v 1.0 (EPL-1.0)\n\n      4 European Union Public License, version 1.1 (EUPL v. 1.1)\n\n      5 GNU General Public License Version 2 (GNU GPLv2)\n\n      6 GNU General Public License Version 3 (GNU GPLv3)\n\n   5. Contributions\n\n   Sous réserve d'une entente distincte, toute contribution soumise par un contributeur au concédant pour inclusion dans le logiciel sera soumise aux termes de cette licence.\n\n   6. Marques de commerce\n\n   La licence n'accorde aucune permission particulière qui permettrait d'utiliser les marques de commerce du concédant, autre que celle requise permettant d'identifier la provenance du logiciel.\n\n   7. Garanties\n\n   Sauf mention contraire, le concédant distribue le logiciel sans aucune garantie, aux risques et périls de l'acquéreur de la copie du logiciel, et ce, sans assurer que le logiciel puisse répondre à un besoin particulier ou puisse donner un résultat quelconque.\n\n   Sans lier le concédant d'une quelconque manière, rien n'empêche un licencié d'offrir ou d'exclure des garanties ou du support.\n\n   8. Responsabilité\n\n   Le licencié est responsable de tout préjudice résultant de l'exercice des droits accordés par la licence.\n\n   Le concédant ne saurait être tenu responsable du préjudice subi par le licencié ou par des tiers, pour quelque cause que ce soit en lien avec la licence et les droits qui y sont accordés.\n\n   9. Résiliation\n\n   La présente licence est résiliée de plein droit dès que les droits qui y sont accordés ne sont pas exercés conformément aux termes qui y sont stipulés.\n\n   Toutefois, si le défaut est corrigé dans un délai de 30 jours de sa prise de connaissance par la personne en défaut, et qu'il s'agit du premier défaut, la licence est accordée de nouveau.\n\n   Pour tout défaut subséquent, le consentement exprès du concédant est nécessaire afin que la licence soit accordée de nouveau.\n\n   10. Version de la licence\n\n   Le Centre de services partagés du Québec, ses ayants cause ou toute personne qu'il désigne, peuvent diffuser des versions révisées ou modifiées de cette licence. Chaque version recevra un numéro unique. Si un logiciel est déjà soumis aux termes d'une version spécifique, c'est seulement cette version qui liera les parties à la licence.\n\n   Le concédant peut aussi choisir de concéder la licence sous la version actuelle ou toute version ultérieure, auquel cas le licencié peut choisir sous quelle version la licence lui est accordée.\n\n   11. Divers\n\n   Dans la mesure où le concédant est un ministère, un organisme public ou une personne morale de droit public, créés en vertu d'une loi de l'Assemblée nationale du Québec, la licence est régie par le droit applicable au Québec et en cas de contestation, les tribunaux du Québec seront seuls compétents.\n\n   La présente licence peut être distribuée sans conditions particulières. Toutefois, une version modifiée doit être distribuée sous un nom différent. Toute référence au Centre de services partagés du Québec, et, le cas échéant, ses ayant cause, doit être retirée, autre que celle permettant d'identifier la provenance de la licence."],"licenseIds":["LiLiQ-Rplus-1.1"],"keywords":["d riv qu","riv qu il","le logiciel un","logiciel un logiciel","modifi ou un","d riv ce","riv ce dernier","d riv combin","riv combin un","est comparable celui","comparable celui de","1 common public","0 2 contrat","2 contrat de","1 3 eclipse","3 eclipse public","1 0 4","0 4 european","4 european union","1 1 5","1 5 gnu","5 gnu general","gnu gplv2 6","gplv2 6 gnu","6 gnu general","gnu gplv3 5","gplv3 5 contributions","forte liliq r version","forte liliq r ci","tout logiciel modifi ou","ou d riv qu","d riv qu il","riv qu il distribue","distribue le logiciel un","le logiciel un logiciel","logiciel un logiciel modifi","logiciel modifi ou un","modifi ou un logiciel","ou un logiciel d","un logiciel d riv","logiciel d riv ce","d riv ce dernier","riv ce dernier doit","ou d riv combin","d riv combin un","riv combin un logiciel","ciprocit est comparable celui","est comparable celui de","comparable celui de la","notamment 1 common public","1 common public license","cpl 1 0 2","1 0 2 contrat","0 2 contrat de","2 contrat de licence","cecill 2 1 3","2 1 3 eclipse","1 3 eclipse public","3 eclipse public license","epl 1 0 4","1 0 4 european","0 4 european union","4 european union public","v 1 1 5","1 1 5 gnu","1 5 gnu general","5 gnu general public","2 gnu gplv2 6","gnu gplv2 6 gnu","gplv2 6 gnu general","6 gnu general public","3 gnu gplv3 5","gnu gplv3 5 contributions","gplv3 5 contributions sous","ciprocit forte liliq r version","forte liliq r version 1","ciprocit forte liliq r ci","forte liliq r ci apr","pour tout logiciel modifi ou","tout logiciel modifi ou d","modifi ou d riv qu","ou d riv qu il","d riv qu il distribue","riv qu il distribue chaque","licenci distribue le logiciel un","distribue le logiciel un logiciel","le logiciel un logiciel modifi","logiciel un logiciel modifi ou","un logiciel modifi ou un","logiciel modifi ou un logiciel","modifi ou un logiciel d","ou un logiciel d riv","un logiciel d riv ce","logiciel d riv ce dernier","d riv ce dernier doit","riv ce dernier doit assumer","distribuer un logiciel modifi ou","modifi ou d riv combin","ou d riv combin un","d riv combin un logiciel","riv combin un logiciel assujetti","r ciprocit est comparable celui","ciprocit est comparable celui de","est comparable celui de la","comparable celui de la pr","moindre notamment 1 common public","notamment 1 common public license","1 common public license version","0 cpl 1 0 2","cpl 1 0 2 contrat","1 0 2 contrat de","0 2 contrat de licence","2 contrat de licence de","1 cecill 2 1 3","cecill 2 1 3 eclipse","2 1 3 eclipse public","1 3 eclipse public license","3 eclipse public license v","0 epl 1 0 4","epl 1 0 4 european","1 0 4 european union","0 4 european union public","4 european union public license","eupl v 1 1 5","v 1 1 5 gnu","1 1 5 gnu general","1 5 gnu general public","5 gnu general public license","version 2 gnu gplv2 6","2 gnu gplv2 6 gnu","gnu gplv2 6 gnu general","gplv2 6 gnu general public","6 gnu general public license","version 3 gnu gplv3 5","3 gnu gplv3 5 contributions","gnu gplv3 5 contributions sous","gplv3 5 contributions sous r"]},{"licenseTexts":["This copy of the libpng notices is provided for your convenience. In case of any discrepancy between this copy and the notices in the file png.h that is included in the libpng distribution, the latter shall prevail.\n\nCOPYRIGHT NOTICE, DISCLAIMER, and LICENSE:\n\nIf you modify libpng you may insert additional notices immediately following this sentence.\n\nThis code is released under the libpng license.\n\nlibpng versions 1.2.6, August 15, 2004, through 1.4.5, December 9, 2010, are Copyright (c) 2004, 2006-2010 Glenn Randers-Pehrson, and are distributed according to the same disclaimer and license as libpng-1.2.5 with the following individual added to the list of Contributing Authors\n\nCosmin Truta\n\nlibpng versions 1.0.7, July 1, 2000, through 1.2.5 - October 3, 2002, are\n\nCopyright (c) 2000-2002 Glenn Randers-Pehrson, and are distributed according to the same disclaimer and license as libpng-1.0.6 with the following individuals added to the list of Contributing Authors\n\nSimon-Pierre Cadieux\n\nEric S. Raymond\n\nGilles Vollant\n\nand with the following additions to the disclaimer:\n\nThere is no warranty against interference with your enjoyment of the library or against infringement. There is no warranty that our efforts or the library will fulfill any of your particular purposes or needs. This library is provided with all faults, and the entire risk of satisfactory quality, performance, accuracy, and effort is with the user.\n\nlibpng versions 0.97, January 1998, through 1.0.6, March 20, 2000, are\n\nCopyright (c) 1998, 1999 Glenn Randers-Pehrson, and are distributed according to the same disclaimer and license as libpng-0.96, with the following individuals added to the list of Contributing Authors:\n\nTom Lane\n\nGlenn Randers-Pehrson\n\nWillem van Schaik\n\nlibpng versions 0.89, June 1996, through 0.96, May 1997, are\n\nCopyright (c) 1996, 1997 Andreas Digger\n\nDistributed according to the same disclaimer and license as libpng-0.88, with the following individuals added to the list of Contributing Authors:\n\nJohn Bowler\n\nKevin Bracey\n\nSam Bushell\n\nMagnus Holmgren\n\nGreg Roelofs\n\nTom Tanner\n\nlibpng versions 0.5, May 1995, through 0.88, January 1996, are\n\nCopyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.\n\nFor the purposes of this copyright and license, \"Contributing Authors\" is defined as the following set of individuals:\n\nAndreas Dilger\n\nDave Martindale\n\nGuy Eric Schalnat\n\nPaul Schmidt\n\nTim Wegner\n\nThe PNG Reference Library is supplied \"AS IS\". The Contributing Authors and Group 42, Inc. disclaim all warranties, expressed or implied, including, without limitation, the warranties of merchantability and of fitness for any purpose. The Contributing Authors and Group 42, Inc. assume no liability for direct, indirect, incidental, special, exemplary, or consequential damages, which may result from the use of the PNG Reference Library, even if advised of the possibility of such damage.\n\nPermission is hereby granted to use, copy, modify, and distribute this source code, or portions hereof, for any purpose, without fee, subject to the following restrictions:\n\n   1. The origin of this source code must not be misrepresented.\n\n   2. Altered versions must be plainly marked as such and must not be misrepresented as being the original source.\n\n   3. This Copyright notice may not be removed or altered from any source or altered source distribution.\n\nThe Contributing Authors and Group 42, Inc. specifically permit, without fee, and encourage the use of this source code as a component to supporting the PNG file format in commercial products. If you use this source code in a product, acknowledgment is not required but would be appreciated.\n\nA \"png_get_copyright\" function is available, for convenient use in \"about\" boxes and the like:\n\nprintf(\"%s\",png_get_copyright(NULL));\n\nAlso, the PNG logo (in PNG format, of course) is supplied in the files \"pngbar.png\" and \"pngbar.jpg (88x31) and \"pngnow.png\" (98x31).\n\nLibpng is OSI Certified Open Source Software. OSI Certified Open Source is a certification mark of the Open Source Initiative.\n\nGlenn Randers-Pehrson\n\nglennrp at users.sourceforge.net\n\nDecember 9, 2010"],"licenseIds":["Libpng"],"keywords":["this copy of","of the libpng","the libpng notices","libpng notices is","notices is provided","provided for your","convenience in case","of any discrepancy","any discrepancy between","discrepancy between this","between this copy","this copy and","copy and the","and the notices","the file png","file png h","png h that","h that is","in the libpng","the libpng distribution","libpng distribution the","distribution the latter","the latter shall","latter shall prevail","shall prevail copyright","prevail copyright notice","copyright notice disclaimer","notice disclaimer and","and license if","you modify libpng","modify libpng you","libpng you may","you may insert","may insert additional","insert additional notices","additional notices immediately","notices immediately following","immediately following this","following this sentence","this sentence this","sentence this code","under the libpng","the libpng license","libpng license libpng","license libpng versions","2 6 august","6 august 15","august 15 2004","15 2004 through","2004 through 1","through 1 4","1 4 5","4 5 december","5 december 9","9 2010 are","2010 are copyright","c 2004 2006","2004 2006 2010","2006 2010 glenn","2010 glenn randers","libpng 1 2","2 5 with","the following individual","following individual added","individual added to","contributing authors cosmin","authors cosmin truta","cosmin truta libpng","truta libpng versions","versions 1 0","0 7 july","7 july 1","july 1 2000","1 2000 through","2000 through 1","2 5 october","5 october 3","october 3 2002","3 2002 are","2002 are copyright","2000 2002 glenn","2002 glenn randers","libpng 1 0","0 6 with","6 with the","contributing authors simon","authors simon pierre","simon pierre cadieux","pierre cadieux eric","cadieux eric s","eric s raymond","s raymond gilles","raymond gilles vollant","gilles vollant and","vollant and with","the following additions","following additions to","the disclaimer there","disclaimer there is","no warranty against","warranty against interference","library or against","or against infringement","against infringement there","infringement there is","no warranty that","warranty that our","that our efforts","our efforts or","efforts or the","or the library","library will fulfill","will fulfill any","fulfill any of","of your particular","your particular purposes","particular purposes or","purposes or needs","or needs this","needs this library","library is provided","provided with all","all faults and","faults and the","and the entire","entire risk of","risk of satisfactory","satisfactory quality performance","quality performance accuracy","performance accuracy and","accuracy and effort","and effort is","effort is with","is with the","with the user","the user libpng","user libpng versions","versions 0 97","0 97 january","97 january 1998","january 1998 through","1998 through 1","through 1 0","0 6 march","6 march 20","march 20 2000","20 2000 are","2000 are copyright","1998 1999 glenn","1999 glenn randers","libpng 0 96","0 96 with","96 with the","contributing authors tom","authors tom lane","tom lane glenn","lane glenn randers","randers pehrson willem","pehrson willem van","willem van schaik","van schaik libpng","schaik libpng versions","versions 0 89","0 89 june","89 june 1996","june 1996 through","1996 through 0","through 0 96","0 96 may","96 may 1997","may 1997 are","1997 are copyright","1997 andreas digger","andreas digger distributed","digger distributed according","libpng 0 88","0 88 with","88 with the","contributing authors john","authors john bowler","john bowler kevin","bowler kevin bracey","kevin bracey sam","bracey sam bushell","sam bushell magnus","bushell magnus holmgren","magnus holmgren greg","holmgren greg roelofs","greg roelofs tom","roelofs tom tanner","tom tanner libpng","tanner libpng versions","versions 0 5","0 5 may","5 may 1995","may 1995 through","1995 through 0","through 0 88","0 88 january","88 january 1996"]},{"licenseTexts":["Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n   - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE."],"licenseIds":["Linux-OpenIB"],"keywords":["distribution the software","the distribution the software","distribution the software is","with the distribution the software","the distribution the software is","distribution the software is provided"]},{"licenseTexts":["MIT No Attribution Copyright \u003cYEARr\u003e \u003cCOPYRIGHT HOLDER\u003e\n\nPermission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the \"Software\"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE."],"licenseIds":["MIT-0"],"keywords":["no attribution copyright","attribution copyright yearr","copyright yearr copyright","yearr copyright holder","copyright holder permission","holder permission is","mit no attribution copyright","no attribution copyright yearr","attribution copyright yearr copyright","copyright yearr copyright holder","yearr copyright holder permission","copyright holder permission is","holder permission is hereby","mit no attribution copyright yearr","no attribution copyright yearr copyright","attribution copyright yearr copyright holder","copyright yearr copyright holder permission","yearr copyright holder permission is","copyright holder permission is hereby","holder permission is hereby granted"]},{"licenseTexts":["\u003ccopyright notice\u003e By obtaining, using, and/or copying this software and/or its associated documentation, you agree that you have read, understood, and will comply with the following terms and conditions:\n\nPermission to use, copy, modify, and distribute this software and its associated documentation for any purpose and without fee is hereby granted, provided that the above copyright notice appears in all copies, and that both that copyright notice and this permission notice appear in supporting documentation, and that the name of the copyright holder not be used in advertising or publicity pertaining to distribution of the software without specific, written permission.\n\nTHE COPYRIGHT HOLDER DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM THE LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE."],"licenseIds":["MIT-CMU"],"keywords":["copyright notice by","notice by obtaining","copying this software","or its associated","associated documentation you","documentation you agree","associated documentation for","copyright holder not","holder not be","copyright holder disclaim","holder disclaim all","copyright notice by obtaining","notice by obtaining using","or copying this software","copying this software and","this software and or","software and or its","and or its associated","or its associated documentation","its associated documentation you","associated documentation you agree","documentation you agree that","software and its associated","its associated documentation for","associated documentation for any","the copyright holder not","copyright holder not be","holder not be used","specific written permission the","permission the copyright holder","the copyright holder disclaim","copyright holder disclaim all","holder disclaim all warranties","copyright notice by obtaining using","notice by obtaining using and","and or copying this software","or copying this software and","copying this software and or","this software and or its","software and or its associated","and or its associated documentation","or its associated documentation you","its associated documentation you agree","associated documentation you agree that","documentation you agree that you","this software and its associated","software and its associated documentation","and its associated documentation for","its associated documentation for any","associated documentation for any purpose","that the name of the","of the copyright holder not","the copyright holder not be","copyright holder not be used","holder not be used in","without specific written permission the","specific written permission the copyright","written permission the copyright holder","permission the copyright holder disclaim","the copyright holder disclaim all","copyright holder disclaim all warranties","holder disclaim all warranties with"]},{"licenseTexts":["Copyright (C) 2000-2008 Carsten Haitzler, Geoff Harrison and various contributors Copyright (C) 2004-2008 Kim Woelders\n\nPermission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the \"Software\"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all copies of the Software, its documentation and marketing \u0026 publicity materials, and acknowledgment shall be given in the documentation, materials and software packages that this Software was used.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE."],"licenseIds":["MIT-advertising"],"keywords":["c 2000 2008","2000 2008 carsten","2008 carsten haitzler","carsten haitzler geoff","haitzler geoff harrison","geoff harrison and","harrison and various","various contributors copyright","contributors copyright c","c 2004 2008","2004 2008 kim","2008 kim woelders","kim woelders permission","woelders permission is","documentation and marketing","and marketing publicity","marketing publicity materials","publicity materials and","materials and acknowledgment","the documentation materials","documentation materials and","materials and software","copyright c 2000 2008","c 2000 2008 carsten","2000 2008 carsten haitzler","2008 carsten haitzler geoff","carsten haitzler geoff harrison","haitzler geoff harrison and","geoff harrison and various","harrison and various contributors","and various contributors copyright","various contributors copyright c","contributors copyright c 2004","copyright c 2004 2008","c 2004 2008 kim","2004 2008 kim woelders","2008 kim woelders permission","kim woelders permission is","woelders permission is hereby","the software its documentation","software its documentation and","its documentation and marketing","documentation and marketing publicity","and marketing publicity materials","marketing publicity materials and","publicity materials and acknowledgment","materials and acknowledgment shall","in the documentation materials","the documentation materials and","documentation materials and software","materials and software packages","copyright c 2000 2008 carsten","c 2000 2008 carsten haitzler","2000 2008 carsten haitzler geoff","2008 carsten haitzler geoff harrison","carsten haitzler geoff harrison and","haitzler geoff harrison and various","geoff harrison and various contributors","harrison and various contributors copyright","and various contributors copyright c","various contributors copyright c 2004","contributors copyright c 2004 2008","copyright c 2004 2008 kim","c 2004 2008 kim woelders","2004 2008 kim woelders permission","2008 kim woelders permission is","kim woelders permission is hereby","woelders permission is hereby granted","copies of the software its","of the software its documentation","the software its documentation and","software its documentation and marketing","its documentation and marketing publicity","documentation and marketing publicity materials","and marketing publicity materials and","marketing publicity materials and acknowledgment","publicity materials and acknowledgment shall","materials and acknowledgment shall be","given in the documentation materials","in the documentation materials and","the documentation materials and software","documentation materials and software packages","materials and software packages that"]},{"licenseTexts":["Copyright (C) 2000 Carsten Haitzler and various contributors (see AUTHORS)\n\nPermission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the \"Software\"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all copies of the Software and its Copyright notices. In addition publicly documented acknowledgment must be given that this software has been used if no source code of this software is made available publicly. This includes acknowledgments in either Copyright notices, Manuals, Publicity and Marketing documents or any documentation provided with any product containing this software. This License does not apply to any software that links to the libraries provided by this software (statically or dynamically), but only to the software provided.\n\nPlease see the COPYING.PLAIN for a plain-english explanation of this notice and it's intent.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE."],"licenseIds":["MIT-enna"],"keywords":["c 2000 carsten","2000 carsten haitzler","carsten haitzler and","haitzler and various","various contributors see","contributors see authors","see authors permission","authors permission is","available publicly this","publicly this includes","this includes acknowledgments","includes acknowledgments in","acknowledgments in either","notice and it","and it s","it s intent","s intent the","copyright c 2000 carsten","c 2000 carsten haitzler","2000 carsten haitzler and","carsten haitzler and various","haitzler and various contributors","and various contributors see","various contributors see authors","contributors see authors permission","see authors permission is","authors permission is hereby","made available publicly this","available publicly this includes","publicly this includes acknowledgments","this includes acknowledgments in","includes acknowledgments in either","acknowledgments in either copyright","this notice and it","notice and it s","and it s intent","it s intent the","s intent the software","copyright c 2000 carsten haitzler","c 2000 carsten haitzler and","2000 carsten haitzler and various","carsten haitzler and various contributors","haitzler and various contributors see","and various contributors see authors","various contributors see authors permission","contributors see authors permission is","see authors permission is hereby","authors permission is hereby granted","is made available publicly this","made available publicly this includes","available publicly this includes acknowledgments","publicly this includes acknowledgments in","this includes acknowledgments in either","includes acknowledgments in either copyright","acknowledgments in either copyright notices","of this notice and it","this notice and it s","notice and it s intent","and it s intent the","it s intent the software","s intent the software is"]},{"licenseTexts":["Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the \"Software\"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all copies of the Software and its documentation and acknowledgment shall be given in the documentation and software packages that this Software was used.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE."],"licenseIds":["MIT-feh"],"keywords":["documentation and acknowledgment","and its documentation and","its documentation and acknowledgment","documentation and acknowledgment shall","documentation and software packages","software and its documentation and","and its documentation and acknowledgment","its documentation and acknowledgment shall","documentation and acknowledgment shall be","given in the documentation and","in the documentation and software","the documentation and software packages","documentation and software packages that"]},{"licenseTexts":["MIT License Copyright (c) \u003cyear\u003e \u003ccopyright holders\u003e\n\nPermission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the \"Software\"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice (including the next paragraph) shall be included in all copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE."," The MIT License (MIT)\n\nCopyright (c) 2015 \n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in\nall copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\nTHE SOFTWARE."," MIT License\n\nCopyright (c) 2018 Ben Boyter\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.","MIT No Attribution\n\nPermission is hereby granted, free of charge, to any person obtaining a copy of this\nsoftware and associated documentation files (the \"Software\"), to deal in the Software\nwithout restriction, including without limitation the rights to use, copy, modify,\nmerge, publish, distribute, sublicense, and/or sell copies of the Software, and to\npermit persons to whom the Software is furnished to do so.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,\nINCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A\nPARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT\nHOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION\nOF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE\nSOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE."],"licenseIds":["MIT"],"keywords":["copyright holders permission","holders permission is","permission notice including","including the next","the next paragraph","next paragraph shall","paragraph shall be","year copyright holders permission","copyright holders permission is","holders permission is hereby","this permission notice including","permission notice including the","notice including the next","including the next paragraph","the next paragraph shall","next paragraph shall be","paragraph shall be included","mit license copyright c year","c year copyright holders permission","year copyright holders permission is","copyright holders permission is hereby","holders permission is hereby granted","and this permission notice including","this permission notice including the","permission notice including the next","notice including the next paragraph","including the next paragraph shall","the next paragraph shall be","next paragraph shall be included","paragraph shall be included in","mit license mit","license mit copyright","mit copyright c","copyright c 2015","c 2015 permission","2015 permission is","the mit license mit","mit license mit copyright","license mit copyright c","mit copyright c 2015","copyright c 2015 permission","c 2015 permission is","2015 permission is hereby","the mit license mit copyright","mit license mit copyright c","license mit copyright c 2015","mit copyright c 2015 permission","copyright c 2015 permission is","c 2015 permission is hereby","2015 permission is hereby granted","c 2018 ben","2018 ben boyter","ben boyter permission","boyter permission is","license copyright c 2018","copyright c 2018 ben","c 2018 ben boyter","2018 ben boyter permission","ben boyter permission is","boyter permission is hereby","mit license copyright c 2018","license copyright c 2018 ben","copyright c 2018 ben boyter","c 2018 ben boyter permission","2018 ben boyter permission is","ben boyter permission is hereby","boyter permission is hereby granted","no attribution permission","attribution permission is","mit no attribution permission","no attribution permission is","attribution permission is hereby","mit no attribution permission is","no attribution permission is hereby","attribution permission is hereby granted"]},{"licenseTexts":["Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the \"Software\"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.\n\nDistributions of all or part of the Software intended to be used by the recipients as they would use the unmodified Software, containing modifications that substantially alter, remove, or disable functionality of the Software, outside of the documented configuration mechanisms provided by the Software, shall be modified such that the Original Author's bug reporting email addresses and urls are either replaced with the contact information of the parties responsible for the changes, or removed entirely.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE."],"licenseIds":["MITNFA"],"keywords":["the software distributions","software distributions of","distributions of all","software intended to","by the recipients","the recipients as","recipients as they","as they would","they would use","would use the","use the unmodified","unmodified software containing","software containing modifications","containing modifications that","modifications that substantially","that substantially alter","substantially alter remove","alter remove or","remove or disable","or disable functionality","disable functionality of","the software outside","software outside of","outside of the","of the documented","the documented configuration","documented configuration mechanisms","configuration mechanisms provided","mechanisms provided by","be modified such","modified such that","author s bug","s bug reporting","bug reporting email","reporting email addresses","email addresses and","addresses and urls","and urls are","urls are either","are either replaced","either replaced with","with the contact","contact information of","the parties responsible","parties responsible for","the changes or","changes or removed","or removed entirely","removed entirely the","entirely the software","of the software distributions","the software distributions of","software distributions of all","distributions of all or","the software intended to","software intended to be","to be used by","be used by the","used by the recipients","by the recipients as","the recipients as they","recipients as they would","as they would use","they would use the","would use the unmodified","use the unmodified software","the unmodified software containing","unmodified software containing modifications","software containing modifications that","containing modifications that substantially","modifications that substantially alter","that substantially alter remove","substantially alter remove or","alter remove or disable","remove or disable functionality","or disable functionality of","disable functionality of the","functionality of the software","of the software outside","the software outside of","software outside of the","outside of the documented","of the documented configuration","the documented configuration mechanisms","documented configuration mechanisms provided","configuration mechanisms provided by","mechanisms provided by the","provided by the software","by the software shall","software shall be modified","shall be modified such","be modified such that","modified such that the","original author s bug","author s bug reporting","s bug reporting email","bug reporting email addresses","reporting email addresses and","email addresses and urls","addresses and urls are","and urls are either","urls are either replaced","are either replaced with","either replaced with the","replaced with the contact","with the contact information","the contact information of","contact information of the","information of the parties","of the parties responsible","the parties responsible for","parties responsible for the","responsible for the changes","for the changes or","the changes or removed","changes or removed entirely","or removed entirely the","removed entirely the software","entirely the software is","portions of the software distributions","of the software distributions of","the software distributions of all","software distributions of all or","distributions of all or part","part of the software intended","of the software intended to","the software intended to be","software intended to be used","intended to be used by","to be used by the","be used by the recipients","used by the recipients as","by the recipients as they","the recipients as they would","recipients as they would use","as they would use the","they would use the unmodified","would use the unmodified software","use the unmodified software containing","the unmodified software containing modifications","unmodified software containing modifications that","software containing modifications that substantially","containing modifications that substantially alter","modifications that substantially alter remove","that substantially alter remove or","substantially alter remove or disable","alter remove or disable functionality","remove or disable functionality of","or disable functionality of the","disable functionality of the software","functionality of the software outside","of the software outside of","the software outside of the","software outside of the documented","outside of the documented configuration","of the documented configuration mechanisms","the documented configuration mechanisms provided","documented configuration mechanisms provided by","configuration mechanisms provided by the","mechanisms provided by the software","provided by the software shall","by the software shall be","the software shall be modified","software shall be modified such","shall be modified such that","be modified such that the","modified such that the original","such that the original author","the original author s bug","original author s bug reporting","author s bug reporting email","s bug reporting email addresses","bug reporting email addresses and","reporting email addresses and urls","email addresses and urls are","addresses and urls are either","and urls are either replaced","urls are either replaced with","are either replaced with the","either replaced with the contact","replaced with the contact information","with the contact information of","the contact information of the","contact information of the parties","information of the parties responsible","of the parties responsible for","the parties responsible for the","parties responsible for the changes","responsible for the changes or","for the changes or removed","the changes or removed entirely","changes or removed entirely the","or removed entirely the software","removed entirely the software is","entirely the software is provided"]},{"licenseTexts":["MOZILLA PUBLIC LICENSE\n\nVersion 1.0\n\n   1. Definitions.\n\n      1.1. \"Contributor\" means each entity that creates or contributes to the creation of Modifications.\n\n      1.2. \"Contributor Version\" means the combination of the Original Code, prior Modifications used by a Contributor, and the Modifications made by that particular Contributor.\n\n      1.3. \"Covered Code\" means the Original Code or Modifications or the combination of the Original Code and Modifications, in each case including portions thereof.\n\n      1.4. \"Electronic Distribution Mechanism\" means a mechanism generally accepted in the software development community for the electronic transfer of data.\n\n      1.5. \"Executable\" means Covered Code in any form other than Source Code.\n\n      1.6. \"Initial Developer\" means the individual or entity identified as the Initial Developer in the Source Code notice required by Exhibit A.\n\n      1.7. \"Larger Work\" means a work which combines Covered Code or portions thereof with code not governed by the terms of this License.\n\n      1.8. \"License\" means this document.\n\n      1.9. \"Modifications\" means any addition to or deletion from the substance or structure of either the Original Code or any previous Modifications. When Covered Code is released as a series of files, a Modification is:\n\n         A. Any addition to or deletion from the contents of a file containing Original Code or previous Modifications.\n\n         B. Any new file that contains any part of the Original Code or previous Modifications.\n\n      1.10. \"Original Code\" means Source Code of computer software code which is described in the Source Code notice required by Exhibit A as Original Code, and which, at the time of its release under this License is not already Covered Code governed by this License.\n\n      1.11. \"Source Code\" means the preferred form of the Covered Code for making modifications to it, including all modules it contains, plus any associated interface definition files, scripts used to control compilation and installation of an Executable, or a list of source code differential comparisons against either the Original Code or another well known, available Covered Code of the Contributor's choice. The Source Code can be in a compressed or archival form, provided the appropriate decompression or de-archiving software is widely available for no charge.\n\n      1.12. \"You\" means an individual or a legal entity exercising rights under, and complying with all of the terms of, this License or a future version of this License issued under Section 6.1. For legal entities, \"You\" includes any entity which controls, is controlled by, or is under common control with You. For purposes of this definition, \"control\" means (a) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (b) ownership of fifty percent (50%) or more of the outstanding shares or beneficial ownership of such entity.\n\n   2. Source Code License.\n\n      2.1. The Initial Developer Grant.\n\n      The Initial Developer hereby grants You a world-wide, royalty-free, non-exclusive license, subject to third party intellectual property claims:\n\n         (a) to use, reproduce, modify, display, perform, sublicense and distribute the Original Code (or portions thereof) with or without Modifications, or as part of a Larger Work; and\n\n         (b) under patents now or hereafter owned or controlled by Initial Developer, to make, have made, use and sell (\"Utilize\") the Original Code (or portions thereof), but solely to the extent that any such patent is reasonably necessary to enable You to Utilize the Original Code (or portions thereof) and not to any greater extent that may be necessary to Utilize further Modifications or combinations.\n\n      2.2. Contributor Grant.\n\n      Each Contributor hereby grants You a world-wide, royalty-free, non-exclusive license, subject to third party intellectual property claims:\n\n         (a) to use, reproduce, modify, display, perform, sublicense and distribute the Modifications created by such Contributor (or portions thereof) either on an unmodified basis, with other Modifications, as Covered Code or as part of a Larger Work; and\n\n         (b) under patents now or hereafter owned or controlled by Contributor, to Utilize the Contributor Version (or portions thereof), but solely to the extent that any such patent is reasonably necessary to enable You to Utilize the Contributor Version (or portions thereof), and not to any greater extent that may be necessary to Utilize further Modifications or combinations.\n\n   3. Distribution Obligations.\n\n      3.1. Application of License.\n\n      The Modifications which You create or to which You contribute are governed by the terms of this License, including without limitation Section 2.2. The Source Code version of Covered Code may be distributed only under the terms of this License or a future version of this License released under Section 6.1, and You must include a copy of this License with every copy of the Source Code You distribute. You may not offer or impose any terms on any Source Code version that alters or restricts the applicable version of this License or the recipients' rights hereunder. However, You may include an additional document offering the additional rights described in Section 3.5.\n\n      3.2. Availability of Source Code.\n\n      Any Modification which You create or to which You contribute must be made available in Source Code form under the terms of this License either on the same media as an Executable version or via an accepted Electronic Distribution Mechanism to anyone to whom you made an Executable version available; and if made available via Electronic Distribution Mechanism, must remain available for at least twelve (12) months after the date it initially became available, or at least six (6) months after a subsequent version of that particular Modification has been made available to such recipients. You are responsible for ensuring that the Source Code version remains available even if the Electronic Distribution Mechanism is maintained by a third party.\n\n      3.3. Description of Modifications.\n\n      You must cause all Covered Code to which you contribute to contain a file documenting the changes You made to create that Covered Code and the date of any change. You must include a prominent statement that the Modification is derived, directly or indirectly, from Original Code provided by the Initial Developer and including the name of the Initial Developer in (a) the Source Code, and (b) in any notice in an Executable version or related documentation in which You describe the origin or ownership of the Covered Code.\n\n      3.4. Intellectual Property Matters\n\n         (a) Third Party Claims.\n\n         If You have knowledge that a party claims an intellectual property right in particular functionality or code (or its utilization under this License), you must include a text file with the source code distribution titled \"LEGAL\" which describes the claim and the party making the claim in sufficient detail that a recipient will know whom to contact. If you obtain such knowledge after You make Your Modification available as described in Section 3.2, You shall promptly modify the LEGAL file in all copies You make available thereafter and shall take other steps (such as notifying appropriate mailing lists or newsgroups) reasonably calculated to inform those who received the Covered Code that new knowledge has been obtained.\n\n         (b) Contributor APIs.\n\n         If Your Modification is an application programming interface and You own or control patents which are reasonably necessary to implement that API, you must also include this information in the LEGAL file.\n\n      3.5. Required Notices.\n\n      You must duplicate the notice in Exhibit A in each file of the Source Code, and this License in any documentation for the Source Code, where You describe recipients' rights relating to Covered Code. If You created one or more Modification(s), You may add your name as a Contributor to the notice described in Exhibit A. If it is not possible to put such notice in a particular Source Code file due to its structure, then you must include such notice in a location (such as a relevant directory file) where a user would be likely to look for such a notice. You may choose to offer, and to charge a fee for, warranty, support, indemnity or liability obligations to one or more recipients of Covered Code. However, You may do so only on Your own behalf, and not on behalf of the Initial Developer or any Contributor. You must make it absolutely clear than any such warranty, support, indemnity or liability obligation is offered by You alone, and You hereby agree to indemnify the Initial Developer and every Contributor for any liability incurred by the Initial Developer or such Contributor as a result of warranty, support, indemnity or liability terms You offer.\n\n      3.6. Distribution of Executable Versions.\n\n      You may distribute Covered Code in Executable form only if the requirements of Section 3.1-3.5 have been met for that Covered Code, and if You include a notice stating that the Source Code version of the Covered Code is available under the terms of this License, including a description of how and where You have fulfilled the obligations of Section 3.2. The notice must be conspicuously included in any notice in an Executable version, related documentation or collateral in which You describe recipients' rights relating to the Covered Code. You may distribute the Executable version of Covered Code under a license of Your choice, which may contain terms different from this License, provided that You are in compliance with the terms of this License and that the license for the Executable version does not attempt to limit or alter the recipient's rights in the Source Code version from the rights set forth in this License. If You distribute the Executable version under a different license You must make it absolutely clear that any terms which differ from this License are offered by You alone, not by the Initial Developer or any Contributor. You hereby agree to indemnify the Initial Developer and every Contributor for any liability incurred by the Initial Developer or such Contributor as a result of any such terms You offer.\n\n      3.7. Larger Works.\n\n      You may create a Larger Work by combining Covered Code with other code not governed by the terms of this License and distribute the Larger Work as a single product. In such a case, You must make sure the requirements of this License are fulfilled for the Covered Code.\n\n   4. Inability to Comply Due to Statute or Regulation.\n\n   If it is impossible for You to comply with any of the terms of this License with respect to some or all of the Covered Code due to statute or regulation then You must: (a) comply with the terms of this License to the maximum extent possible; and (b) describe the limitations and the code they affect. Such description must be included in the LEGAL file described in Section 3.4 and must be included with all distributions of the Source Code. Except to the extent prohibited by statute or regulation, such description must be sufficiently detailed for a recipient of ordinary skill to be able to understand it.\n\n   5. Application of this License.\n\n   This License applies to code to which the Initial Developer has attached the notice in Exhibit A, and to related Covered Code.\n\n   6. Versions of the License.\n\n      6.1. New Versions.\n\n      Netscape Communications Corporation (\"Netscape\") may publish revised and/or new versions of the License from time to time. Each version will be given a distinguishing version number.\n\n      6.2. Effect of New Versions.\n\n      Once Covered Code has been published under a particular version of the License, You may always continue to use it under the terms of that version. You may also choose to use such Covered Code under the terms of any subsequent version of the License published by Netscape. No one other than Netscape has the right to modify the terms applicable to Covered Code created under this License.\n\n      6.3. Derivative Works.\n\n      If you create or use a modified version of this License (which you may only do in order to apply it to code which is not already Covered Code governed by this License), you must (a) rename Your license so that the phrases \"Mozilla\", \"MOZILLAPL\", \"MOZPL\", \"Netscape\", \"NPL\" or any confusingly similar phrase do not appear anywhere in your license and (b) otherwise make it clear that your version of the license contains terms which differ from the Mozilla Public License and Netscape Public License. (Filling in the name of the Initial Developer, Original Code or Contributor in the notice described in Exhibit A shall not of themselves be deemed to be modifications of this License.)\n\n   7. DISCLAIMER OF WARRANTY.\n\n   COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN \"AS IS\" BASIS, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER.\n\n   8. TERMINATION.\n\n   This License and the rights granted hereunder will terminate automatically if You fail to comply with terms herein and fail to cure such breach within 30 days of becoming aware of the breach. All sublicenses to the Covered Code which are properly granted shall survive any termination of this License. Provisions which, by their nature, must remain in effect beyond the termination of this License shall survive.\n\n   9. LIMITATION OF LIABILITY.\n\n   UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER TORT (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL THE INITIAL DEVELOPER, ANY OTHER CONTRIBUTOR, OR ANY DISTRIBUTOR OF COVERED CODE, OR ANY SUPPLIER OF ANY OF SUCH PARTIES, BE LIABLE TO YOU OR ANY OTHER PERSON FOR ANY INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, COMPUTER FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER COMMERCIAL DAMAGES OR LOSSES, EVEN IF SUCH PARTY SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF LIABILITY SHALL NOT APPLY TO LIABILITY FOR DEATH OR PERSONAL INJURY RESULTING FROM SUCH PARTY'S NEGLIGENCE TO THE EXTENT APPLICABLE LAW PROHIBITS SUCH LIMITATION. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OR LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THAT EXCLUSION AND LIMITATION MAY NOT APPLY TO YOU.\n\n   10. U.S. GOVERNMENT END USERS.\n\n   The Covered Code is a \"commercial item,\" as that term is defined in 48 C.F.R. 2.101 (Oct. 1995), consisting of \"commercial computer software\" and \"commercial computer software documentation,\" as such terms are used in 48 C.F.R. 12.212 (Sept. 1995). Consistent with 48 C.F.R. 12.212 and 48 C.F.R. 227.7202-1 through 227.7202-4 (June 1995), all U.S. Government End Users acquire Covered Code with only those rights set forth herein.\n\n   11. MISCELLANEOUS.\n\n   This License represents the complete agreement concerning subject matter hereof. If any provision of this License is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable. This License shall be governed by California law provisions (except to the extent applicable law, if any, provides otherwise), excluding its conflict-of-law provisions. With respect to disputes in which at least one party is a citizen of, or an entity chartered or registered to do business in, the United States of America: (a) unless otherwise agreed in writing, all disputes relating to this License (excepting any dispute relating to intellectual property rights) shall be subject to final and binding arbitration, with the losing party paying all costs of arbitration; (b) any arbitration relating to this Agreement shall be held in Santa Clara County, California, under the auspices of JAMS/EndDispute; and (c) any litigation relating to this Agreement shall be subject to the jurisdiction of the Federal Courts of the Northern District of California, with venue lying in Santa Clara County, California, with the losing party responsible for costs, including without limitation, court costs and reasonable attorneys fees and expenses. The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded. Any law or regulation which provides that the language of a contract shall be construed against the drafter shall not apply to this License.\n\n   12. RESPONSIBILITY FOR CLAIMS.\n\n   Except in cases where another Contributor has failed to comply with Section 3.4, You are responsible for damages arising, directly or indirectly, out of Your utilization of rights under this License, based on the number of copies of Covered Code you made available, the revenues you received from utilizing such rights, and other relevant factors. You agree to work with affected parties to distribute responsibility on an equitable basis. EXHIBIT A.\n\n\"The contents of this file are subject to the Mozilla Public License Version 1.0 (the \"License\"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.mozilla.org/MPL/\n\nSoftware distributed under the License is distributed on an \"AS IS\" basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the specific language governing rights and limitations under the License.\n\nThe Original Code is _____ . The Initial Developer of the Original Code is _____ . Portions created by _____ are Copyright (C) _____ . All Rights Reserved. Contributor(s): _____ .\""],"licenseIds":["MPL-1.0"],"keywords":null},{"licenseTexts":["Mozilla Public License Version 1.1\n\n   1. Definitions.\n\n      1.0.1. \"Commercial Use\" means distribution or otherwise making the Covered Code available to a third party.\n\n      1.1. \"Contributor\" means each entity that creates or contributes to the creation of Modifications.\n\n      1.2. \"Contributor Version\" means the combination of the Original Code, prior Modifications used by a Contributor, and the Modifications made by that particular Contributor.\n\n      1.3. \"Covered Code\" means the Original Code or Modifications or the combination of the Original Code and Modifications, in each case including portions thereof.\n\n      1.4. \"Electronic Distribution Mechanism\" means a mechanism generally accepted in the software development community for the electronic transfer of data.\n\n      1.5. \"Executable\" means Covered Code in any form other than Source Code.\n\n      1.6. \"Initial Developer\" means the individual or entity identified as the Initial Developer in the Source Code notice required by Exhibit A.\n\n      1.7. \"Larger Work\" means a work which combines Covered Code or portions thereof with code not governed by the terms of this License.\n\n      1.8. \"License\" means this document.\n\n      1.8.1. \"Licensable\" means having the right to grant, to the maximum extent possible, whether at the time of the initial grant or subsequently acquired, any and all of the rights conveyed herein.\n\n      1.9. \"Modifications\" means any addition to or deletion from the substance or structure of either the Original Code or any previous Modifications. When Covered Code is released as a series of files, a Modification is:\n\n      Any addition to or deletion from the contents of a file containing Original Code or previous Modifications.\n\n      Any new file that contains any part of the Original Code or previous Modifications.\n\n      1.10. \"Original Code\" means Source Code of computer software code which is described in the Source Code notice required by Exhibit A as Original Code, and which, at the time of its release under this License is not already Covered Code governed by this License.\n\n      1.10.1. \"Patent Claims\" means any patent claim(s), now owned or hereafter acquired, including without limitation, method, process, and apparatus claims, in any patent Licensable by grantor.\n\n      1.11. \"Source Code\" means the preferred form of the Covered Code for making modifications to it, including all modules it contains, plus any associated interface definition files, scripts used to control compilation and installation of an Executable, or source code differential comparisons against either the Original Code or another well known, available Covered Code of the Contributor's choice. The Source Code can be in a compressed or archival form, provided the appropriate decompression or de-archiving software is widely available for no charge.\n\n      1.12. \"You\" (or \"Your\") means an individual or a legal entity exercising rights under, and complying with all of the terms of, this License or a future version of this License issued under Section 6.1. For legal entities, \"You\" includes any entity which controls, is controlled by, or is under common control with You. For purposes of this definition, \"control\" means (a) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (b) ownership of more than fifty percent (50%) of the outstanding shares or beneficial ownership of such entity.\n\n   2. Source Code License.\n\n      2.1. The Initial Developer Grant. The Initial Developer hereby grants You a world-wide, royalty-free, non-exclusive license, subject to third party intellectual property claims:\n\n         a. under intellectual property rights (other than patent or trademark) Licensable by Initial Developer to use, reproduce, modify, display, perform, sublicense and distribute the Original Code (or portions thereof) with or without Modifications, and/or as part of a Larger Work; and\n\n         b. under Patents Claims infringed by the making, using or selling of Original Code, to make, have made, use, practice, sell, and offer for sale, and/or otherwise dispose of the Original Code (or portions thereof).\n\n         c. the licenses granted in this Section 2.1 (a) and (b) are effective on the date Initial Developer first distributes Original Code under the terms of this License.\n\n         d. Notwithstanding Section 2.1 (b) above, no patent license is granted: 1) for code that You delete from the Original Code; 2) separate from the Original Code; or 3) for infringements caused by: i) the modification of the Original Code or ii) the combination of the Original Code with other software or devices.\n\n      2.2. Contributor Grant. Subject to third party intellectual property claims, each Contributor hereby grants You a world-wide, royalty-free, non-exclusive license\n\n         a. under intellectual property rights (other than patent or trademark) Licensable by Contributor, to use, reproduce, modify, display, perform, sublicense and distribute the Modifications created by such Contributor (or portions thereof) either on an unmodified basis, with other Modifications, as Covered Code and/or as part of a Larger Work; and\n\n         b. under Patent Claims infringed by the making, using, or selling of Modifications made by that Contributor either alone and/or in combination with its Contributor Version (or portions of such combination), to make, use, sell, offer for sale, have made, and/or otherwise dispose of: 1) Modifications made by that Contributor (or portions thereof); and 2) the combination of Modifications made by that Contributor with its Contributor Version (or portions of such combination).\n\n         c. the licenses granted in Sections 2.2 (a) and 2.2 (b) are effective on the date Contributor first makes Commercial Use of the Covered Code.\n\n         d. Notwithstanding Section 2.2 (b) above, no patent license is granted: 1) for any code that Contributor has deleted from the Contributor Version; 2) separate from the Contributor Version; 3) for infringements caused by: i) third party modifications of Contributor Version or ii) the combination of Modifications made by that Contributor with other software (except as part of the Contributor Version) or other devices; or 4) under Patent Claims infringed by Covered Code in the absence of Modifications made by that Contributor.\n\n   3. Distribution Obligations.\n\n      3.1. Application of License. The Modifications which You create or to which You contribute are governed by the terms of this License, including without limitation Section 2.2. The Source Code version of Covered Code may be distributed only under the terms of this License or a future version of this License released under Section 6.1, and You must include a copy of this License with every copy of the Source Code You distribute. You may not offer or impose any terms on any Source Code version that alters or restricts the applicable version of this License or the recipients' rights hereunder. However, You may include an additional document offering the additional rights described in Section 3.5.\n\n      3.2. Availability of Source Code. Any Modification which You create or to which You contribute must be made available in Source Code form under the terms of this License either on the same media as an Executable version or via an accepted Electronic Distribution Mechanism to anyone to whom you made an Executable version available; and if made available via Electronic Distribution Mechanism, must remain available for at least twelve (12) months after the date it initially became available, or at least six (6) months after a subsequent version of that particular Modification has been made available to such recipients. You are responsible for ensuring that the Source Code version remains available even if the Electronic Distribution Mechanism is maintained by a third party.\n\n      3.3. Description of Modifications. You must cause all Covered Code to which You contribute to contain a file documenting the changes You made to create that Covered Code and the date of any change. You must include a prominent statement that the Modification is derived, directly or indirectly, from Original Code provided by the Initial Developer and including the name of the Initial Developer in (a) the Source Code, and (b) in any notice in an Executable version or related documentation in which You describe the origin or ownership of the Covered Code.\n\n      3.4. Intellectual Property Matters\n\n         (a) Third Party Claims\n\n         If Contributor has knowledge that a license under a third party's intellectual property rights is required to exercise the rights granted by such Contributor under Sections 2.1 or 2.2, Contributor must include a text file with the Source Code distribution titled \"LEGAL\" which describes the claim and the party making the claim in sufficient detail that a recipient will know whom to contact. If Contributor obtains such knowledge after the Modification is made available as described in Section 3.2, Contributor shall promptly modify the LEGAL file in all copies Contributor makes available thereafter and shall take other steps (such as notifying appropriate mailing lists or newsgroups) reasonably calculated to inform those who received the Covered Code that new knowledge has been obtained.\n\n         (b) Contributor APIs\n\n         If Contributor's Modifications include an application programming interface and Contributor has knowledge of patent licenses which are reasonably necessary to implement that API, Contributor must also include this information in the LEGAL file.\n\n         (c) Representations.\n\n         Contributor represents that, except as disclosed pursuant to Section 3.4 (a) above, Contributor believes that Contributor's Modifications are Contributor's original creation(s) and/or Contributor has sufficient rights to grant the rights conveyed by this License.\n\n      3.5. Required Notices. You must duplicate the notice in Exhibit A in each file of the Source Code. If it is not possible to put such notice in a particular Source Code file due to its structure, then You must include such notice in a location (such as a relevant directory) where a user would be likely to look for such a notice. If You created one or more Modification(s) You may add your name as a Contributor to the notice described in Exhibit A. You must also duplicate this License in any documentation for the Source Code where You describe recipients' rights or ownership rights relating to Covered Code. You may choose to offer, and to charge a fee for, warranty, support, indemnity or liability obligations to one or more recipients of Covered Code. However, You may do so only on Your own behalf, and not on behalf of the Initial Developer or any Contributor. You must make it absolutely clear than any such warranty, support, indemnity or liability obligation is offered by You alone, and You hereby agree to indemnify the Initial Developer and every Contributor for any liability incurred by the Initial Developer or such Contributor as a result of warranty, support, indemnity or liability terms You offer.\n\n      3.6. Distribution of Executable Versions. You may distribute Covered Code in Executable form only if the requirements of Sections 3.1, 3.2, 3.3, 3.4 and 3.5 have been met for that Covered Code, and if You include a notice stating that the Source Code version of the Covered Code is available under the terms of this License, including a description of how and where You have fulfilled the obligations of Section 3.2. The notice must be conspicuously included in any notice in an Executable version, related documentation or collateral in which You describe recipients' rights relating to the Covered Code. You may distribute the Executable version of Covered Code or ownership rights under a license of Your choice, which may contain terms different from this License, provided that You are in compliance with the terms of this License and that the license for the Executable version does not attempt to limit or alter the recipient's rights in the Source Code version from the rights set forth in this License. If You distribute the Executable version under a different license You must make it absolutely clear that any terms which differ from this License are offered by You alone, not by the Initial Developer or any Contributor. You hereby agree to indemnify the Initial Developer and every Contributor for any liability incurred by the Initial Developer or such Contributor as a result of any such terms You offer.\n\n      3.7. Larger Works. You may create a Larger Work by combining Covered Code with other code not governed by the terms of this License and distribute the Larger Work as a single product. In such a case, You must make sure the requirements of this License are fulfilled for the Covered Code.\n\n   4. Inability to Comply Due to Statute or Regulation.\n\n   If it is impossible for You to comply with any of the terms of this License with respect to some or all of the Covered Code due to statute, judicial order, or regulation then You must: (a) comply with the terms of this License to the maximum extent possible; and (b) describe the limitations and the code they affect. Such description must be included in the LEGAL file described in Section 3.4 and must be included with all distributions of the Source Code. Except to the extent prohibited by statute or regulation, such description must be sufficiently detailed for a recipient of ordinary skill to be able to understand it.\n\n   5. Application of this License.\n\n   This License applies to code to which the Initial Developer has attached the notice in Exhibit A and to related Covered Code.\n\n   6. Versions of the License.\n\n      6.1. New Versions\n\n      Netscape Communications Corporation (\"Netscape\") may publish revised and/or new versions of the License from time to time. Each version will be given a distinguishing version number.\n\n      6.2. Effect of New Versions\n\n      Once Covered Code has been published under a particular version of the License, You may always continue to use it under the terms of that version. You may also choose to use such Covered Code under the terms of any subsequent version of the License published by Netscape. No one other than Netscape has the right to modify the terms applicable to Covered Code created under this License.\n\n      6.3. Derivative Works\n\n      If You create or use a modified version of this License (which you may only do in order to apply it to code which is not already Covered Code governed by this License), You must (a) rename Your license so that the phrases \"Mozilla\", \"MOZILLAPL\", \"MOZPL\", \"Netscape\", \"MPL\", \"NPL\" or any confusingly similar phrase do not appear in your license (except to note that your license differs from this License) and (b) otherwise make it clear that Your version of the license contains terms which differ from the Mozilla Public License and Netscape Public License. (Filling in the name of the Initial Developer, Original Code or Contributor in the notice described in Exhibit A shall not of themselves be deemed to be modifications of this License.)\n\n   7. DISCLAIMER OF WARRANTY\n\n   COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN \"AS IS\" BASIS, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER.\n\n   8. Termination\n\n      8.1. This License and the rights granted hereunder will terminate automatically if You fail to comply with terms herein and fail to cure such breach within 30 days of becoming aware of the breach. All sublicenses to the Covered Code which are properly granted shall survive any termination of this License. Provisions which, by their nature, must remain in effect beyond the termination of this License shall survive.\n\n      8.2. If You initiate litigation by asserting a patent infringement claim (excluding declatory judgment actions) against Initial Developer or a Contributor (the Initial Developer or Contributor against whom You file such action is referred to as \"Participant\") alleging that:\n\n         a. such Participant's Contributor Version directly or indirectly infringes any patent, then any and all rights granted by such Participant to You under Sections 2.1 and/or 2.2 of this License shall, upon 60 days notice from Participant terminate prospectively, unless if within 60 days after receipt of notice You either: (i) agree in writing to pay Participant a mutually agreeable reasonable royalty for Your past and future use of Modifications made by such Participant, or (ii) withdraw Your litigation claim with respect to the Contributor Version against such Participant. If within 60 days of notice, a reasonable royalty and payment arrangement are not mutually agreed upon in writing by the parties or the litigation claim is not withdrawn, the rights granted by Participant to You under Sections 2.1 and/or 2.2 automatically terminate at the expiration of the 60 day notice period specified above.\n\n         b. any software, hardware, or device, other than such Participant's Contributor Version, directly or indirectly infringes any patent, then any rights granted to You by such Participant under Sections 2.1(b) and 2.2(b) are revoked effective as of the date You first made, used, sold, distributed, or had made, Modifications made by that Participant.\n\n      8.3. If You assert a patent infringement claim against Participant alleging that such Participant's Contributor Version directly or indirectly infringes any patent where such claim is resolved (such as by license or settlement) prior to the initiation of patent infringement litigation, then the reasonable value of the licenses granted by such Participant under Sections 2.1 or 2.2 shall be taken into account in determining the amount or value of any payment or license.\n\n      8.4. In the event of termination under Sections 8.1 or 8.2 above, all end user license agreements (excluding distributors and resellers) which have been validly granted by You or any distributor hereunder prior to termination shall survive termination.\n\n   9. LIMITATION OF LIABILITY\n\n   UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER TORT (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL YOU, THE INITIAL DEVELOPER, ANY OTHER CONTRIBUTOR, OR ANY DISTRIBUTOR OF COVERED CODE, OR ANY SUPPLIER OF ANY OF SUCH PARTIES, BE LIABLE TO ANY PERSON FOR ANY INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, COMPUTER FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER COMMERCIAL DAMAGES OR LOSSES, EVEN IF SUCH PARTY SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF LIABILITY SHALL NOT APPLY TO LIABILITY FOR DEATH OR PERSONAL INJURY RESULTING FROM SUCH PARTY'S NEGLIGENCE TO THE EXTENT APPLICABLE LAW PROHIBITS SUCH LIMITATION. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OR LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THIS EXCLUSION AND LIMITATION MAY NOT APPLY TO YOU.\n\n   10. U.S. government end users\n\n   The Covered Code is a \"commercial item,\" as that term is defined in 48 C.F.R. 2.101 (Oct. 1995), consisting of \"commercial computer software\" and \"commercial computer software documentation,\" as such terms are used in 48 C.F.R. 12.212 (Sept. 1995). Consistent with 48 C.F.R. 12.212 and 48 C.F.R. 227.7202-1 through 227.7202-4 (June 1995), all U.S. Government End Users acquire Covered Code with only those rights set forth herein.\n\n   11. Miscellaneous\n\n   This License represents the complete agreement concerning subject matter hereof. If any provision of this License is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable. This License shall be governed by California law provisions (except to the extent applicable law, if any, provides otherwise), excluding its conflict-of-law provisions. With respect to disputes in which at least one party is a citizen of, or an entity chartered or registered to do business in the United States of America, any litigation relating to this License shall be subject to the jurisdiction of the Federal Courts of the Northern District of California, with venue lying in Santa Clara County, California, with the losing party responsible for costs, including without limitation, court costs and reasonable attorneys' fees and expenses. The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded. Any law or regulation which provides that the language of a contract shall be construed against the drafter shall not apply to this License.\n\n   12. Responsibility for claims\n\n   As between Initial Developer and the Contributors, each party is responsible for claims and damages arising, directly or indirectly, out of its utilization of rights under this License and You agree to work with Initial Developer and Contributors to distribute such responsibility on an equitable basis. Nothing herein is intended or shall be deemed to constitute any admission of liability.\n\n   13. Multiple-licensed code\n\n   Initial Developer may designate portions of the Covered Code as \"Multiple-Licensed\". \"Multiple-Licensed\" means that the Initial Developer permits you to utilize portions of the Covered Code under Your choice of the MPL or the alternative licenses, if any, specified by the Initial Developer in the file described in Exhibit A. Exhibit A - Mozilla Public License.\n\n\"The contents of this file are subject to the Mozilla Public License Version 1.1 (the \"License\"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.mozilla.org/MPL/\n\nSoftware distributed under the License is distributed on an \"AS IS\" basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the specific language governing rights and limitations under the License.\n\nThe Original Code is ______________________________________ .\n\nThe Initial Developer of the Original Code is ________________________ .\n\nPortions created by ______________________ are Copyright (C) ______ . All Rights Reserved.\n\nContributor(s): ______________________________________ .\n\nAlternatively, the contents of this file may be used under the terms of the _____ license (the \" [___] License\"), in which case the provisions of [______] License are applicable instead of those above. If you wish to allow use of your version of this file only under the terms of the [____] License and not to allow others to use your version of this file under the MPL, indicate your decision by deleting the provisions above and replace them with the notice and other provisions required by the [___] License. If you do not delete the provisions above, a recipient may use your version of this file under either the MPL or the [___] License.\"\n\nNOTE: The text of this Exhibit A may differ slightly from the text of the notices in the Source Code files of the Original Code. You should use the text of this Exhibit A rather than the text found in the Original Code Source Code for Your Modifications."],"licenseIds":["MPL-1.1"],"keywords":null},{"licenseTexts":["Mozilla Public License Version 2.0\n\n   1. Definitions\n\n      1.1. \"Contributor\" means each individual or legal entity that creates, contributes to the creation of, or owns Covered Software.\n\n      1.2. \"Contributor Version\" means the combination of the Contributions of others (if any) used by a Contributor and that particular Contributor's Contribution.\n\n      1.3. \"Contribution\" means Covered Software of a particular Contributor.\n\n      1.4. \"Covered Software\" means Source Code Form to which the initial Contributor has attached the notice in Exhibit A, the Executable Form of such Source Code Form, and Modifications of such Source Code Form, in each case including portions thereof.\n\n      1.5. \"Incompatible With Secondary Licenses\" means\n\n         (a) that the initial Contributor has attached the notice described in Exhibit B to the Covered Software; or\n\n         (b) that the Covered Software was made available under the terms of version 1.1 or earlier of the License, but not also under the terms of a Secondary License.\n\n      1.6. \"Executable Form\" means any form of the work other than Source Code Form.\n\n      1.7. \"Larger Work\" means a work that combines Covered Software with other material, in a separate file or files, that is not Covered Software.\n\n      1.8. \"License\" means this document.\n\n      1.9. \"Licensable\" means having the right to grant, to the maximum extent possible, whether at the time of the initial grant or subsequently, any and all of the rights conveyed by this License.\n\n      1.10. \"Modifications\" means any of the following:\n\n         (a) any file in Source Code Form that results from an addition to, deletion from, or modification of the contents of Covered Software; or\n\n         (b) any new file in Source Code Form that contains any Covered Software.\n\n      1.11. \"Patent Claims\" of a Contributor means any patent claim(s), including without limitation, method, process, and apparatus claims, in any patent Licensable by such Contributor that would be infringed, but for the grant of the License, by the making, using, selling, offering for sale, having made, import, or transfer of either its Contributions or its Contributor Version.\n\n      1.12. \"Secondary License\" means either the GNU General Public License, Version 2.0, the GNU Lesser General Public License, Version 2.1, the GNU Affero General Public License, Version 3.0, or any later versions of those licenses.\n\n      1.13. \"Source Code Form\" means the form of the work preferred for making modifications.\n\n      1.14. \"You\" (or \"Your\") means an individual or a legal entity exercising rights under this License. For legal entities, \"You\" includes any entity that controls, is controlled by, or is under common control with You. For purposes of this definition, \"control\" means (a) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (b) ownership of more than fifty percent (50%) of the outstanding shares or beneficial ownership of such entity.\n\n   2. License Grants and Conditions\n\n      2.1. Grants\n\n      Each Contributor hereby grants You a world-wide, royalty-free, non-exclusive license:\n\n         (a) under intellectual property rights (other than patent or trademark) Licensable by such Contributor to use, reproduce, make available, modify, display, perform, distribute, and otherwise exploit its Contributions, either on an unmodified basis, with Modifications, or as part of a Larger Work; and\n\n         (b) under Patent Claims of such Contributor to make, use, sell, offer for sale, have made, import, and otherwise transfer either its Contributions or its Contributor Version.\n\n      2.2. Effective Date\n\n      The licenses granted in Section 2.1 with respect to any Contribution become effective for each Contribution on the date the Contributor first distributes such Contribution.\n\n      2.3. Limitations on Grant Scope\n\n      The licenses granted in this Section 2 are the only rights granted under this License. No additional rights or licenses will be implied from the distribution or licensing of Covered Software under this License. Notwithstanding Section 2.1(b) above, no patent license is granted by a Contributor:\n\n         (a) for any code that a Contributor has removed from Covered Software; or\n\n         (b) for infringements caused by: (i) Your and any other third party's modifications of Covered Software, or (ii) the combination of its Contributions with other software (except as part of its Contributor Version); or\n\n         (c) under Patent Claims infringed by Covered Software in the absence of its Contributions.\n\n      This License does not grant any rights in the trademarks, service marks, or logos of any Contributor (except as may be necessary to comply with the notice requirements in Section 3.4).\n\n      2.4. Subsequent Licenses\n\n      No Contributor makes additional grants as a result of Your choice to distribute the Covered Software under a subsequent version of this License (see Section 10.2) or under the terms of a Secondary License (if permitted under the terms of Section 3.3).\n\n      2.5. Representation\n\n      Each Contributor represents that the Contributor believes its Contributions are its original creation(s) or it has sufficient rights to grant the rights to its Contributions conveyed by this License.\n\n      2.6. Fair Use\n\n      This License is not intended to limit any rights You have under applicable copyright doctrines of fair use, fair dealing, or other equivalents.\n\n      2.7. Conditions\n\n      Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted in Section 2.1.\n\n   3. Responsibilities\n\n      3.1. Distribution of Source Form\n\n      All distribution of Covered Software in Source Code Form, including any Modifications that You create or to which You contribute, must be under the terms of this License. You must inform recipients that the Source Code Form of the Covered Software is governed by the terms of this License, and how they can obtain a copy of this License. You may not attempt to alter or restrict the recipients' rights in the Source Code Form.\n\n      3.2. Distribution of Executable Form\n\n      If You distribute Covered Software in Executable Form then:\n\n         (a) such Covered Software must also be made available in Source Code Form, as described in Section 3.1, and You must inform recipients of the Executable Form how they can obtain a copy of such Source Code Form by reasonable means in a timely manner, at a charge no more than the cost of distribution to the recipient; and\n\n         (b) You may distribute such Executable Form under the terms of this License, or sublicense it under different terms, provided that the license for the Executable Form does not attempt to limit or alter the recipients' rights in the Source Code Form under this License.\n\n      3.3. Distribution of a Larger Work\n\n      You may create and distribute a Larger Work under terms of Your choice, provided that You also comply with the requirements of this License for the Covered Software. If the Larger Work is a combination of Covered Software with a work governed by one or more Secondary Licenses, and the Covered Software is not Incompatible With Secondary Licenses, this License permits You to additionally distribute such Covered Software under the terms of such Secondary License(s), so that the recipient of the Larger Work may, at their option, further distribute the Covered Software under the terms of either this License or such Secondary License(s).\n\n      3.4. Notices\n\n      You may not remove or alter the substance of any license notices (including copyright notices, patent notices, disclaimers of warranty, or limitations of liability) contained within the Source Code Form of the Covered Software, except that You may alter any license notices to the extent required to remedy known factual inaccuracies.\n\n      3.5. Application of Additional Terms\n\n      You may choose to offer, and to charge a fee for, warranty, support, indemnity or liability obligations to one or more recipients of Covered Software. However, You may do so only on Your own behalf, and not on behalf of any Contributor. You must make it absolutely clear that any such warranty, support, indemnity, or liability obligation is offered by You alone, and You hereby agree to indemnify every Contributor for any liability incurred by such Contributor as a result of warranty, support, indemnity or liability terms You offer. You may include additional disclaimers of warranty and limitations of liability specific to any jurisdiction.\n\n   4. Inability to Comply Due to Statute or Regulation\n\n   If it is impossible for You to comply with any of the terms of this License with respect to some or all of the Covered Software due to statute, judicial order, or regulation then You must: (a) comply with the terms of this License to the maximum extent possible; and (b) describe the limitations and the code they affect. Such description must be placed in a text file included with all distributions of the Covered Software under this License. Except to the extent prohibited by statute or regulation, such description must be sufficiently detailed for a recipient of ordinary skill to be able to understand it.\n\n   5. Termination\n\n      5.1. The rights granted under this License will terminate automatically if You fail to comply with any of its terms. However, if You become compliant, then the rights granted under this License from a particular Contributor are reinstated (a) provisionally, unless and until such Contributor explicitly and finally terminates Your grants, and (b) on an ongoing basis, if such Contributor fails to notify You of the non-compliance by some reasonable means prior to 60 days after You have come back into compliance. Moreover, Your grants from a particular Contributor are reinstated on an ongoing basis if such Contributor notifies You of the non-compliance by some reasonable means, this is the first time You have received notice of non-compliance with this License from such Contributor, and You become compliant prior to 30 days after Your receipt of the notice.\n\n      5.2. If You initiate litigation against any entity by asserting a patent infringement claim (excluding declaratory judgment actions, counter-claims, and cross-claims) alleging that a Contributor Version directly or indirectly infringes any patent, then the rights granted to You by any and all Contributors for the Covered Software under Section 2.1 of this License shall terminate.\n\n      5.3. In the event of termination under Sections 5.1 or 5.2 above, all end user license agreements (excluding distributors and resellers) which have been validly granted by You or Your distributors under this License prior to termination shall survive termination.\n\n   6. Disclaimer of Warranty\n\n   Covered Software is provided under this License on an \"as is\" basis, without warranty of any kind, either expressed, implied, or statutory, including, without limitation, warranties that the Covered Software is free of defects, merchantable, fit for a particular purpose or non-infringing. The entire risk as to the quality and performance of the Covered Software is with You. Should any Covered Software prove defective in any respect, You (not any Contributor) assume the cost of any necessary servicing, repair, or correction. This disclaimer of warranty constitutes an essential part of this License. No use of any Covered Software is authorized under this License except under this disclaimer.\n\n   7. Limitation of Liability\n\n   Under no circumstances and under no legal theory, whether tort (including negligence), contract, or otherwise, shall any Contributor, or anyone who distributes Covered Software as permitted above, be liable to You for any direct, indirect, special, incidental, or consequential damages of any character including, without limitation, damages for lost profits, loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses, even if such party shall have been informed of the possibility of such damages. This limitation of liability shall not apply to liability for death or personal injury resulting from such party's negligence to the extent applicable law prohibits such limitation. Some jurisdictions do not allow the exclusion or limitation of incidental or consequential damages, so this exclusion and limitation may not apply to You.\n\n   8. Litigation\n\n   Any litigation relating to this License may be brought only in the courts of a jurisdiction where the defendant maintains its principal place of business and such litigation shall be governed by laws of that jurisdiction, without reference to its conflict-of-law provisions. Nothing in this Section shall prevent a party's ability to bring cross-claims or counter-claims.\n\n   9. Miscellaneous\n\n   This License represents the complete agreement concerning the subject matter hereof. If any provision of this License is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable. Any law or regulation which provides that the language of a contract shall be construed against the drafter shall not be used to construe this License against a Contributor.\n\n   10. Versions of the License\n\n      10.1. New Versions\n\n      Mozilla Foundation is the license steward. Except as provided in Section 10.3, no one other than the license steward has the right to modify or publish new versions of this License. Each version will be given a distinguishing version number.\n\n      10.2. Effect of New Versions\n\n      You may distribute the Covered Software under the terms of the version of the License under which You originally received the Covered Software, or under the terms of any subsequent version published by the license steward.\n\n      10.3. Modified Versions\n\n      If you create software not governed by this License, and you want to create a new license for such software, you may create and use a modified version of this License if you rename the license and remove any references to the name of the license steward (except to note that such modified license differs from this License).\n\n      10.4. Distributing Source Code Form that is Incompatible With Secondary Licenses\n\n      If You choose to distribute Source Code Form that is Incompatible With Secondary Licenses under the terms of this version of the License, the notice described in Exhibit B of this License must be attached. Exhibit A - Source Code Form License Notice\n\nThis Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was not distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.\n\nIf it is not possible or desirable to put the notice in a particular file, then You may include the notice in a location (such as a LICENSE file in a relevant directory) where a recipient would be likely to look for such a notice.\n\nYou may add additional accurate notices of copyright ownership.\n\nExhibit B - \"Incompatible With Secondary Licenses\" Notice\n\nThis Source Code Form is \"Incompatible With Secondary Licenses\", as defined by the Mozilla Public License, v. 2.0."],"licenseIds":["MPL-2.0-no-copyleft-exception","MPL-2.0"],"keywords":["1 or earlier","any jurisdiction 4","jurisdiction 4 inability","must be placed","placed in a","text file included","file included with","5 3 in","under sections 5","sections 5 1","5 1 or","1 or 5","or 5 2","5 2 above","claims 9 miscellaneous","a contributor 10","contributor 10 versions","10 versions of","the license 10","license 10 1","10 1 new","new versions mozilla","versions mozilla foundation","mozilla foundation is","steward except as","section 10 3","10 3 no","version number 10","number 10 2","10 2 effect","license steward 10","steward 10 3","10 3 modified","license 10 4","10 4 distributing","0 if a","the mpl was","mpl was not","one at http","at http mozilla","http mozilla org","org mpl 2","0 if it","by the mozilla","2 0 1 definitions","of version 1 1","1 1 or earlier","1 or earlier of","to any jurisdiction 4","any jurisdiction 4 inability","jurisdiction 4 inability to","description must be placed","must be placed in","be placed in a","placed in a text","a text file included","text file included with","file included with all","this license except to","license except to the","termination 5 1 the","5 1 the rights","notice 5 2 if","terminate 5 3 in","5 3 in the","termination under sections 5","under sections 5 1","sections 5 1 or","5 1 or 5","1 or 5 2","or 5 2 above","5 2 above all","counter claims 9 miscellaneous","claims 9 miscellaneous this","against a contributor 10","a contributor 10 versions","contributor 10 versions of","10 versions of the","of the license 10","the license 10 1","license 10 1 new","10 1 new versions","1 new versions mozilla","new versions mozilla foundation","versions mozilla foundation is","mozilla foundation is the","foundation is the license","is the license steward","license steward except as","steward except as provided","provided in section 10","in section 10 3","section 10 3 no","10 3 no one","distinguishing version number 10","version number 10 2","number 10 2 effect","10 2 effect of","the license steward 10","license steward 10 3","steward 10 3 modified","10 3 modified versions","from this license 10","this license 10 4","license 10 4 distributing","10 4 distributing source","terms of the mozilla","v 2 0 if","2 0 if a","0 if a copy","copy of the mpl","of the mpl was","the mpl was not","mpl was not distributed","obtain one at http","one at http mozilla","at http mozilla org","http mozilla org mpl","mozilla org mpl 2","org mpl 2 0","mpl 2 0 if","2 0 if it","0 if it is","with secondary licenses notice","defined by the mozilla","by the mozilla public","version 2 0 1 definitions","2 0 1 definitions 1","terms of version 1 1","of version 1 1 or","version 1 1 or earlier","1 1 or earlier of","1 or earlier of the","12 secondary license means either","license you may not attempt","specific to any jurisdiction 4","to any jurisdiction 4 inability","any jurisdiction 4 inability to","jurisdiction 4 inability to comply","such description must be placed","description must be placed in","must be placed in a","be placed in a text","placed in a text file","in a text file included","a text file included with","text file included with all","file included with all distributions","all distributions of the covered","distributions of the covered software","the covered software under this","software under this license except","under this license except to","this license except to the","license except to the extent","5 termination 5 1 the","termination 5 1 the rights","5 1 the rights granted","the notice 5 2 if","notice 5 2 if you","5 2 if you initiate","shall terminate 5 3 in","terminate 5 3 in the","5 3 in the event","of termination under sections 5","termination under sections 5 1","under sections 5 1 or","sections 5 1 or 5","5 1 or 5 2","1 or 5 2 above","or 5 2 above all","5 2 above all end","or counter claims 9 miscellaneous","counter claims 9 miscellaneous this","claims 9 miscellaneous this license","license against a contributor 10","against a contributor 10 versions","a contributor 10 versions of","contributor 10 versions of the","10 versions of the license","versions of the license 10","of the license 10 1","the license 10 1 new","license 10 1 new versions","10 1 new versions mozilla","1 new versions mozilla foundation","new versions mozilla foundation is","versions mozilla foundation is the","mozilla foundation is the license","foundation is the license steward","is the license steward except","the license steward except as","license steward except as provided","steward except as provided in","as provided in section 10","provided in section 10 3","in section 10 3 no","section 10 3 no one","10 3 no one other","a distinguishing version number 10"]},{"licenseTexts":["Microsoft Public License (Ms-PL)\n\nThis license governs use of the accompanying software. If you use the software, you accept this license. If you do not accept the license, do not use the software.\n\n   1. Definitions\n\n   The terms \"reproduce,\" \"reproduction,\" \"derivative works,\" and \"distribution\" have the same meaning here as under U.S. copyright law. A \"contribution\" is the original software, or any additions or changes to the software. A \"contributor\" is any person that distributes its contribution under this license. \"Licensed patents\" are a contributor's patent claims that read directly on its contribution.\n\n   2. Grant of Rights\n\n      (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.\n\n      (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.\n\n   3. Conditions and Limitations\n\n      (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.\n\n      (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, your patent license from such contributor to the software ends automatically.\n\n      (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution notices that are present in the software.\n\n      (D) If you distribute any portion of the software in source code form, you may do so only under this license by including a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object code form, you may only do so under a license that complies with this license.\n\n      (E) The software is licensed \"as-is.\" You bear the risk of using it. The contributors give no express warranties, guarantees, or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular purpose and non-infringement."],"licenseIds":["MS-PL"],"keywords":["microsoft public license","public license ms","license ms pl","ms pl this","pl this license","limitations a no","or trademarks b","trademarks b if","automatically c if","the software d","software d if","license e the","e the software","microsoft public license ms","public license ms pl","license ms pl this","ms pl this license","pl this license governs","and limitations a no","limitations a no trademark","a no trademark license","logo or trademarks b","or trademarks b if","trademarks b if you","software ends automatically c","ends automatically c if","automatically c if you","in the software d","the software d if","software d if you","with this license e","this license e the","license e the software","e the software is","microsoft public license ms pl","public license ms pl this","license ms pl this license","ms pl this license governs","pl this license governs use","conditions and limitations a no","and limitations a no trademark","limitations a no trademark license","a no trademark license this","name logo or trademarks b","logo or trademarks b if","or trademarks b if you","trademarks b if you bring","the software ends automatically c","software ends automatically c if","ends automatically c if you","automatically c if you distribute","c if you distribute any","present in the software d","in the software d if","the software d if you","software d if you distribute","complies with this license e","with this license e the","this license e the software","license e the software is","e the software is licensed"]},{"licenseTexts":["Microsoft Reciprocal License (Ms-RL)\n\nThis license governs use of the accompanying software. If you use the software, you accept this license. If you do not accept the license, do not use the software.\n\n   1. Definitions\n\n   The terms \"reproduce,\" \"reproduction,\" \"derivative works,\" and \"distribution\" have the same meaning here as under U.S. copyright law.\n\n   A \"contribution\" is the original software, or any additions or changes to the software.\n\n   A \"contributor\" is any person that distributes its contribution under this license.\n\n   \"Licensed patents\" are a contributor's patent claims that read directly on its contribution.\n\n   2. Grant of Rights\n\n      (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.\n\n      (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.\n\n   3. Conditions and Limitations\n\n      (A) Reciprocal Grants- For any file you distribute that contains code from the software (in source code or binary format), you must provide recipients the source code to that file along with a copy of this license, which license will govern that file. You may license other files that are entirely your own work and do not contain code from the software under any terms you choose.\n\n      (B) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.\n\n      (C) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, your patent license from such contributor to the software ends automatically.\n\n      (D) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution notices that are present in the software.\n\n      (E) If you distribute any portion of the software in source code form, you may do so only under this license by including a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object code form, you may only do so under a license that complies with this license.\n\n      (F) The software is licensed \"as-is.\" You bear the risk of using it. The contributors give no express warranties, guarantees, or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular purpose and non-infringement."],"licenseIds":["MS-RL"],"keywords":["microsoft reciprocal license","reciprocal license ms","license ms rl","ms rl this","rl this license","limitations a reciprocal","a reciprocal grants","reciprocal grants for","grants for any","for any file","file you distribute","you distribute that","distribute that contains","that contains code","contains code from","or binary format","binary format you","must provide recipients","recipients the source","code to that","to that file","that file along","license which license","which license will","license will govern","will govern that","govern that file","may license other","license other files","other files that","own work and","work and do","do not contain","not contain code","contain code from","you choose b","choose b no","b no trademark","or trademarks c","trademarks c if","ends automatically d","automatically d if","the software e","software e if","license f the","f the software","microsoft reciprocal license ms","reciprocal license ms rl","license ms rl this","ms rl this license","rl this license governs","and limitations a reciprocal","limitations a reciprocal grants","a reciprocal grants for","reciprocal grants for any","grants for any file","for any file you","any file you distribute","file you distribute that","you distribute that contains","distribute that contains code","that contains code from","contains code from the","from the software in","code or binary format","or binary format you","binary format you must","format you must provide","you must provide recipients","must provide recipients the","provide recipients the source","recipients the source code","source code to that","code to that file","to that file along","that file along with","file along with a","along with a copy","this license which license","license which license will","which license will govern","license will govern that","will govern that file","govern that file you","file you may license","you may license other","may license other files","license other files that","other files that are","your own work and","own work and do","work and do not","and do not contain","do not contain code","not contain code from","contain code from the","from the software under","software under any terms","terms you choose b","you choose b no","choose b no trademark","b no trademark license","logo or trademarks c","or trademarks c if","trademarks c if you","c if you bring","software ends automatically d","ends automatically d if","automatically d if you","in the software e","the software e if","software e if you","e if you distribute","with this license f","this license f the","license f the software","f the software is","microsoft reciprocal license ms rl","reciprocal license ms rl this","license ms rl this license","ms rl this license governs","rl this license governs use","conditions and limitations a reciprocal","and limitations a reciprocal grants","limitations a reciprocal grants for","a reciprocal grants for any","reciprocal grants for any file","grants for any file you","for any file you distribute","any file you distribute that","file you distribute that contains","you distribute that contains code","distribute that contains code from","that contains code from the","contains code from the software","code from the software in","from the software in source","source code or binary format","code or binary format you","or binary format you must","binary format you must provide","format you must provide recipients","you must provide recipients the","must provide recipients the source","provide recipients the source code","recipients the source code to","the source code to that","source code to that file","code to that file along","to that file along with","that file along with a","file along with a copy","along with a copy of","copy of this license which","of this license which license","this license which license will","license which license will govern","which license will govern that","license will govern that file","will govern that file you","govern that file you may","that file you may license","file you may license other","you may license other files","may license other files that","license other files that are","other files that are entirely","entirely your own work and","your own work and do","own work and do not","work and do not contain","and do not contain code","do not contain code from","not contain code from the","contain code from the software","code from the software under","from the software under any","the software under any terms","software under any terms you","any terms you choose b","terms you choose b no","you choose b no trademark","choose b no trademark license","b no trademark license this","name logo or trademarks c","logo or trademarks c if","or trademarks c if you","trademarks c if you bring","c if you bring a","the software ends automatically d","software ends automatically d if","ends automatically d if you","automatically d if you distribute","present in the software e","in the software e if","the software e if you","software e if you distribute","e if you distribute any","complies with this license f","with this license f the"]},{"licenseTexts":["Software License for MTL Copyright (c) 2007 The Trustees of Indiana University.\n\n2008 Dresden University of Technology and the Trustees of Indiana University.\n\n2010 SimuNova UG (haftungsbeschränkt), www.simunova.com.\n\nAll rights reserved.\n\nAuthors: Peter Gottschling and Andrew Lumsdaine\n\nThis file is part of the Matrix Template Library\n\nDresden University of Technology -- short TUD -- and Indiana University -- short IU -- have the exclusive rights to license this product under the following license.\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   1. All redistributions of source code must retain the above copyright notice, the list of authors in the original source code, this list of conditions and the disclaimer listed in this license;\n\n   2. All redistributions in binary form must reproduce the above copyright notice, this list of conditions and the disclaimer listed in this license in the documentation and/or other materials provided with the distribution;\n\n   3. Any documentation included with all redistributions must include the following acknowledgement:\n\n   \"This product includes software developed at the University of Notre Dame, the Pervasive Technology Labs at Indiana University, and Dresden University of Technology. For technical information contact Andrew Lumsdaine at the Pervasive Technology Labs at Indiana University. For administrative and license questions contact the Advanced Research and Technology Institute at 1100 Waterway Blvd. Indianapolis, Indiana 46202, phone 317-274-5905, fax 317-274-5902.\"\n\n   Alternatively, this acknowledgement may appear in the software itself, and wherever such third-party acknowledgments normally appear.\n\n   4. The name \"MTL\" shall not be used to endorse or promote products derived from this software without prior written permission from IU or TUD. For written permission, please contact Indiana University Advanced Research \u0026 Technology Institute.\n\n   5. Products derived from this software may not be called \"MTL\", nor may \"MTL\" appear in their name, without prior written permission of Indiana University Advanced Research \u0026 Technology Institute.\n\nTUD and IU provide no reassurances that the source code provided does not infringe the patent or any other intellectual property rights of any other entity. TUD and IU disclaim any liability to any recipient for claims brought by any other entity based on infringement of intellectual property rights or otherwise.\n\nLICENSEE UNDERSTANDS THAT SOFTWARE IS PROVIDED \"AS IS\" FOR WHICH NO WARRANTIES AS TO CAPABILITIES OR ACCURACY ARE MADE. DRESDEN UNIVERSITY OF TECHNOLOGY AND INDIANA UNIVERSITY GIVE NO WARRANTIES AND MAKE NO REPRESENTATION THAT SOFTWARE IS FREE OF INFRINGEMENT OF THIRD PARTY PATENT, COPYRIGHT, OR OTHER PROPRIETARY RIGHTS. DRESDEN UNIVERSITY OF TECHNOLOGY AND INDIANA UNIVERSITY MAKE NO WARRANTIES THAT SOFTWARE IS FREE FROM \"BUGS\", \"VIRUSES\", \"TROJAN HORSES\", \"TRAP DOORS\", \"WORMS\", OR OTHER HARMFUL CODE. LICENSEE ASSUMES THE ENTIRE RISK AS TO THE PERFORMANCE OF SOFTWARE AND/OR ASSOCIATED MATERIALS, AND TO THE PERFORMANCE AND VALIDITY OF INFORMATION GENERATED USING SOFTWARE."],"licenseIds":["MTLL"],"keywords":["software license for","license for mtl","for mtl copyright","mtl copyright c","c 2007 the","2007 the trustees","indiana university 2008","university 2008 dresden","2008 dresden university","technology and the","and the trustees","indiana university 2010","university 2010 simunova","2010 simunova ug","simunova ug haftungsbeschr","ug haftungsbeschr nkt","haftungsbeschr nkt www","nkt www simunova","www simunova com","simunova com all","rights reserved authors","reserved authors peter","authors peter gottschling","peter gottschling and","gottschling and andrew","and andrew lumsdaine","andrew lumsdaine this","lumsdaine this file","of the matrix","the matrix template","matrix template library","template library dresden","library dresden university","of technology short","technology short tud","short tud and","tud and indiana","indiana university short","university short iu","short iu have","iu have the","have the exclusive","exclusive rights to","rights to license","license this product","this product under","following license redistribution","university of notre","of notre dame","notre dame the","dame the pervasive","indiana university and","university and dresden","and dresden university","of technology for","technology for technical","for technical information","technical information contact","information contact andrew","contact andrew lumsdaine","andrew lumsdaine at","lumsdaine at the","at the pervasive","university for administrative","for administrative and","administrative and license","and license questions","license questions contact","questions contact the","contact the advanced","the advanced research","advanced research and","research and technology","and technology institute","technology institute at","institute at 1100","at 1100 waterway","1100 waterway blvd","waterway blvd indianapolis","blvd indianapolis indiana","indianapolis indiana 46202","indiana 46202 phone","46202 phone 317","phone 317 274","317 274 5905","274 5905 fax","5905 fax 317","fax 317 274","317 274 5902","274 5902 alternatively","5902 alternatively this","alternatively this acknowledgement","this acknowledgement may","acknowledgement may appear","the name mtl","name mtl shall","mtl shall not","permission from iu","from iu or","iu or tud","or tud for","tud for written","please contact indiana","contact indiana university","technology institute 5","institute 5 products","be called mtl","called mtl nor","mtl nor may","nor may mtl","may mtl appear","mtl appear in","permission of indiana","technology institute tud","institute tud and","and iu provide","iu provide no","other entity tud","entity tud and","and iu disclaim","iu disclaim any","are made dresden","made dresden university","indiana university give","university give no","give no warranties","warranties and make","and make no","proprietary rights dresden","rights dresden university","indiana university make","make no warranties","software license for mtl","license for mtl copyright","for mtl copyright c","mtl copyright c 2007","copyright c 2007 the","c 2007 the trustees","2007 the trustees of","of indiana university 2008","indiana university 2008 dresden","university 2008 dresden university","2008 dresden university of","of technology and the","technology and the trustees","and the trustees of","of indiana university 2010","indiana university 2010 simunova","university 2010 simunova ug","2010 simunova ug haftungsbeschr","simunova ug haftungsbeschr nkt","ug haftungsbeschr nkt www","haftungsbeschr nkt www simunova","nkt www simunova com","www simunova com all","simunova com all rights","all rights reserved authors","rights reserved authors peter","reserved authors peter gottschling","authors peter gottschling and","peter gottschling and andrew","gottschling and andrew lumsdaine","and andrew lumsdaine this","andrew lumsdaine this file","lumsdaine this file is","part of the matrix","of the matrix template","the matrix template library","matrix template library dresden","template library dresden university","library dresden university of","university of technology short","of technology short tud","technology short tud and","short tud and indiana","tud and indiana university","and indiana university short","indiana university short iu","university short iu have","short iu have the","iu have the exclusive","have the exclusive rights","the exclusive rights to","exclusive rights to license","rights to license this","to license this product","license this product under","this product under the","product under the following","the following license redistribution","following license redistribution and","developed at the university","at the university of","the university of notre","university of notre dame","of notre dame the","notre dame the pervasive","dame the pervasive technology","at indiana university and","indiana university and dresden"]},{"licenseTexts":["MakeIndex Distribution Notice\n\n11/11/1989 Copyright (C) 1989 by Chen \u0026 Harrison International Systems, Inc.\n\nCopyright (C) 1988 by Olivetti Research Center\n\nCopyright (C) 1987 by Regents of the University of California\n\nAuthor:\n\nPehong Chen (phc@renoir.berkeley.edu)\n\nChen \u0026 Harrison International Systems, Inc.\n\nPalo Alto, California\n\nUSA\n\nPermission is hereby granted to make and distribute original copies of this program provided that the copyright notice and this permission notice are preserved and provided that the recipient is not asked to waive or limit his right to redistribute copies as allowed by this permission notice and provided that anyone who receives an executable form of this program is granted access to a machine-readable form of the source code for this program at a cost not greater than reasonable reproduction, shipping, and handling costs. Executable forms of this program distributed without the source code must be accompanied by a conspicuous copy of this permission notice and a statement that tells the recipient how to obtain the source code.\n\nPermission is granted to distribute modified versions of all or part of this program under the conditions above with the additional requirement that the entire modified work must be covered by a permission notice identical to this permission notice. Anything distributed with and usable only in conjunction with something derived from this program, whose useful purpose is to extend or adapt or add capabilities to this program, is to be considered a modified version of this program under the requirement above. Ports of this program to other systems not supported in the distribution are also considered modified versions. All modified versions should be reported back to the author.\n\nThis program is distributed with no warranty of any sort. No contributor accepts responsibility for the consequences of using this program or for whether it serves any particular purpose."],"licenseIds":["MakeIndex"],"keywords":["makeindex distribution notice","distribution notice 11","notice 11 11","11 11 1989","11 1989 copyright","c 1989 by","1989 by chen","by chen harrison","c 1988 by","1988 by olivetti","by olivetti research","olivetti research center","research center copyright","center copyright c","copyright c 1987","c 1987 by","1987 by regents","by regents of","of california author","california author pehong","author pehong chen","pehong chen phc","chen phc renoir","phc renoir berkeley","renoir berkeley edu","berkeley edu chen","edu chen harrison","systems inc palo","inc palo alto","alto california usa","distribute original copies","original copies of","this program provided","are preserved and","preserved and provided","the recipient is","recipient is not","is not asked","not asked to","asked to waive","to waive or","waive or limit","or limit his","limit his right","right to redistribute","redistribute copies as","copies as allowed","allowed by this","by this permission","notice and provided","provided that anyone","who receives an","receives an executable","an executable form","program is granted","is granted access","granted access to","to a machine","for this program","this program at","program at a","a cost not","cost not greater","not greater than","greater than reasonable","than reasonable reproduction","reasonable reproduction shipping","reproduction shipping and","shipping and handling","and handling costs","handling costs executable","costs executable forms","forms of this","this program distributed","program distributed without","distributed without the","by a conspicuous","a conspicuous copy","conspicuous copy of","of this permission","statement that tells","that tells the","tells the recipient","the recipient how","recipient how to","source code permission","code permission is","to distribute modified","conditions above with","the additional requirement","additional requirement that","requirement that the","the entire modified","entire modified work","must be covered","by a permission","to this permission","permission notice anything","notice anything distributed","anything distributed with","distributed with and","with and usable","and usable only","usable only in","only in conjunction","conjunction with something","with something derived","something derived from","from this program","this program whose","program whose useful","whose useful purpose","useful purpose is","purpose is to","is to extend","to extend or","extend or adapt","or adapt or","adapt or add","or add capabilities","add capabilities to","capabilities to this","to this program","program is to","to be considered","considered a modified","under the requirement","the requirement above","requirement above ports","above ports of","ports of this","this program to","program to other","to other systems","other systems not","systems not supported","not supported in","supported in the","distribution are also","are also considered","also considered modified","considered modified versions","modified versions all","versions all modified","all modified versions","modified versions should","versions should be","should be reported","be reported back","reported back to","the author this","distributed with no","any sort no","sort no contributor","no contributor accepts","contributor accepts responsibility","accepts responsibility for","using this program","this program or","program or for","makeindex distribution notice 11","distribution notice 11 11","notice 11 11 1989","11 11 1989 copyright","11 1989 copyright c","copyright c 1989 by","c 1989 by chen","1989 by chen harrison","by chen harrison international","international systems inc copyright","systems inc copyright c","inc copyright c 1988","copyright c 1988 by","c 1988 by olivetti","1988 by olivetti research","by olivetti research center","olivetti research center copyright","research center copyright c","center copyright c 1987","copyright c 1987 by","c 1987 by regents","1987 by regents of","by regents of the","university of california author","of california author pehong","california author pehong chen","author pehong chen phc","pehong chen phc renoir","chen phc renoir berkeley","phc renoir berkeley edu","renoir berkeley edu chen","berkeley edu chen harrison","edu chen harrison international","international systems inc palo","systems inc palo alto","inc palo alto california","palo alto california usa","alto california usa permission","hereby granted to make","make and distribute original"]},{"licenseTexts":["The MirOS Licence Copyright [YEAR] [NAME] [EMAIL]\n\nProvided that these terms and disclaimer and all copyright notices are retained or reproduced in an accompanying document, permission is granted to deal in this work without restriction, including unlimited rights to use, publicly perform, distribute, sell, modify, merge, give away, or sublicence.\n\nThis work is provided \"AS IS\" and WITHOUT WARRANTY of any kind, to the utmost extent permitted by applicable law, neither express nor implied; without malicious intent or gross negligence. In no event may a licensor, author or contributor be held liable for indirect, direct, other damage, loss, or other issues arising in any way out of dealing in the work, even if advised of the possibility of such damage or existence of a defect, except proven that it results out of said person's immediate fault when using the work as intended."],"licenseIds":["MirOS"],"keywords":["the miros licence","miros licence copyright","licence copyright year","copyright year name","year name email","name email provided","email provided that","provided that these","that these terms","terms and disclaimer","and disclaimer and","disclaimer and all","are retained or","retained or reproduced","or reproduced in","reproduced in an","in an accompanying","an accompanying document","accompanying document permission","document permission is","granted to deal","deal in this","this work without","restriction including unlimited","including unlimited rights","unlimited rights to","to use publicly","use publicly perform","perform distribute sell","distribute sell modify","sell modify merge","modify merge give","merge give away","away or sublicence","or sublicence this","sublicence this work","to the utmost","the utmost extent","utmost extent permitted","law neither express","neither express nor","express nor implied","nor implied without","implied without malicious","without malicious intent","malicious intent or","intent or gross","or gross negligence","gross negligence in","negligence in no","no event may","event may a","may a licensor","a licensor author","licensor author or","author or contributor","or contributor be","contributor be held","liable for indirect","for indirect direct","indirect direct other","direct other damage","other damage loss","damage loss or","loss or other","or other issues","other issues arising","issues arising in","out of dealing","of dealing in","dealing in the","damage or existence","or existence of","of a defect","a defect except","defect except proven","except proven that","proven that it","that it results","it results out","results out of","out of said","of said person","said person s","person s immediate","s immediate fault","immediate fault when","fault when using","when using the","using the work","work as intended","the miros licence copyright","miros licence copyright year","licence copyright year name","copyright year name email","year name email provided","name email provided that","email provided that these","provided that these terms","that these terms and","these terms and disclaimer","terms and disclaimer and","and disclaimer and all","disclaimer and all copyright","and all copyright notices","notices are retained or","are retained or reproduced","retained or reproduced in","or reproduced in an","reproduced in an accompanying","in an accompanying document","an accompanying document permission","accompanying document permission is","document permission is granted","is granted to deal","granted to deal in","to deal in this","deal in this work","in this work without","this work without restriction","without restriction including unlimited","restriction including unlimited rights","including unlimited rights to","unlimited rights to use","rights to use publicly","to use publicly perform","use publicly perform distribute","publicly perform distribute sell","perform distribute sell modify","distribute sell modify merge","sell modify merge give","modify merge give away","merge give away or","give away or sublicence","away or sublicence this","or sublicence this work","sublicence this work is","kind to the utmost","to the utmost extent","the utmost extent permitted","utmost extent permitted by","applicable law neither express","law neither express nor","neither express nor implied","express nor implied without","nor implied without malicious","implied without malicious intent","without malicious intent or","malicious intent or gross","intent or gross negligence","or gross negligence in","gross negligence in no","negligence in no event","in no event may","no event may a","event may a licensor","may a licensor author","a licensor author or","licensor author or contributor","author or contributor be","or contributor be held","contributor be held liable","held liable for indirect","liable for indirect direct","for indirect direct other","indirect direct other damage","direct other damage loss","other damage loss or","damage loss or other","loss or other issues","or other issues arising","other issues arising in","issues arising in any","way out of dealing","out of dealing in","of dealing in the","dealing in the work","in the work even","work even if advised","such damage or existence","damage or existence of","or existence of a","existence of a defect","of a defect except","a defect except proven","defect except proven that","except proven that it","proven that it results","that it results out","it results out of","results out of said","out of said person","of said person s","said person s immediate","person s immediate fault","s immediate fault when","immediate fault when using","fault when using the","when using the work","using the work as"]},{"licenseTexts":["MOTOSOTO OPEN SOURCE LICENSE - Version 0.9.1\n\nThis Motosoto Open Source License (the \"License\") applies to \"Community Portal Server\" and related software products as well as any updatesor maintenance releases of that software (\"Motosoto Products\") that are distributed by Motosoto.Com B.V. (\"Licensor\"). Any Motosoto Product licensed pursuant to this License is a \"Licensed Product.\" Licensed Product, in its entirety, is protected by Dutch copyright law. This License identifies the terms under which you may use, copy, distribute or modify Licensed Product and has been submitted to the Open Software Initiative (OSI) for approval. Preamble\n\nThis Preamble is intended to describe, in plain English, the nature and scope of this License. However, this Preamble is not a part of this license. The legal effect of this License is dependent only upon the terms of the License and not this Preamble. This License complies with the Open Source Definition and has been approved by Open Source Initiative. Software distributed under this License may be marked as \"OSI Certified Open Source Software.\"\n\nThis License provides that:\n\n   1. You may use, sell or give away the Licensed Product, alone or as a component of an aggregate software distribution containing programs from several different sources. No royalty or other fee is required.\n\n   2. Both Source Code and executable versions of the Licensed Product, including Modifications made by previous Contributors, are available for your use. (The terms \"Licensed Product,\" \"Modifications,\" \"Contributors\" and \"Source Code\" are defined in the License.)\n\n   3. You are allowed to make Modifications to the Licensed Product, and you can create Derivative Works from it. (The term \"Derivative Works\" is defined in the License.)\n\n   4. By accepting the Licensed Product under the provisions of this License, you agree that any Modifications you make to the Licensed Product and then distribute are governed by the provisions of this License. In particular, you must make the Source Code of your Modifications available to others.\n\n   5. You may use the Licensed Product for any purpose, but the Licensor is not providing you any warranty whatsoever, nor is the Licensor accepting any liability in the event that the Licensed Product doesn't work properly or causes you any injury or damages.\n\n   6. If you sublicense the Licensed Product or Derivative Works, you may charge fees for warranty or support, or for accepting indemnity or liability obligations to your customers. You cannot charge for the Source Code.\n\n   7. If you assert any patent claims against the Licensor relating to the Licensed Product, or if you breach any terms of the License, your rights to the Licensed Product under this License automatically terminate.\n\nYou may use this License to distribute your own Derivative Works, in which case the provisions of this License will apply to your Derivative Works just as they do to the original Licensed Product.\n\nAlternatively, you may distribute your Derivative Works under any other OSI-approved Open Source license, or under a proprietary license of your choice. If you use any license other than this License, however, you must continue to fulfill the requirements of this License (including the provisions relating to publishing the Source Code) for those portions of your Derivative Works that consist of the Licensed Product, including the files containing Modifications.\n\nNew versions of this License may be published from time to time. You may choose to continue to use the license terms in this version of the License or those from the new version. However, only the Licensor has the right to change the License terms as they apply to the Licensed Product. This License relies on precise definitions for certain terms. Those terms are defined when they are first used, and the definitions are repeated for your convenience in a Glossary at the end of the License.\n\nLicense Terms\n\n   1. Grant of License From Licensor.\n\n   Licensor hereby grants you a world-wide, royalty-free, non-exclusive license, subject to third party intellectual property claims, to do the following:\n\n      a. Use, reproduce, modify, display, perform, sublicense and distribute Licensed Product or portions thereof (including Modifications as hereinafter defined), in both Source Code or as an executable program. \"Source Code\" means the preferred form for making modifications to the Licensed Product, including all modules contained therein, plus any associated interface definition files, scripts used to control compilation and installation of an executable program, or a list of differential comparisons against the Source Code of the Licensed Product.\n\n      b. Create Derivative Works (as that term is defined under Dutch copyright law) of Licensed Product by adding to or deleting from the substance or structure of said Licensed Product.\n\n      c. Under claims of patents now or hereafter owned or controlled by Licensor, to make, use, sell, offer for sale, have made, and/or otherwise dispose of Licensed Product or portions thereof, but solely to the extent that any such claim is necessary to enable you to make, use, sell, offer for sale, have made, and/or otherwise dispose of Licensed Product or portions thereof or Derivative Works thereof.\n\n   2. Grant of License to Modifications From Contributor.\n\n   \"Modifications\" means any additions to or deletions from the substance or structure of (i) a file containing Licensed Product, or (ii) any new file that contains any part of Licensed Product. Hereinafter in this License, the term \"Licensed Product\" shall include all previous Modifications that you receive from any Contributor. By application of the provisions in Section 4(a) below, each person or entity who created or contributed to the creation of, and distributed, a Modification (a \"Contributor\") hereby grants you a world-wide, royalty-free, non-exclusive license, subject to third party intellectual property claims, to do the following:\n\n      a. Use, reproduce, modify, display, perform, sublicense and distribute any Modifications created by such Contributor or portions thereof, in both Source Code or as an executable program, either on an unmodified basis or as part of Derivative Works.\n\n      b. Under claims of patents now or hereafter owned or controlled by Contributor, to make, use, sell, offer for sale, have made, and/or otherwise dispose of Modifications or portions thereof, but solely to the extent that any such claim is necessary to enable you to make, use, sell, offer for sale, have made, and/or otherwise dispose of Modifications or portions thereof or Derivative Works thereof.\n\n   3. Exclusions From License Grant.\n\n   Nothing in this License shall be deemed to grant any rights to trademarks, copyrights, patents, trade secrets or any other intellectual property of Licensor or any Contributor except as expressly stated herein. No patent license is granted separate from the Licensed Product, for code that you delete from the Licensed Product, or for combinations of the Licensed Product with other software or hardware. No right is granted to the trademarks of Licensor or any Contributor even if such marks are included in the Licensed Product. Nothing in this License shall be interpreted to prohibit Licensor from licensing under different terms from this License any code that Licensor otherwise would have a right to license.\n\n   4. Your Obligations Regarding Distribution.\n\n      a. Application of This License to Your Modifications. As an express condition for your use of the Licensed Product, you hereby agree that any Modifications that you create or to which you contribute, and which you distribute, are governed by the terms of this License including, without limitation, Section 2. Any Modifications that you create or to which you contribute may be distributed only under the terms of this License or a future version of this License released under Section 7. You must include a copy of this License with every copy of the Modifications you distribute. You agree not to offer or impose any terms on any Source Code or executable version of the Licensed Product or Modifications that alter or restrict the applicable version of this License or the recipients' rights hereunder. However, you may include an additional document offering the additional rights described in Section 4(e).\n\n      b. Availability of Source Code. You must make available, under the terms of this License, the Source Code of the Licensed Product and any Modifications that you distribute, either on the same media as you distribute any executable or other form of the Licensed Product, or via a mechanism generally accepted in the software development community for the electronic transfer of data (an \"Electronic Distribution Mechanism\"). The Source Code for any version of Licensed Product or Modifications that you distribute must remain available for at least twelve (12) months after the date it initially became available, or at least six (6) months after a subsequent version of said Licensed Product or Modifications has been made available. You are responsible for ensuring that the Source Code version remains available even if the Electronic Distribution Mechanism is maintained by a third party.\n\n      c. Description of Modifications. You must cause any Modifications that you create or to which you contribute, and which you distribute, to contain a file documenting the additions, changes or deletions you made to create or contribute to those Modifications, and the dates of any such additions, changes or deletions. You must include a prominent statement that the Modifications are derived, directly or indirectly, from the Licensed Product and include the names of the Licensor and any Contributor to the Licensed Product in (i) the Source Code and (ii) in any notice displayed by a version of the Licensed Product you distribute or in related documentation in which you describe the origin or ownership of the Licensed Product. You may not modify or delete any preexisting copyright notices in the Licensed Product.\n\n      d. Intellectual Property Matters.\n\n         i. Third Party Claims. If you have knowledge that a license to a third party's intellectual property right is required to exercise the rights granted by this License, you must include a text file with the Source Code distribution titled \"LEGAL\" that describes the claim and the party making the claim in sufficient detail that a recipient will know whom to contact. If you obtain such knowledge after you make any Modifications available as described in Section 4(b), you shall promptly modify the LEGAL file in all copies you make available thereafter and shall take other steps (such as notifying appropriate mailing lists or newsgroups) reasonably calculated to inform those who received the Licensed Product from you that new knowledge has been obtained.\n\n         ii. Contributor APIs. If your Modifications include an application programming interface (\"API\") and you have knowledge of patent licenses that are reasonably necessary to implement that API, you must also include this information in the LEGAL file.\n\n         iii. Representations. You represent that, except as disclosed pursuant to 4(d)(i) above, you believe that any Modifications you distribute are your original creations and that you have sufficient rights to grant the rights conveyed by this License.\n\n      e. Required Notices. You must duplicate this License in any documentation you provide along with the Source Code of any Modifications you create or to which you contribute, and which you distribute, wherever you describe recipients' rights relating to Licensed Product. You must duplicate the notice contained in Exhibit A (the \"Notice\") in each file of the Source Code of any copy you distribute of the Licensed Product. If you created a Modification, you may add your name as a Contributor to the Notice. If it is not possible to put the Notice in a particular Source Code file due to its structure, then you must include such Notice in a location (such as a relevant directory file) where a user would be likely to look for such a notice. You may choose to offer, and charge a fee for, warranty, support, indemnity or liability obligations to one or more recipients of Licensed Product. However, you may do so only on your own behalf, and not on behalf of the Licensor or any Contributor. You must make it clear that any such warranty, support, indemnity or liability obligation is offered by you alone, and you hereby agree to indemnify the Licensor and every Contributor for any liability incurred by the Licensor or such Contributor as a result of warranty, support, indemnity or liability terms you offer.\n\n      f. Distribution of Executable Versions. You may distribute Licensed Product as an executable program under a license of your choice that may contain terms different from this License provided (i) you have satisfied the requirements of Sections 4(a) through 4(e) for that distribution, (ii) you include a conspicuous notice in the executable version, related documentation and collateral materials stating that the Source Code version of the Licensed Product is available under the terms of this License, including a description of how and where you have fulfilled the obligations of Section 4(b), (iii) you retain all existing copyright notices in the Licensed Product, and (iv) you make it clear that any terms that differ from this License are offered by you alone, not by Licensor or any Contributor. You hereby agree to indemnify the Licensor and every Contributor for any liability incurred by Licensor or such Contributor as a result of any terms you offer.\n\n      g. Distribution of Derivative Works. You may create Derivative Works (e.g., combinations of some or all of the Licensed Product with other code) and distribute the Derivative Works as products under any other license you select, with the proviso that the requirements of this License are fulfilled for those portions of the Derivative Works that consist of the Licensed Product or any Modifications thereto.\n\n   5. Inability to Comply Due to Statute or Regulation.\n\n   If it is impossible for you to comply with any of the terms of this License with respect to some or all of the Licensed Product due to statute, judicial order, or regulation, then you must (i) comply with the terms of this License to the maximum extent possible, (ii) cite the statute or regulation that prohibits you from adhering to the License, and (iii) describe the limitations and the code they affect. Such description must be included in the LEGAL file described in Section 4(d), and must be included with all distributions of the Source Code. Except to the extent prohibited by statute or regulation, such description must be sufficiently detailed for a recipient of ordinary skill at computer programming to be able to understand it.\n\n   6. Application of This License.\n\n   This License applies to code to which Licensor or Contributor has attached the Notice in Exhibit A, which is incorporated herein by this reference.\n\n   7. Versions of This License.\n\n      a. Version. The Motosoto Open Source License is derived from the Jabber Open Source License. All changes are related to applicable law and the location of court.\n\n      b. New Versions. Licensor may publish from time to time revised and/or new versions of the License.\n\n      c. Effect of New Versions. Once Licensed Product has been published under a particular version of the License, you may always continue to use it under the terms of that version. You may also choose to use such Licensed Product under the terms of any subsequent version of the License published by Licensor. No one other than Lic ensor has the right to modify the terms applicable to Licensed Product created under this License.\n\n      d. Derivative Works of this License. If you create or use a modified version of this License, which you may do only in order to apply it to software that is not already a Licensed Product under this License, you must rename your license so that it is not confusingly similar to this License, and must make it clear that your license contains terms that differ from this License. In so naming your license, you may not use any trademark of Licensor or any Contributor.\n\n   8. Disclaimer of Warranty.\n\n   LICENSED PRODUCT IS PROVIDED UNDER THIS LICENSE ON AN \"AS IS\" BASIS, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES THAT THE LICENSED PRODUCT IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE LICENSED PRODUCT IS WITH YOU. SHOULD LICENSED PRODUCT PROVE DEFECTIVE IN ANY RESPECT, YOU (AND NOT THE LICENSOR OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. NO USE OF LICENSED PRODUCT IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER.\n\n   9. Termination.\n\n      a. Automatic Termination Upon Breach. This license and the rights granted hereunder will terminate automatically if you fail to comply with the terms herein and fail to cure such breach within thirty (30) days of becoming aware of the breach. All sublicenses to the Licensed Product that are properly granted shall survive any termination of this license. Provisions that, by their nature, must remain in effect beyond the termination of this License, shall survive.\n\n      b. Termination Upon Assertion of Patent Infringement. If you initiate litigation by asserting a patent infringement claim (excluding declaratory judgment actions) against Licensor or a Contributor (Licensor or Contributor against whom you file such an action is referred to herein as \"Respondent\") alleging that Licensed Product directly or indirectly infringes any patent, then any and all rights granted by such Respondent to you under Sections 1 or 2 of this License shall terminate prospectively upon sixty (60) days notice from Respondent (the \"Notice Period\") unless within that Notice Period you either agree in writing (i) to pay Respondent a mutually agreeable reasonably royalty for your past or future use of Licensed Product made by such Respondent, or (ii) withdraw your litigation claim with respect to Licensed Product against such Respondent. If within said Notice Period a reasonable royalty and payment arrangement are not mutually agreed upon in writing by the parties or the litigation claim is not withdrawn, the rights granted by Licensor to you under Sections 1 and 2 automatically terminate at the expiration of said Notice Period.\n\n      c. Reasonable Value of This License. If you assert a patent infringement claim against Respondent alleging that Licensed Product directly or indirectly infringes any patent where such claim is resolved (such as by license or settlement) prior to the initiation of patent infringement litigation, then the reasonable value of the licenses granted by said Respondent under Sections 1 and 2 shall be taken into account in determining the amount or value of any payment or license.\n\n      d. No Retroactive Effect of Termination. In the event of termination under Sections 9(a) or 9(b) above, all end user license agreements (excluding licenses to distributors and reselle rs) that have been validly granted by you or any distributor hereunder prior to termination shall survive termination.\n\n   10. Limitation of Liability.\n\nUNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER TORT (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL THE LICENSOR, ANY CONTRIBUTOR, OR ANY DISTRIBUTOR OF LICENSED PRODUCT, OR ANY SUPPLIER OF ANY OF SUCH PARTIES, BE LIABLE TO ANY PERSON FOR ANY INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, COMPUTER FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER COMMERCIAL DAMAGES OR LOSSES, EVEN IF SUCH PARTY SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF LIABILITY SHALL NOT APPLY TO LIABILITY FOR DEATH OR PERSONAL INJURY RESULTING FROM SUCH PARTY"],"licenseIds":["Motosoto"],"keywords":["0 9 1","1 this motosoto","this motosoto open","applies to community","to community portal","community portal server","portal server and","server and related","as any updatesor","any updatesor maintenance","updatesor maintenance releases","that software motosoto","software motosoto products","motosoto products that","distributed by motosoto","by motosoto com","motosoto com b","com b v","b v licensor","v licensor any","licensor any motosoto","any motosoto product","motosoto product licensed","protected by dutch","by dutch copyright","product and has","has been submitted","been submitted to","submitted to the","open software initiative","software initiative osi","initiative osi for","osi for approval","for approval preamble","approval preamble this","definition and has","source initiative software","initiative software distributed","may be marked","marked as osi","as osi certified","source software this","including modifications as","modifications as hereinafter","as hereinafter defined","hereinafter defined in","defined in both","executable program source","licensed product b","product b create","b create derivative","defined under dutch","under dutch copyright","licensed product by","product by adding","licensed product c","product c under","c under claims","4 e b","e b availability","party c description","c description of","you distribute to","distribute to contain","contribute to those","to those modifications","those modifications and","product and include","product in i","displayed by a","product you distribute","product you may","delete any preexisting","any preexisting copyright","preexisting copyright notices","licensed product d","product d intellectual","d intellectual property","to 4 d","4 d i","d i above","license e required","e required notices","through 4 e","4 e for","e for that","4 b iii","b iii you","iii you retain","retain all existing","all existing copyright","product and iv","and iv you","iv you make","you offer g","offer g distribution","g distribution of","license a version","a version the","version the motosoto","the motosoto open","source license is","source license all","license all changes","all changes are","changes are related","are related to","related to applicable","location of court","of court b","court b new","b new versions","the license c","license c effect","c effect of","other than lic","than lic ensor","lic ensor has","ensor has the","license d derivative","d derivative works","distributors and reselle","and reselle rs","reselle rs that","rs that have","version 0 9 1","0 9 1 this","9 1 this motosoto","1 this motosoto open","this motosoto open source","license applies to community","applies to community portal","to community portal server","community portal server and","portal server and related","server and related software","well as any updatesor","as any updatesor maintenance","any updatesor maintenance releases","updatesor maintenance releases of","of that software motosoto","that software motosoto products","software motosoto products that","motosoto products that are","are distributed by motosoto","distributed by motosoto com","by motosoto com b","motosoto com b v","com b v licensor","b v licensor any","v licensor any motosoto","licensor any motosoto product","any motosoto product licensed","motosoto product licensed pursuant","is protected by dutch","protected by dutch copyright","by dutch copyright law","dutch copyright law this","modify licensed product and","licensed product and has","product and has been","and has been submitted","has been submitted to","been submitted to the","submitted to the open","to the open software","the open software initiative","open software initiative osi","software initiative osi for","initiative osi for approval","osi for approval preamble","for approval preamble this","approval preamble this preamble","source definition and has","definition and has been","and has been approved","open source initiative software","source initiative software distributed","initiative software distributed under","software distributed under this","license may be marked","may be marked as","be marked as osi","marked as osi certified","as osi certified open","open source software this","source software this license","software this license provides","and distribute licensed product","distribute licensed product or","thereof including modifications as","including modifications as hereinafter","modifications as hereinafter defined","as hereinafter defined in","hereinafter defined in both","defined in both source","an executable program source","executable program source code","program source code means","the licensed product b"]},{"licenseTexts":["木兰宽松许可证, 第1版 木兰宽松许可证， 第1版\n\n2019年8月 http://license.coscl.org.cn/MulanPSL\n\n您对\"软件\"的复制、使用、修改及分发受木兰宽松许可证，第1版（\"本许可证\"）的如下条款的约束：\n\n   0. 定义\n\n   \"软件\"是指由\"贡献\"构成的许可在\"本许可证\"下的程序和相关文档的集合。\n\n   \"贡献者\"是指将受版权法保护的作品许可在\"本许可证\"下的自然人或\"法人实体\"。\n\n   \"法人实体\"是指提交贡献的机构及其\"关联实体\"。\n\n   \"关联实体\"是指，对\"本许可证\"下的一方而言，控制、受控制或与其共同受控制的机构，此处的控制是指有受控方或共同受控方至少50%直接或间接的投票权、资金或其他有价证券。\n\n   \"贡献\"是指由任一\"贡献者\"许可在\"本许可证\"下的受版权法保护的作品。\n\n   1. 授予版权许可\n\n   每个\"贡献者\"根据\"本许可证\"授予您永久性的、全球性的、免费的、非独占的、不可撤销的版权许可，您可以复制、使用、修改、分发其\"贡献\"，不论修改与否。\n\n   2. 授予专利许可\n\n   每个\"贡献者\"根据\"本许可证\"授予您永久性的、全球性的、免费的、非独占的、不可撤销的（根据本条规定撤销除外）专利许可，供您制造、委托制造、使用、许诺销售、销售、进口其\"贡献\"或以其他方式转移其\"贡献\"。前述专利许可仅限于\"贡献者\"现在或将来拥有或控制的其\"贡献\"本身或其\"贡献\"与许可\"贡献\"时的\"软件\"结合而将必然会侵犯的专利权利要求，不包括仅因您或他人修改\"贡献\"或其他结合而将必然会侵犯到的专利权利要求。如您或您的\"关联实体\"直接或间接地（包括通过代理、专利被许可人或受让人），就\"软件\"或其中的\"贡献\"对任何人发起专利侵权诉讼（包括反诉或交叉诉讼）或其他专利维权行动，指控其侵犯专利权，则\"本许可证\"授予您对\"软件\"的专利许可自您提起诉讼或发起维权行动之日终止。\n\n   3. 无商标许可\n\n   \"本许可证\"不提供对\"贡献者\"的商品名称、商标、服务标志或产品名称的商标许可，但您为满足第4条规定的声明义务而必须使用除外。\n\n   4. 分发限制\n\n   您可以在任何媒介中将\"软件\"以源程序形式或可执行形式重新分发，不论修改与否，但您必须向接收者提供\"本许可证\"的副本，并保留\"软件\"中的版权、商标、专利及免责声明。\n\n   5. 免责声明与责任限制\n\n   \"软件\"及其中的\"贡献\"在提供时不带任何明示或默示的担保。在任何情况下，\"贡献者\"或版权所有者不对任何人因使用\"软件\"或其中的\"贡献\"而引发的任何直接或间接损失承担责任，不论因何种原因导致或者基于何种法律理论,即使其曾被建议有此种损失的可能性。\n\n条款结束\n\n如何将木兰宽松许可证，第1版，应用到您的软件\n\n如果您希望将木兰宽松许可证，第1版，应用到您的新软件，为了方便接收者查阅，建议您完成如下三步：\n\n   1， 请您补充如下声明中的空白，包括软件名、软件的首次发表年份以及您作为版权人的名字；\n\n   2， 请您在软件包的一级目录下创建以\"LICENSE\"为名的文件，将整个许可证文本放入该文件中；\n\n   3， 请将如下声明文本放入每个源文件的头部注释中。\n\nCopyright (c) [2019] [name of copyright holder]\n\n[Software Name] is licensed under the Mulan PSL v1.\n\nYou can use this software according to the terms and conditions of the Mulan PSL v1.\n\nYou may obtain a copy of Mulan PSL v1 at:\n\nhttp://license.coscl.org.cn/MulanPSL\n\nTHIS SOFTWARE IS PROVIDED ON AN \"AS IS\" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.\n\nSee the Mulan PSL v1 for more details. Mulan Permissive Software License，Version 1 Mulan Permissive Software License，Version 1 (Mulan PSL v1)\n\nAugust 2019 http://license.coscl.org.cn/MulanPSL\n\nYour reproduction, use, modification and distribution of the Software shall be subject to Mulan PSL v1 (this License) with following terms and conditions:\n\n   0. Definition\n\n   Software means the program and related documents which are comprised of those Contribution and licensed under this License.\n\n   Contributor means the Individual or Legal Entity who licenses its copyrightable work under this License.\n\n   Legal Entity means the entity making a Contribution and all its Affiliates.\n\n   Affiliates means entities that control, or are controlled by, or are under common control with a party to this License, 'control' means direct or indirect ownership of at least fifty percent (50%) of the voting power, capital or other securities of controlled or commonly controlled entity.\n\n   Contribution means the copyrightable work licensed by a particular Contributor under this License.\n\n   1. Grant of Copyright License\n\n   Subject to the terms and conditions of this License, each Contributor hereby grants to you a perpetual, worldwide, royalty-free, non-exclusive, irrevocable copyright license to reproduce, use, modify, or distribute its Contribution, with modification or not.\n\n   2. Grant of Patent License\n\n   Subject to the terms and conditions of this License, each Contributor hereby grants to you a perpetual, worldwide, royalty-free, non-exclusive, irrevocable (except for revocation under this Section) patent license to make, have made, use, offer for sale, sell, import or otherwise transfer its Contribution where such patent license is only limited to the patent claims owned or controlled by such Contributor now or in future which will be necessarily infringed by its Contribution alone, or by combination of the Contribution with the Software to which the Contribution was contributed, excluding of any patent claims solely be infringed by your or others' modification or other combinations. If you or your Affiliates directly or indirectly (including through an agent, patent licensee or assignee）, institute patent litigation (including a cross claim or counterclaim in a litigation) or other patent enforcement activities against any individual or entity by alleging that the Software or any Contribution in it infringes patents, then any patent license granted to you under this License for the Software shall terminate as of the date such litigation or activity is filed or taken.\n\n   3. No Trademark License\n\n   No trademark license is granted to use the trade names, trademarks, service marks, or product names of Contributor, except as required to fulfill notice requirements in section 4.\n\n   4. Distribution Restriction\n\n   You may distribute the Software in any medium with or without modification, whether in source or executable forms, provided that you provide recipients with a copy of this License and retain copyright, patent, trademark and disclaimer statements in the Software.\n\n   5. Disclaimer of Warranty and Limitation of Liability\n\n   The Software and Contribution in it are provided without warranties of any kind, either express or implied. In no event shall any Contributor or copyright holder be liable to you for any damages,including, but not limited to any direct, or indirect, special or consequential damages arising from your use or inability to use the Software or the Contribution in it, no matter how it's caused or based on which legal theory, even if advised of the possibility of such damages.\n\nEnd of the Terms and Conditions\n\nHow to apply the Mulan Permissive Software License，Version 1 (Mulan PSL v1) to your software\n\nTo apply the Mulan PSL v1 to your work, for easy identification by recipients, you are suggested to complete following three steps:\n\n   i. Fill in the blanks in following statement, including insert your software name, the year of the first publication of your software, and your name identified as the copyright owner;\n\n   ii. Create a file named \"LICENSE\" which contains the whole context of this License in the first directory of your software package;\n\n   iii. Attach the statement to the appropriate annotated syntax at the beginning of each source file.\n\nCopyright (c) [2019] [name of copyright holder]\n\n[Software Name] is licensed under the Mulan PSL v1.\n\nYou can use this software according to the terms and conditions of the Mulan PSL v1.\n\nYou may obtain a copy of Mulan PSL v1 at:\n\nhttp://license.coscl.org.cn/MulanPSL\n\nTHIS SOFTWARE IS PROVIDED ON AN \"AS IS\" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.\n\nSee the Mulan PSL v1 for more details."],"licenseIds":["MulanPSL-1.0"],"keywords":["1 1 2019","1 2019 8","2019 8 http","8 http license","cn mulanpsl 1","mulanpsl 1 0","1 0 50","4 5 1","5 1 1","1 1 2","1 mulan permissive","psl v1 august","v1 august 2019","august 2019 http","2019 http license","cn mulanpsl your","mulanpsl your reproduction","psl v1 this","v1 this license","license with following","with following terms","which are comprised","are comprised of","comprised of those","of those contribution","those contribution and","contribution and licensed","that control or","control or are","or are controlled","control with a","with a party","controlled entity contribution","entity contribution means","license 1 grant","was contributed excluding","contributed excluding of","excluding of any","patent claims solely","claims solely be","solely be infringed","by your or","your or others","or others modification","others modification or","or other combinations","other combinations if","combinations if you","or indirectly including","indirectly including through","including through an","through an agent","an agent patent","agent patent licensee","patent licensee or","licensee or assignee","or assignee institute","assignee institute patent","1 1 2019 8","1 2019 8 http","2019 8 http license","8 http license coscl","org cn mulanpsl 1","cn mulanpsl 1 0","mulanpsl 1 0 50","1 0 50 1","4 4 5 1","4 5 1 1","5 1 1 1","1 1 1 2","1 1 2 license","3 copyright c 2019","version 1 mulan permissive","1 mulan permissive software","mulan psl v1 august","psl v1 august 2019","v1 august 2019 http","august 2019 http license","2019 http license coscl","org cn mulanpsl your","cn mulanpsl your reproduction","mulanpsl your reproduction use","to mulan psl v1","mulan psl v1 this","psl v1 this license","v1 this license with","this license with following","license with following terms","with following terms and","documents which are comprised","which are comprised of","are comprised of those","comprised of those contribution","of those contribution and","those contribution and licensed","contribution and licensed under","and licensed under this","entities that control or","that control or are","control or are controlled","or are controlled by","common control with a","control with a party","with a party to","to this license control","commonly controlled entity contribution","controlled entity contribution means","entity contribution means the","this license 1 grant","license 1 grant of","contribution was contributed excluding","was contributed excluding of","contributed excluding of any","excluding of any patent","any patent claims solely","patent claims solely be","claims solely be infringed","solely be infringed by","infringed by your or","by your or others","your or others modification","or others modification or","others modification or other","modification or other combinations","or other combinations if","other combinations if you","combinations if you or","directly or indirectly including","or indirectly including through","indirectly including through an","including through an agent","through an agent patent","an agent patent licensee","agent patent licensee or","patent licensee or assignee","licensee or assignee institute","or assignee institute patent","assignee institute patent litigation","damages end of the","v1 to your software","v1 to your work","file copyright c 2019","1 1 2019 8 http","1 2019 8 http license","2019 8 http license coscl","8 http license coscl org","coscl org cn mulanpsl 1","org cn mulanpsl 1 0","cn mulanpsl 1 0 50","mulanpsl 1 0 50 1","1 0 50 1 2","3 4 4 5 1","4 4 5 1 1","4 5 1 1 1","5 1 1 1 2","1 1 1 2 license","1 1 2 license 3","license 3 copyright c 2019","3 copyright c 2019 name","v1 for more details mulan","license version 1 mulan permissive","version 1 mulan permissive software","1 mulan permissive software license","1 mulan psl v1 august","mulan psl v1 august 2019","psl v1 august 2019 http","v1 august 2019 http license","august 2019 http license coscl","2019 http license coscl org","coscl org cn mulanpsl your","org cn mulanpsl your reproduction","cn mulanpsl your reproduction use","mulanpsl your reproduction use modification","subject to mulan psl v1","to mulan psl v1 this","mulan psl v1 this license","psl v1 this license with","v1 this license with following","this license with following terms","license with following terms and","with following terms and conditions","related documents which are comprised","documents which are comprised of","which are comprised of those","are comprised of those contribution","comprised of those contribution and","of those contribution and licensed","those contribution and licensed under","contribution and licensed under this","and licensed under this license","licensed under this license contributor","means entities that control or","entities that control or are","that control or are controlled","control or are controlled by","or are controlled by or","under common control with a","common control with a party","control with a party to","with a party to this"]},{"licenseTexts":["木兰宽松许可证, 第2版 木兰宽松许可证， 第2版\n\n2020年1月 http://license.coscl.org.cn/MulanPSL2\n\n您对\"软件\"的复制、使用、修改及分发受木兰宽松许可证，第2版（\"本许可证\"）的如下条款的约束：\n\n   0. 定义\n\n   \"软件\" 是指由\"贡献\"构成的许可在\"本许可证\"下的程序和相关文档的集合。\n\n   \"贡献\" 是指由任一\"贡献者\"许可在\"本许可证\"下的受版权法保护的作品。\n\n   \"贡献者\" 是指将受版权法保护的作品许可在\"本许可证\"下的自然人或\"法人实体\"。\n\n   \"法人实体\" 是指提交贡献的机构及其\"关联实体\"。\n\n   \"关联实体\" 是指，对\"本许可证\"下的行为方而言，控制、受控制或与其共同受控制的机构，此处的控制是指有受控方或共同受控方至少50%直接或间接的投票权、资金或其他有价证券。\n\n   1. 授予版权许可\n\n   每个\"贡献者\"根据\"本许可证\"授予您永久性的、全球性的、免费的、非独占的、不可撤销的版权许可，您可以复制、使用、修改、分发其\"贡献\"，不论修改与否。\n\n   2. 授予专利许可\n\n   每个\"贡献者\"根据\"本许可证\"授予您永久性的、全球性的、免费的、非独占的、不可撤销的（根据本条规定撤销除外）专利许可，供您制造、委托制造、使用、许诺销售、销售、进口其\"贡献\"或以其他方式转移其\"贡献\"。前述专利许可仅限于\"贡献者\"现在或将来拥有或控制的其\"贡献\"本身或其\"贡献\"与许可\"贡献\"时的\"软件\"结合而将必然会侵犯的专利权利要求，不包括对\"贡献\"的修改或包含\"贡献\"的其他结合。如果您或您的\"关联实体\"直接或间接地，就\"软件\"或其中的\"贡献\"对任何人发起专利侵权诉讼（包括反诉或交叉诉讼）或其他专利维权行动，指控其侵犯专利权，则\"本许可证\"授予您对\"软件\"的专利许可自您提起诉讼或发起维权行动之日终止。\n\n   3. 无商标许可\n\n   \"本许可证\"不提供对\"贡献者\"的商品名称、商标、服务标志或产品名称的商标许可，但您为满足第4条规定的声明义务而必须使用除外。\n\n   4. 分发限制\n\n   您可以在任何媒介中将\"软件\"以源程序形式或可执行形式重新分发，不论修改与否，但您必须向接收者提供\"本许可证\"的副本，并保留\"软件\"中的版权、商标、专利及免责声明。\n\n   5. 免责声明与责任限制\n\n   \"软件\"及其中的\"贡献\"在提供时不带任何明示或默示的担保。在任何情况下，\"贡献者\"或版权所有者不对任何人因使用\"软件\"或其中的\"贡献\"而引发的任何直接或间接损失承担责任，不论因何种原因导致或者基于何种法律理论，即使其曾被建议有此种损失的可能性。\n\n   6. 语言\n\n   \"本许可证\"以中英文双语表述，中英文版本具有同等法律效力。如果中英文版本存在任何冲突不一致，以中文版为准。\n\n条款结束\n\n如何将木兰宽松许可证，第2版，应用到您的软件\n\n如果您希望将木兰宽松许可证，第2版，应用到您的新软件，为了方便接收者查阅，建议您完成如下三步：\n\n   1， 请您补充如下声明中的空白，包括软件名、软件的首次发表年份以及您作为版权人的名字；\n\n   2， 请您在软件包的一级目录下创建以\"LICENSE\"为名的文件，将整个许可证文本放入该文件中；\n\n   3， 请将如下声明文本放入每个源文件的头部注释中。\n\nCopyright (c) [Year] [name of copyright holder]\n\n[Software Name] is licensed under Mulan PSL v2.\n\nYou can use this software according to the terms and conditions of the Mulan PSL v2.\n\nYou may obtain a copy of Mulan PSL v2 at:\n\nhttp://license.coscl.org.cn/MulanPSL2\n\nTHIS SOFTWARE IS PROVIDED ON AN \"AS IS\" BASIS, WITHOUT WARRANTIES OF ANY KIND,\n\nEITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,\n\nMERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.\n\nSee the Mulan PSL v2 for more details. Mulan Permissive Software License，Version 2 Mulan Permissive Software License，Version 2 (Mulan PSL v2)\n\nJanuary 2020 http://license.coscl.org.cn/MulanPSL2\n\nYour reproduction, use, modification and distribution of the Software shall be subject to Mulan PSL v2 (this License) with the following terms and conditions:\n\n   0. Definition\n\n   Software means the program and related documents which are licensed under this License and comprise all Contribution(s).\n\n   Contribution means the copyrightable work licensed by a particular Contributor under this License.\n\n   Contributor means the Individual or Legal Entity who licenses its copyrightable work under this License.\n\n   Legal Entity means the entity making a Contribution and all its Affiliates.\n\n   Affiliates means entities that control, are controlled by, or are under common control with the acting entity under this License, 'control' means direct or indirect ownership of at least fifty percent (50%) of the voting power, capital or other securities of controlled or commonly controlled entity.\n\n   1. Grant of Copyright License\n\n   Subject to the terms and conditions of this License, each Contributor hereby grants to you a perpetual, worldwide, royalty-free, non-exclusive, irrevocable copyright license to reproduce, use, modify, or distribute its Contribution, with modification or not.\n\n   2. Grant of Patent License\n\n   Subject to the terms and conditions of this License, each Contributor hereby grants to you a perpetual, worldwide, royalty-free, non-exclusive, irrevocable (except for revocation under this Section) patent license to make, have made, use, offer for sale, sell, import or otherwise transfer its Contribution, where such patent license is only limited to the patent claims owned or controlled by such Contributor now or in future which will be necessarily infringed by its Contribution alone, or by combination of the Contribution with the Software to which the Contribution was contributed. The patent license shall not apply to any modification of the Contribution, and any other combination which includes the Contribution. If you or your Affiliates directly or indirectly institute patent litigation (including a cross claim or counterclaim in a litigation) or other patent enforcement activities against any individual or entity by alleging that the Software or any Contribution in it infringes patents, then any patent license granted to you under this License for the Software shall terminate as of the date such litigation or activity is filed or taken.\n\n   3. No Trademark License\n\n   No trademark license is granted to use the trade names, trademarks, service marks, or product names of Contributor, except as required to fulfill notice requirements in section 4.\n\n   4. Distribution Restriction\n\n   You may distribute the Software in any medium with or without modification, whether in source or executable forms, provided that you provide recipients with a copy of this License and retain copyright, patent, trademark and disclaimer statements in the Software.\n\n   5. Disclaimer of Warranty and Limitation of Liability\n\n   THE SOFTWARE AND CONTRIBUTION IN IT ARE PROVIDED WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED. IN NO EVENT SHALL ANY CONTRIBUTOR OR COPYRIGHT HOLDER BE LIABLE TO YOU FOR ANY DAMAGES, INCLUDING, BUT NOT LIMITED TO ANY DIRECT, OR INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES ARISING FROM YOUR USE OR INABILITY TO USE THE SOFTWARE OR THE CONTRIBUTION IN IT, NO MATTER HOW IT'S CAUSED OR BASED ON WHICH LEGAL THEORY, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\n   6. Language\n\n   THIS LICENSE IS WRITTEN IN BOTH CHINESE AND ENGLISH, AND THE CHINESE VERSION AND ENGLISH VERSION SHALL HAVE THE SAME LEGAL EFFECT. IN THE CASE OF DIVERGENCE BETWEEN THE CHINESE AND ENGLISH VERSIONS, THE CHINESE VERSION SHALL PREVAIL.\n\nEND OF THE TERMS AND CONDITIONS\n\nHow to Apply the Mulan Permissive Software License，Version 2 (Mulan PSL v2) to Your Software\n\nTo apply the Mulan PSL v2 to your work, for easy identification by recipients, you are suggested to complete following three steps:\n\n   i. Fill in the blanks in following statement, including insert your software name, the year of the first publication of your software, and your name identified as the copyright owner;\n\n   ii. Create a file named \"LICENSE\" which contains the whole context of this License in the first directory of your software package;\n\n   iii. Attach the statement to the appropriate annotated syntax at the beginning of each source file.\n\nCopyright (c) [Year] [name of copyright holder]\n\n[Software Name] is licensed under Mulan PSL v2.\n\nYou can use this software according to the terms and conditions of the Mulan PSL v2.\n\nYou may obtain a copy of Mulan PSL v2 at:\n\nhttp://license.coscl.org.cn/MulanPSL2\n\nTHIS SOFTWARE IS PROVIDED ON AN \"AS IS\" BASIS, WITHOUT WARRANTIES OF ANY KIND,\n\nEITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,\n\nMERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.\n\nSee the Mulan PSL v2 for more details."],"licenseIds":["MulanPSL-2.0"],"keywords":["2 2 2020","2 2020 1","2020 1 http","1 http license","cn mulanpsl2 2","mulanpsl2 2 0","2 0 50","5 6 2","2 mulan permissive","psl v2 january","v2 january 2020","january 2020 http","2020 http license","cn mulanpsl2 your","mulanpsl2 your reproduction","psl v2 this","v2 this license","which are licensed","license and comprise","and comprise all","comprise all contribution","all contribution s","contribution s contribution","s contribution means","with the acting","acting entity under","entity under this","controlled entity 1","entity 1 grant","was contributed the","contributed the patent","any modification of","contribution and any","any other combination","other combination which","combination which includes","includes the contribution","contribution if you","or indirectly institute","indirectly institute patent","damages 6 language","6 language this","language this license","license is written","written in both","in both chinese","both chinese and","english and the","and the chinese","chinese version and","version and english","and english version","english version shall","version shall have","same legal effect","legal effect in","case of divergence","of divergence between","divergence between the","between the chinese","the chinese and","and english versions","english versions the","versions the chinese","chinese version shall","version shall prevail","shall prevail end","prevail end of","2 2 2020 1","2 2020 1 http","2020 1 http license","1 http license coscl","org cn mulanpsl2 2","cn mulanpsl2 2 0","mulanpsl2 2 0 50","2 0 50 1","4 4 5 6","4 5 6 2","5 6 2 2","6 2 2 1","2 2 1 2","2 1 2 license","3 copyright c year","version 2 mulan permissive","2 mulan permissive software","mulan psl v2 january","psl v2 january 2020","v2 january 2020 http","january 2020 http license","2020 http license coscl","org cn mulanpsl2 your","cn mulanpsl2 your reproduction","mulanpsl2 your reproduction use","to mulan psl v2","mulan psl v2 this","psl v2 this license","v2 this license with","license with the following","documents which are licensed","which are licensed under","are licensed under this","this license and comprise","license and comprise all","and comprise all contribution","comprise all contribution s","all contribution s contribution","contribution s contribution means","s contribution means the","control with the acting","with the acting entity","the acting entity under","acting entity under this","entity under this license","under this license control","commonly controlled entity 1","controlled entity 1 grant","entity 1 grant of","contribution was contributed the","was contributed the patent","contributed the patent license","apply to any modification","to any modification of","any modification of the","modification of the contribution","the contribution and any","contribution and any other","and any other combination","any other combination which","other combination which includes","combination which includes the","which includes the contribution","includes the contribution if","the contribution if you","contribution if you or","directly or indirectly institute","or indirectly institute patent","indirectly institute patent litigation","such damages 6 language","damages 6 language this","6 language this license","language this license is","this license is written","license is written in","is written in both","written in both chinese","in both chinese and","both chinese and english","chinese and english and","and english and the","english and the chinese","and the chinese version","the chinese version and","chinese version and english","version and english version","and english version shall","english version shall have","version shall have the","shall have the same","have the same legal","the same legal effect","same legal effect in","legal effect in the","effect in the case","the case of divergence","case of divergence between","of divergence between the","divergence between the chinese","between the chinese and","the chinese and english","chinese and english versions","and english versions the","english versions the chinese","versions the chinese version","the chinese version shall","chinese version shall prevail","version shall prevail end","shall prevail end of","prevail end of the","v2 to your software","v2 to your work","file copyright c year","2 2 2020 1 http","2 2020 1 http license","2020 1 http license coscl","1 http license coscl org","coscl org cn mulanpsl2 2","org cn mulanpsl2 2 0","cn mulanpsl2 2 0 50","mulanpsl2 2 0 50 1","2 0 50 1 2","3 4 4 5 6","4 4 5 6 2","4 5 6 2 2","5 6 2 2 1","6 2 2 1 2","2 2 1 2 license","2 1 2 license 3","license 3 copyright c year","3 copyright c year name","v2 for more details mulan"]},{"licenseTexts":["Multics License Historical Background\n\nThis edition of the Multics software materials and documentation is provided and donated to Massachusetts Institute of Technology by Group BULL including BULL HN Information Systems Inc. as a contribution to computer science knowledge. This donation is made also to give evidence of the common contributions of Massachusetts Institute of Technology, Bell Laboratories, General Electric, Honeywell Information Systems Inc., Honeywell BULL Inc., Groupe BULL and BULL HN Information Systems Inc. to the development of this operating system. Multics development was initiated by Massachusetts Institute of Technology Project MAC (1963-1970), renamed the MIT Laboratory for Computer Science and Artificial Intelligence in the mid 1970s, under the leadership of Professor Fernando Jose Corbato. Users consider that Multics provided the best software architecture for managing computer hardware properly and for executing programs. Many subsequent operating systems incorporated Multics principles. Multics was distributed in 1975 to 2000 by Group Bull in Europe, and in the U.S. by Bull HN Information Systems Inc., as successor in interest by change in name only to Honeywell Bull Inc. and Honeywell Information Systems Inc. . -----------------------------------------------------------\n\nPermission to use, copy, modify, and distribute these programs and their documentation for any purpose and without fee is hereby granted, provided that the below copyright notice and historical background appear in all copies and that both the copyright notice and historical background and this permission notice appear in supporting documentation, and that the names of MIT, HIS, BULL or BULL HN not be used in advertising or publicity pertaining to distribution of the programs without specific prior written permission. Copyright 1972 by Massachusetts Institute of Technology and Honeywell Information Systems Inc.\n\nCopyright 2006 by BULL HN Information Systems Inc.\n\nCopyright 2006 by Bull SAS All Rights Reserved"],"licenseIds":["Multics"],"keywords":["multics license historical","license historical background","historical background this","background this edition","this edition of","of the multics","the multics software","multics software materials","software materials and","is provided and","provided and donated","and donated to","donated to massachusetts","to massachusetts institute","of technology by","technology by group","group bull including","bull including bull","including bull hn","inc as a","contribution to computer","to computer science","computer science knowledge","science knowledge this","knowledge this donation","this donation is","donation is made","is made also","made also to","also to give","to give evidence","give evidence of","evidence of the","the common contributions","common contributions of","contributions of massachusetts","of massachusetts institute","of technology bell","technology bell laboratories","bell laboratories general","laboratories general electric","general electric honeywell","electric honeywell information","systems inc honeywell","inc honeywell bull","bull inc groupe","inc groupe bull","groupe bull and","bull and bull","and bull hn","systems inc to","inc to the","to the development","of this operating","this operating system","operating system multics","system multics development","multics development was","development was initiated","was initiated by","initiated by massachusetts","of technology project","technology project mac","project mac 1963","mac 1963 1970","1963 1970 renamed","1970 renamed the","renamed the mit","the mit laboratory","mit laboratory for","laboratory for computer","for computer science","computer science and","science and artificial","and artificial intelligence","artificial intelligence in","intelligence in the","in the mid","the mid 1970s","mid 1970s under","1970s under the","under the leadership","the leadership of","leadership of professor","of professor fernando","professor fernando jose","fernando jose corbato","jose corbato users","corbato users consider","users consider that","consider that multics","that multics provided","multics provided the","provided the best","the best software","best software architecture","software architecture for","architecture for managing","for managing computer","managing computer hardware","computer hardware properly","hardware properly and","properly and for","and for executing","for executing programs","executing programs many","programs many subsequent","many subsequent operating","subsequent operating systems","operating systems incorporated","systems incorporated multics","incorporated multics principles","multics principles multics","principles multics was","multics was distributed","was distributed in","distributed in 1975","in 1975 to","1975 to 2000","to 2000 by","2000 by group","group bull in","bull in europe","in europe and","europe and in","u s by","s by bull","inc as successor","as successor in","successor in interest","in interest by","interest by change","by change in","change in name","in name only","name only to","only to honeywell","to honeywell bull","bull inc and","inc and honeywell","systems inc permission","and distribute these","distribute these programs","these programs and","programs and their","and their documentation","their documentation for","that the below","the below copyright","below copyright notice","historical background appear","background appear in","historical background and","background and this","that the names","names of mit","of mit his","mit his bull","his bull or","bull or bull","or bull hn","bull hn not","hn not be","the programs without","programs without specific","written permission copyright","permission copyright 1972","copyright 1972 by","1972 by massachusetts","technology and honeywell","by bull sas","bull sas all","sas all rights","multics license historical background","license historical background this","historical background this edition","background this edition of","this edition of the","edition of the multics","of the multics software","the multics software materials","multics software materials and","software materials and documentation","materials and documentation is","documentation is provided and","is provided and donated","provided and donated to","and donated to massachusetts","donated to massachusetts institute","to massachusetts institute of","institute of technology by","of technology by group","technology by group bull","by group bull including","group bull including bull","bull including bull hn","including bull hn information","systems inc as a","inc as a contribution","as a contribution to"]},{"licenseTexts":["Copyright (c) 1995-2012 by Arkkra Enterprises. All rights reserved.\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following DISCLAIMER.\n\n   2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following DISCLAIMER in the documentation and/or other materials provided with the distribution.\n\n   3. Any additions, deletions, or changes to the original files must be clearly indicated in accompanying documentation. including the reasons for the changes, and the names of those who made the modifications.\n\nDISCLAIMER\n\nTHIS SOFTWARE IS PROVIDED \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."],"licenseIds":["Mup"],"keywords":["c 1995 2012","1995 2012 by","2012 by arkkra","by arkkra enterprises","arkkra enterprises all","enterprises all rights","3 any additions","accompanying documentation including","documentation including the","including the reasons","changes and the","and the names","names of those","those who made","who made the","made the modifications","the modifications disclaimer","modifications disclaimer this","copyright c 1995 2012","c 1995 2012 by","1995 2012 by arkkra","2012 by arkkra enterprises","by arkkra enterprises all","arkkra enterprises all rights","enterprises all rights reserved","distribution 3 any additions","3 any additions deletions","in accompanying documentation including","accompanying documentation including the","documentation including the reasons","including the reasons for","reasons for the changes","for the changes and","the changes and the","changes and the names","and the names of","the names of those","names of those who","of those who made","those who made the","who made the modifications","made the modifications disclaimer","the modifications disclaimer this","modifications disclaimer this software","copyright c 1995 2012 by","c 1995 2012 by arkkra","1995 2012 by arkkra enterprises","2012 by arkkra enterprises all","by arkkra enterprises all rights","arkkra enterprises all rights reserved","enterprises all rights reserved redistribution","the distribution 3 any additions","distribution 3 any additions deletions","3 any additions deletions or","indicated in accompanying documentation including","in accompanying documentation including the","accompanying documentation including the reasons","documentation including the reasons for","including the reasons for the","the reasons for the changes","reasons for the changes and","for the changes and the","the changes and the names","changes and the names of","and the names of those","the names of those who","names of those who made","of those who made the","those who made the modifications","who made the modifications disclaimer","made the modifications disclaimer this","the modifications disclaimer this software","modifications disclaimer this software is"]},{"licenseTexts":["NASA OPEN SOURCE AGREEMENT VERSION 1.3\n\nTHIS OPEN SOURCE AGREEMENT (\"AGREEMENT\") DEFINES THE RIGHTS OF USE, REPRODUCTION, DISTRIBUTION, MODIFICATION AND REDISTRIBUTION OF CERTAIN COMPUTER SOFTWARE ORIGINALLY RELEASED BY THE UNITED STATES GOVERNMENT AS REPRESENTED BY THE GOVERNMENT AGENCY LISTED BELOW (\"GOVERNMENT AGENCY\"). THE UNITED STATES GOVERNMENT, AS REPRESENTED BY GOVERNMENT AGENCY, IS AN INTENDED THIRD-PARTY BENEFICIARY OF ALL SUBSEQUENT DISTRIBUTIONS OR REDISTRIBUTIONS OF THE SUBJECT SOFTWARE. ANYONE WHO USES, REPRODUCES, DISTRIBUTES, MODIFIES OR REDISTRIBUTES THE SUBJECT SOFTWARE, AS DEFINED HEREIN, OR ANY PART THEREOF, IS, BY THAT ACTION, ACCEPTING IN FULL THE RESPONSIBILITIES AND OBLIGATIONS CONTAINED IN THIS AGREEMENT.\n\nGovernment Agency: _______________\n\nGovernment Agency Original Software Designation: _______________\n\nGovernment Agency Original Software Title: _______________\n\nUser Registration Requested. Please Visit http://_______________\n\nGovernment Agency Point of Contact for Original Software: _______________\n\n   \n\n   DEFINITIONS\n\n      A. \"Contributor\" means Government Agency, as the developer of the Original Software, and any entity that makes a Modification.\n\n      B. \"Covered Patents\" mean patent claims licensable by a Contributor that are necessarily infringed by the use or sale of its Modification alone or when combined with the Subject Software.\n\n      C. \"Display\" means the showing of a copy of the Subject Software, either directly or by means of an image, or any other device.\n\n      D. \"Distribution\" means conveyance or transfer of the Subject Software, regardless of means, to another.\n\n      E. \"Larger Work\" means computer software that combines Subject Software, or portions thereof, with software separate from the Subject Software that is not governed by the terms of this Agreement.\n\n      F. \"Modification\" means any alteration of, including addition to or deletion from, the substance or structure of either the Original Software or Subject Software, and includes derivative works, as that term is defined in the Copyright Statute, 17 USC 101. However, the act of including Subject Software as part of a Larger Work does not in and of itself constitute a Modification.\n\n      G. \"Original Software\" means the computer software first released under this Agreement by Government Agency with Government Agency designation _______________ and entitled _______________ , including source code, object code and accompanying documentation, if any.\n\n      H. \"Recipient\" means anyone who acquires the Subject Software under this Agreement, including all Contributors.\n\n      I. \"Redistribution\" means Distribution of the Subject Software after a Modification has been made.\n\n      J. \"Reproduction\" means the making of a counterpart, image or copy of the Subject Software.\n\n      K. \"Sale\" means the exchange of the Subject Software for money or equivalent value.\n\n      L. \"Subject Software\" means the Original Software, Modifications, or any respective parts thereof.\n\n      M. \"Use\" means the application or employment of the Subject Software for any purpose.\n\n   \n\n   GRANT OF RIGHTS\n\n      A. Under Non-Patent Rights: Subject to the terms and conditions of this Agreement, each Contributor, with respect to its own contribution to the Subject Software, hereby grants to each Recipient a non-exclusive, world-wide, royalty-free license to engage in the following activities pertaining to the Subject Software:\n\n         1. Use\n\n         2. Distribution\n\n         3. Reproduction\n\n         4. Modification\n\n         5. Redistribution\n\n         6. Display\n\n      B. Under Patent Rights: Subject to the terms and conditions of this Agreement, each Contributor, with respect to its own contribution to the Subject Software, hereby grants to each Recipient under Covered Patents a non-exclusive, world-wide, royalty-free license to engage in the following activities pertaining to the Subject Software:\n\n         1. Use\n\n         2. Distribution\n\n         3. Reproduction\n\n         4. Sale\n\n         5. Offer for Sale\n\n      C. The rights granted under Paragraph B. also apply to the combination of a Contributor's Modification and the Subject Software if, at the time the Modification is added by the Contributor, the addition of such Modification causes the combination to be covered by the Covered Patents. It does not apply to any other combinations that include a Modification.\n\n      D. The rights granted in Paragraphs A. and B. allow the Recipient to sublicense those same rights. Such sublicense must be under the same terms and conditions of this Agreement.\n\n   \n\n   OBLIGATIONS OF RECIPIENT\n\n      A. Distribution or Redistribution of the Subject Software must be made under this Agreement except for additions covered under paragraph 3H.\n\n         1. Whenever a Recipient distributes or redistributes the Subject Software, a copy of this Agreement must be included with each copy of the Subject Software; and\n\n         2. If Recipient distributes or redistributes the Subject Software in any form other than source code, Recipient must also make the source code freely available, and must provide with each copy of the Subject Software information on how to obtain the source code in a reasonable manner on or through a medium customarily used for software exchange.\n\n      B. Each Recipient must ensure that the following copyright notice appears prominently in the Subject Software:\n\n      [Government Agency will insert the applicable copyright notice in each agreement accompanying the initial distribution of original software and remove this bracketed language.]\n\n      [The following copyright notice will be used if created by a contractor pursuant to Government Agency contract and rights obtained from creator by assignment. Government Agency will insert the year and its Agency designation and remove the bracketed language.] Copyright (c) {YEAR} United States Government as represented by _______________ . All Rights Reserved.\n\n      [The following copyright notice will be used if created by civil servants only. Government Agency will insert the year and its Agency designation and remove the bracketed language.] Copyright (c) {YEAR} United States Government as represented by _______________ . No copyright is claimed in the United States under Title 17, U.S.Code. All Other Rights Reserved.\n\n      C. Each Contributor must characterize its alteration of the Subject Software as a Modification and must identify itself as the originator of its Modification in a manner that reasonably allows subsequent Recipients to identify the originator of the Modification. In fulfillment of these requirements, Contributor must include a file (e.g., a change log file) that describes the alterations made and the date of the alterations, identifies Contributor as originator of the alterations, and consents to characterization of the alterations as a Modification, for example, by including a statement that the Modification is derived, directly or indirectly, from Original Software provided by Government Agency. Once consent is granted, it may not thereafter be revoked.\n\n      D. A Contributor may add its own copyright notice to the Subject Software. Once a copyright notice has been added to the Subject Software, a Recipient may not remove it without the express permission of the Contributor who added the notice.\n\n      E. A Recipient may not make any representation in the Subject Software or in any promotional, advertising or other material that may be construed as an endorsement by Government Agency or by any prior Recipient of any product or service provided by Recipient, or that may seek to obtain commercial advantage by the fact of Government Agency's or a prior Recipient's participation in this Agreement.\n\n      F. In an effort to track usage and maintain accurate records of the Subject Software, each Recipient, upon receipt of the Subject Software, is requested to register with Government Agency by visiting the following website: _______________ . Recipient's name and personal information shall be used for statistical purposes only. Once a Recipient makes a Modification available, it is requested that the Recipient inform Government Agency at the web site provided above how to access the Modification.\n\n      [Alternative paragraph for use when a web site for release and monitoring of subject software will not be supported by releasing Government Agency] In an effort to track usage and maintain accurate records of the Subject Software, each Recipient, upon receipt of the Subject Software, is requested to provide Government Agency, by e-mail to the Government Agency Point of Contact listed in clause 5.F., the following information: _______________ . Recipient's name and personal information shall be used for statistical purposes only. Once a Recipient makes a Modification available, it is requested that the Recipient inform Government Agency, by e-mail to the Government Agency Point of Contact listed in clause 5.F., how to access the Modification.\n\n      G. Each Contributor represents that that its Modification is believed to be Contributor's original creation and does not violate any existing agreements, regulations, statutes or rules, and further that Contributor has sufficient rights to grant the rights conveyed by this Agreement.\n\n      H. A Recipient may choose to offer, and to charge a fee for, warranty, support, indemnity and/or liability obligations to one or more other Recipients of the Subject Software. A Recipient may do so, however, only on its own behalf and not on behalf of Government Agency or any other Recipient. Such a Recipient must make it absolutely clear that any such warranty, support, indemnity and/or liability obligation is offered by that Recipient alone. Further, such Recipient agrees to indemnify Government Agency and every other Recipient for any liability incurred by them as a result of warranty, support, indemnity and/or liability offered by such Recipient.\n\n      I. A Recipient may create a Larger Work by combining Subject Software with separate software not governed by the terms of this agreement and distribute the Larger Work as a single product. In such case, the Recipient must make sure Subject Software, or portions thereof, included in the Larger Work is subject to this Agreement.\n\n      J. Notwithstanding any provisions contained herein, Recipient is hereby put on notice that export of any goods or technical data from the United States may require some form of export license from the U.S. Government. Failure to obtain necessary export licenses may result in criminal liability under U.S. laws. Government Agency neither represents that a license shall not be required nor that, if required, it shall be issued. Nothing granted herein provides any such export license.\n\n   \n\n   DISCLAIMER OF WARRANTIES AND LIABILITIES; WAIVER AND INDEMNIFICATION\n\n      A. No Warranty: THE SUBJECT SOFTWARE IS PROVIDED \"AS IS\" WITHOUT ANY WARRANTY OF ANY KIND, EITHER EXPRESSED, IMPLIED, OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, ANY WARRANTY THAT THE SUBJECT SOFTWARE WILL CONFORM TO SPECIFICATIONS, ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR FREEDOM FROM INFRINGEMENT, ANY WARRANTY THAT THE SUBJECT SOFTWARE WILL BE ERROR FREE, OR ANY WARRANTY THAT DOCUMENTATION, IF PROVIDED, WILL CONFORM TO THE SUBJECT SOFTWARE. THIS AGREEMENT DOES NOT, IN ANY MANNER, CONSTITUTE AN ENDORSEMENT BY GOVERNMENT AGENCY OR ANY PRIOR RECIPIENT OF ANY RESULTS, RESULTING DESIGNS, HARDWARE, SOFTWARE PRODUCTS OR ANY OTHER APPLICATIONS RESULTING FROM USE OF THE SUBJECT SOFTWARE. FURTHER, GOVERNMENT AGENCY DISCLAIMS ALL WARRANTIES AND LIABILITIES REGARDING THIRD-PARTY SOFTWARE, IF PRESENT IN THE ORIGINAL SOFTWARE, AND DISTRIBUTES IT \"AS IS.\"\n\n      B. Waiver and Indemnity: RECIPIENT AGREES TO WAIVE ANY AND ALL CLAIMS AGAINST THE UNITED STATES GOVERNMENT, ITS CONTRACTORS AND SUBCONTRACTORS, AS WELL AS ANY PRIOR RECIPIENT. IF RECIPIENT'S USE OF THE SUBJECT SOFTWARE RESULTS IN ANY LIABILITIES, DEMANDS, DAMAGES, EXPENSES OR LOSSES ARISING FROM SUCH USE, INCLUDING ANY DAMAGES FROM PRODUCTS BASED ON, OR RESULTING FROM, RECIPIENT'S USE OF THE SUBJECT SOFTWARE, RECIPIENT SHALL INDEMNIFY AND HOLD HARMLESS THE UNITED STATES GOVERNMENT, ITS CONTRACTORS AND SUBCONTRACTORS, AS WELL AS ANY PRIOR RECIPIENT, TO THE EXTENT PERMITTED BY LAW. RECIPIENT'S SOLE REMEDY FOR ANY SUCH MATTER SHALL BE THE IMMEDIATE, UNILATERAL TERMINATION OF THIS AGREEMENT.\n\n   \n\n   GENERAL TERMS\n\n      A. Termination: This Agreement and the rights granted hereunder will terminate automatically if a Recipient fails to comply with these terms and conditions, and fails to cure such noncompliance within thirty (30) days of becoming aware of such noncompliance. Upon termination, a Recipient agrees to immediately cease use and distribution of the Subject Software. All sublicenses to the Subject Software properly granted by the breaching Recipient shall survive any such termination of this Agreement.\n\n      B. Severability: If any provision of this Agreement is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this Agreement.\n\n      C. Applicable Law: This Agreement shall be subject to United States federal law only for all purposes, including, but not limited to, determining the validity of this Agreement, the meaning of its provisions and the rights, obligations and remedies of the parties.\n\n      D. Entire Understanding: This Agreement constitutes the entire understanding and agreement of the parties relating to release of the Subject Software and may not be superseded, modified or amended except by further written agreement duly executed by the parties.\n\n      E. Binding Authority: By accepting and using the Subject Software under this Agreement, a Recipient affirms its authority to bind the Recipient to all terms and conditions of this Agreement and that that Recipient hereby agrees to all terms and conditions herein.\n\n      F. Point of Contact: Any Recipient contact with Government Agency is to be directed to the designated representative as follows: _______________ ."],"licenseIds":["NASA-1.3"],"keywords":["nasa open source","source agreement version","3 this open","this open source","source agreement agreement","agreement agreement defines","agreement defines the","of certain computer","certain computer software","computer software originally","software originally released","represented by the","government agency listed","agency listed below","listed below government","below government agency","government agency the","agency the united","represented by government","agency is an","beneficiary of all","of all subsequent","all subsequent distributions","subsequent distributions or","distributions or redistributions","or redistributions of","subject software anyone","software anyone who","as defined herein","defined herein or","full the responsibilities","the responsibilities and","responsibilities and obligations","and obligations contained","obligations contained in","this agreement government","agreement government agency","government agency government","agency government agency","original software designation","software designation government","designation government agency","original software title","software title user","title user registration","user registration requested","registration requested please","requested please visit","visit http government","http government agency","of contact for","contact for original","for original software","original software definitions","software definitions a","definitions a contributor","contributor means government","means government agency","government agency as","agency as the","as the developer","and any entity","entity that makes","that makes a","a modification b","modification b covered","b covered patents","covered patents mean","its modification alone","modification alone or","subject software c","software c display","c display means","display means the","means the showing","the showing of","showing of a","subject software either","software either directly","of an image","an image or","image or any","any other device","other device d","device d distribution","d distribution means","distribution means conveyance","means conveyance or","conveyance or transfer","transfer of the","subject software regardless","software regardless of","regardless of means","of means to","means to another","to another e","another e larger","e larger work","work means computer","means computer software","computer software that","software that combines","that combines subject","combines subject software","thereof with software","with software separate","software separate from","from the subject","subject software that","is not governed","agreement f modification","f modification means","modification means any","means any alteration","alteration of including","of including addition","including addition to","software or subject","or subject software","software and includes","and includes derivative","includes derivative works","the copyright statute","copyright statute 17","statute 17 usc","17 usc 101","usc 101 however","101 however the","however the act","act of including","of including subject","including subject software","larger work does","and of itself","of itself constitute","itself constitute a","constitute a modification","a modification g","modification g original","g original software","means the computer","the computer software","computer software first","software first released","agreement by government","government agency with","agency with government","government agency designation","designation and entitled","and entitled including","entitled including source","accompanying documentation if","if any h","any h recipient","h recipient means","anyone who acquires","who acquires the","acquires the subject","all contributors i","contributors i redistribution","i redistribution means","redistribution means distribution","means distribution of","subject software after","software after a","after a modification","a modification has","been made j","made j reproduction","j reproduction means","reproduction means the","means the making","making of a","of a counterpart","a counterpart image","counterpart image or","image or copy","or copy of","subject software k","software k sale","k sale means","sale means the","means the exchange","software for money","for money or","money or equivalent","or equivalent value","equivalent value l","value l subject","l subject software","subject software means","original software modifications","any respective parts","respective parts thereof","parts thereof m","thereof m use","m use means","use means the","means the application","the application or"]},{"licenseTexts":["The Net Boolean Public License Version 1, 22 August 1998 Copyright 1998, Net Boolean Incorporated, Redwood City, California, USA All Rights Reserved. Note: This license is derived from the \"Artistic License\" as distributed with the Perl Programming Language. Its terms are different from those of the \"Artistic License.\"\n\nPREAMBLE\n\nThe intent of this document is to state the conditions under which a Package may be copied, such that the Copyright Holder maintains some semblance of artistic control over the development of the package, while giving the users of the package the right to use and distribute the Package in a more-or-less customary fashion, plus the right to make reasonable modifications.\n\nDefinitions:\n\n\"Package\" refers to the collection of files distributed by the Copyright Holder, and derivatives of that collection of files created through textual modification.\n\n\"Standard Version\" refers to such a Package if it has not been modified, or has been modified in accordance with the wishes of the Copyright Holder.\n\n\"Copyright Holder\" is whoever is named in the copyright or copyrights for the package.\n\n\"You\" is you, if you're thinking about copying or distributing this Package.\n\n\"Reasonable copying fee\" is whatever you can justify on the basis of media cost, duplication charges, time of people involved, and so on. (You will not be required to justify it to the Copyright Holder, but only to the computing community at large as a market that must bear the fee.)\n\n\"Freely Available\" means that no fee is charged for the item itself, though there may be fees involved in handling the item. It also means that recipients of the item may redistribute it under the same conditions they received it.\n\n   1. You may make and give away verbatim copies of the source form of the Standard Version of this Package without restriction, provided that you duplicate all of the original copyright notices and associated disclaimers.\n\n   2. You may apply bug fixes, portability fixes and other modifications derived from the Public Domain or from the Copyright Holder. A Package modified in such a way shall still be considered the Standard Version.\n\n   3. You may otherwise modify your copy of this Package in any way, provided that you insert a prominent notice in each changed file stating how and when you changed that file, and provided that you do at least ONE of the following:\n\n      a) place your modifications in the Public Domain or otherwise make them Freely Available, such as by posting said modifications to Usenet or an equivalent medium, or placing the modifications on a major archive site such as uunet.uu.net, or by allowing the Copyright Holder to include your modifications in the Standard Version of the Package.\n\n      b) use the modified Package only within your corporation or organization.\n\n      c) rename any non-standard executables so the names do not conflict with standard executables, which must also be provided, and provide a separate manual page for each non-standard executable that clearly documents how it differs from the Standard Version.\n\n      d) make other distribution arrangements with the Copyright Holder.\n\n   4. You may distribute the programs of this Package in object code or executable form, provided that you do at least ONE of the following:\n\n      a) distribute a Standard Version of the executables and library files, together with instructions (in the manual page or equivalent) on where to get the Standard Version.\n\n      b) accompany the distribution with the machine-readable source of the Package with your modifications.\n\n      c) accompany any non-standard executables with their corresponding Standard Version executables, giving the non-standard executables non-standard names, and clearly documenting the differences in manual pages (or equivalent), together with instructions on where to get the Standard Version.\n\n      d) make other distribution arrangements with the Copyright Holder.\n\n   5. You may charge a reasonable copying fee for any distribution of this Package. You may charge any fee you choose for support of this Package. You may not charge a fee for this Package itself. However, you may distribute this Package in aggregate with other (possibly commercial) programs as part of a larger (possibly commercial) software distribution provided that you do not advertise this Package as a product of your own.\n\n   6. The scripts and library files supplied as input to or produced as output from the programs of this Package do not automatically fall under the copyright of this Package, but belong to whomever generated them, and may be sold commercially, and may be aggregated with this Package.\n\n   7. C subroutines supplied by you and linked into this Package in order to emulate subroutines and variables of the language defined by this Package shall not be considered part of this Package, but are the equivalent of input as in Paragraph 6, provided these subroutines do not change the language in any way that would cause it to fail the regression tests for the language.\n\n   8. The name of the Copyright Holder may not be used to endorse or promote products derived from this software without specific prior written permission.\n\n   9. THIS PACKAGE IS PROVIDED \"AS IS\" AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. The End"],"licenseIds":["NBPL-1.0"],"keywords":["the net boolean","net boolean public","boolean public license","version 1 22","1 22 august","22 august 1998","copyright 1998 net","1998 net boolean","net boolean incorporated","boolean incorporated redwood","incorporated redwood city","the net boolean public","net boolean public license","boolean public license version","license version 1 22","version 1 22 august","1 22 august 1998","22 august 1998 copyright","1998 copyright 1998 net","copyright 1998 net boolean","1998 net boolean incorporated","net boolean incorporated redwood","boolean incorporated redwood city","incorporated redwood city california","the net boolean public license","net boolean public license version","boolean public license version 1","public license version 1 22","license version 1 22 august","version 1 22 august 1998","1 22 august 1998 copyright","22 august 1998 copyright 1998","august 1998 copyright 1998 net","1998 copyright 1998 net boolean","copyright 1998 net boolean incorporated","1998 net boolean incorporated redwood","net boolean incorporated redwood city","boolean incorporated redwood city california","incorporated redwood city california usa","usa all rights reserved note"]},{"licenseTexts":["Non-Commercial Government Licence\n\nfor public sector information\n\nYou are encouraged to use and re-use the Information that is available under this licence freely and flexibly, with only a few conditions.\n\nUsing information under this licence\n\nUse of copyright and database right material expressly made available under this licence (the 'Information') indicates your acceptance of the terms and conditions below.\n\nThe Licensor grants you a worldwide, royalty-free, perpetual, non-exclusive licence to use the Information for Non-Commercial purposes only subject to the conditions below.\n\nThis licence does not affect your freedom under fair dealing or fair use or any other copyright or database right exceptions and limitations.\n\nYou are free to:\n\n   copy, publish, distribute and transmit the Information;\n\n   adapt the Information;\n\n   exploit the Information for Non-Commercial purposes for example, by combining it with other information in your own product or application.\n\nYou are not permitted to:\n\n   exercise any of the rights granted to you by this licence in any manner that is primarily intended for or directed toward commercial advantage or private monetary compensation.\n\nYou must, where you do any of the above:\n\n   acknowledge the source of the Information by including any attribution statement specified by the Information Provider(s) and, where possible, provide a link to this licence;\n\n   If the Information Provider does not provide a specific attribution statement, you must use the following:\n\n   Contains information licensed under the Non-Commercial Government Licence v2.0.\n\n   If you are using Information from several Information Providers and listing multiple attributions is not practical in your product or application, you may include a URI or hyperlink to a resource that contains the required attribution statements.\n\n   ensure that any onward licensing of the Information – for example when combined with other information – is for Non-Commercial purposes only.\n\n   These are important conditions of this licence and if you fail to comply with them or use the Information other than for Non-Commercial purposes the rights granted to you under this licence, or any similar licence granted by the Licensor, will end automatically.\n\nExemptions\n\nThis licence does not cover the use of:\n\n   • personal data in the Information;\n\n   • Information that has not been accessed by way of publication or disclosure under information access legislation (including the Freedom of Information Acts for the UK and Scotland) by or with the consent of the Information Provider;\n\n   • departmental or public sector organisation logos, crests, military insignia and the Royal Arms except where they form an integral part of a document or dataset;\n\n   • military insignia\n\n   • third party rights the Information Provider is not authorised to license;\n\n   • other intellectual property rights, including patents, trade marks, and design rights; and\n\n   • identity documents such as the British Passport.\n\nNon-endorsement\n\nThis licence does not grant you any right to use the Information in a way that suggests any official status or that the Information Provider and/or Licensor endorse you or your use of the Information.\n\nNo warranty\n\nThe Information is licensed 'as is' and the Information Provider excludes all representations, warranties, obligations and liabilities in relation to the Information to the maximum extent permitted by law.\n\nThe Information Provider is not liable for any errors or omissions in the Information and shall not be liable for any loss, injury or damage of any kind caused by its use. The Information Provider does not guarantee the continued supply of the Information.\n\nGoverning Law\n\nThis licence is governed by the laws of the jurisdiction in which the Information Provider has its principal place of business, unless otherwise specified by the Information Provider.\n\nDefinitions\n\nIn this licence the terms below have the following meanings:\n\n'Information' means information protected by copyright or by database right (for example, literary and artistic works, content, data and source code) offered for use under the terms of this licence.\n\n'Information Provider' means the person or organisation providing the Information under this licence.\n\n'Licensor' means any Information Provider which has the authority to offer Information under the terms of this licence or the Keeper of the Public Records, who has the authority to offer Information subject to Crown copyright and Crown database rights and Information subject to copyright and database right that has been assigned to or acquired by the Crown, under the terms of this licence.\n\n'Non-Commercial purposes' means not intended for or directed toward commercial advantage or private monetary compensation. For the purposes of this licence, 'private monetary compensation' does not include the exchange of the Information for other copyrighted works by means of digital file-sharing or otherwise provided there is no payment of any monetary compensation in connection with the exchange of the Information.\n\n'Use' as a verb, means doing any act which is restricted by copyright or database right, whether in the original medium or in any other medium, and includes without limitation distributing, copying, adapting, modifying as may be technically necessary to use it in a different mode or format.\n\n'You' means the natural or legal person, or body of persons corporate or incorporate, acquiring rights under this licence."],"licenseIds":["NCGL-UK-2.0"],"keywords":["government licence for","licence for public","for public sector","sector information you","information you are","purposes only subject","only subject to","commercial purposes for","purposes for example","other information in","application you are","permitted to exercise","licence in any","monetary compensation you","compensation you must","following contains information","the non commercial","v2 0 if","attribution statements ensure","statements ensure that","ensure that any","that any onward","any onward licensing","onward licensing of","information for example","for example when","example when combined","other information is","information is for","is for non","purposes only these","only these are","with them or","them or use","the information other","information other than","commercial purposes the","purposes the rights","logos crests military","crests military insignia","military insignia and","insignia and the","this licence non","licence non commercial","commercial purposes means","purposes means not","means not intended","this licence private","licence private monetary","monetary compensation does","compensation does not","include the exchange","or otherwise provided","otherwise provided there","the information use","information use as","commercial government licence for","government licence for public","licence for public sector","for public sector information","public sector information you","sector information you are","information you are encouraged","commercial purposes only subject","purposes only subject to","only subject to the","exploit the information for","non commercial purposes for","commercial purposes for example","purposes for example by","with other information in","other information in your","information in your own","or application you are","application you are not","not permitted to exercise","permitted to exercise any","you by this licence","by this licence in","this licence in any","licence in any manner","private monetary compensation you","monetary compensation you must","compensation you must where","the following contains information","following contains information licensed","under the non commercial","the non commercial government","commercial government licence v2","licence v2 0 if","v2 0 if you","required attribution statements ensure","attribution statements ensure that","statements ensure that any","ensure that any onward","that any onward licensing","any onward licensing of","onward licensing of the","licensing of the information","the information for example","information for example when","for example when combined","example when combined with","when combined with other","combined with other information","with other information is","other information is for","information is for non","is for non commercial","commercial purposes only these","purposes only these are","only these are important","comply with them or","with them or use","them or use the","or use the information","use the information other","the information other than","information other than for","than for non commercial","non commercial purposes the","commercial purposes the rights","purposes the rights granted","organisation logos crests military","logos crests military insignia","crests military insignia and","military insignia and the","insignia and the royal","the public records who","of this licence non","this licence non commercial","licence non commercial purposes","non commercial purposes means","commercial purposes means not","purposes means not intended","means not intended for","not intended for or","private monetary compensation for","monetary compensation for the","compensation for the purposes","purposes of this licence","of this licence private","this licence private monetary","licence private monetary compensation","private monetary compensation does","monetary compensation does not","compensation does not include","not include the exchange","include the exchange of","the information for other","information for other copyrighted","sharing or otherwise provided","or otherwise provided there","otherwise provided there is","of the information use","the information use as","information use as a","non commercial government licence for","commercial government licence for public","government licence for public sector","licence for public sector information","for public sector information you","public sector information you are","sector information you are encouraged","information you are encouraged to","to use the information for","use the information for non","non commercial purposes only subject","commercial purposes only subject to","purposes only subject to the","only subject to the conditions","information exploit the information for","exploit the information for non","for non commercial purposes for","non commercial purposes for example","commercial purposes for example by","purposes for example by combining","it with other information in","with other information in your","other information in your own","information in your own product","product or application you are","or application you are not","application you are not permitted","are not permitted to exercise","not permitted to exercise any","permitted to exercise any of","to you by this licence","you by this licence in","by this licence in any","this licence in any manner","licence in any manner that","or private monetary compensation you","private monetary compensation you must","monetary compensation you must where","compensation you must where you","use the following contains information","the following contains information licensed","following contains information licensed under","information licensed under the non"]},{"licenseTexts":["University of Illinois/NCSA Open Source License Copyright (c) \u003cYear\u003e \u003cOwner Organization Name\u003e. All rights reserved.\n\nDeveloped by: \n\n\u003cName of Development Group\u003e\n\n\u003cName of Institution\u003e\n\n\u003cURL for Development Group/Institution\u003e\n\nPermission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the \"Software\"), to deal with the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:\n\n   * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimers.\n\n   * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimers in the documentation and/or other materials provided with the distribution.\n\n   * Neither the names of \u003cName of Development Group, Name of Institution\u003e , nor the names of its contributors may be used to endorse or promote products derived from this Software without specific prior written permission.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE SOFTWARE."],"licenseIds":["NCSA"],"keywords":["year owner organization","owner organization name","organization name all","name all rights","rights reserved developed","reserved developed by","developed by name","of institution url","institution url for","url for development","for development group","development group institution","group institution permission","institution permission is","to deal with","deal with the","following conditions redistributions","following disclaimers redistributions","disclaimers redistributions in","following disclaimers in","disclaimers in the","names of name","of name of","of institution nor","institution nor the","the contributors or","contributors or copyright","other dealings with","dealings with the","c year owner organization","year owner organization name","owner organization name all","organization name all rights","name all rights reserved","all rights reserved developed","rights reserved developed by","reserved developed by name","developed by name of","by name of development","name of institution url","of institution url for","institution url for development","url for development group","for development group institution","development group institution permission","group institution permission is","institution permission is hereby","software to deal with","to deal with the","deal with the software","with the software without","the following conditions redistributions","following conditions redistributions of","the following disclaimers redistributions","following disclaimers redistributions in","disclaimers redistributions in binary","the following disclaimers in","following disclaimers in the","disclaimers in the documentation","distribution neither the names","the names of name","names of name of","of name of development","name of institution nor","of institution nor the","institution nor the names","permission the software is","shall the contributors or","the contributors or copyright","contributors or copyright holders","or other dealings with","other dealings with the","dealings with the software","ncsa open source license copyright","source license copyright c year","license copyright c year owner","copyright c year owner organization","c year owner organization name","year owner organization name all","owner organization name all rights","organization name all rights reserved","name all rights reserved developed","all rights reserved developed by","rights reserved developed by name","reserved developed by name of","developed by name of development","by name of development group","group name of institution url","name of institution url for","of institution url for development","institution url for development group","url for development group institution","for development group institution permission","development group institution permission is","group institution permission is hereby","institution permission is hereby granted","the software to deal with","software to deal with the","to deal with the software","deal with the software without","with the software without restriction","to the following conditions redistributions","the following conditions redistributions of","following conditions redistributions of source","and the following disclaimers redistributions","the following disclaimers redistributions in","following disclaimers redistributions in binary","disclaimers redistributions in binary form","and the following disclaimers in","the following disclaimers in the","following disclaimers in the documentation","disclaimers in the documentation and","the distribution neither the names","distribution neither the names of","neither the names of name","the names of name of","names of name of development","of name of development group","group name of institution nor","name of institution nor the","of institution nor the names","institution nor the names of","written permission the software is","permission the software is provided","event shall the contributors or","shall the contributors or copyright","the contributors or copyright holders","contributors or copyright holders be","use or other dealings with","or other dealings with the","other dealings with the software"]},{"licenseTexts":["NETHACK GENERAL PUBLIC LICENSE (Copyright 1989 M. Stephenson)\n\n(Based on the BISON general public license, copyright 1988 Richard M. Stallman)\n\nEveryone is permitted to copy and distribute verbatim copies of this license, but changing it is not allowed. You can also use this wording to make the terms for other programs.\n\nThe license agreements of most software companies keep you at the mercy of those companies. By contrast, our general public license is intended to give everyone the right to share NetHack. To make sure that you get the rights we want you to have, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. Hence this license agreement.\n\nSpecifically, we want to make sure that you have the right to give away copies of NetHack, that you receive source code or else can get it if you want it, that you can change NetHack or use pieces of it in new free programs, and that you know you can do these things.\n\nTo make sure that everyone has such rights, we have to forbid you to deprive anyone else of these rights. For example, if you distribute copies of NetHack, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must tell them their rights.\n\nAlso, for our own protection, we must make certain that everyone finds out that there is no warranty for NetHack. If NetHack is modified by someone else and passed on, we want its recipients to know that what they have is not what we distributed.\n\nTherefore we (Mike Stephenson and other holders of NetHack copyrights) make the following terms which say what you must do to be allowed to distribute or change NetHack.\n\nCOPYING POLICIES\n\n   1. You may copy and distribute verbatim copies of NetHack source code as you receive it, in any medium, provided that you keep intact the notices on all files that refer to copyrights, to this License Agreement, and to the absence of any warranty; and give any other recipients of the NetHack program a copy of this License Agreement along with the program.\n\n   2. You may modify your copy or copies of NetHack or any portion of it, and copy and distribute such modifications under the terms of Paragraph 1 above (including distributing this License Agreement), provided that you also do the following:\n\n      a) cause the modified files to carry prominent notices stating that you changed the files and the date of any change; and\n\n      b) cause the whole of any work that you distribute or publish, that in whole or in part contains or is a derivative of NetHack or any part thereof, to be licensed at no charge to all third parties on terms identical to those contained in this License Agreement (except that you may choose to grant more extensive warranty protection to some or all third parties, at your option)\n\n      c) You may charge a distribution fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee.\n\n   3. You may copy and distribute NetHack (or a portion or derivative of it, under Paragraph 2) in object code or executable form under the terms of Paragraphs 1 and 2 above provided that you also do one of the following:\n\n      a) accompany it with the complete machine-readable source code, which must be distributed under the terms of Paragraphs 1 and 2 above; or,\n\n      b) accompany it with full information as to how to obtain the complete machine-readable source code from an appropriate archive site. (This alternative is allowed only for noncommercial distribution.)\n\n   For these purposes, complete source code means either the full source distribution as originally released over Usenet or updated copies of the files in this distribution used to create the object code or executable.\n\n   4. You may not copy, sublicense, distribute or transfer NetHack except as expressly provided under this License Agreement. Any attempt otherwise to copy, sublicense, distribute or transfer NetHack is void and your rights to use the program under this License agreement shall be automatically terminated. However, parties who have received computer software programs from you with this License Agreement will not have their licenses terminated so long as such parties remain in full compliance.\n\nStated plainly: You are permitted to modify NetHack, or otherwise use parts of NetHack, provided that you comply with the conditions specified above; in particular, your modified NetHack or program containing parts of NetHack must remain freely available as provided in this License Agreement. In other words, go ahead and share NetHack, but don't try to stop anyone else from sharing it farther."],"licenseIds":["NGPL"],"keywords":["nethack general public","license copyright 1989","copyright 1989 m","1989 m stephenson","m stephenson based","stephenson based on","on the bison","the bison general","bison general public","license copyright 1988","copyright 1988 richard","1988 richard m","richard m stallman","m stallman everyone","stallman everyone is","license but changing","allowed you can","use this wording","this wording to","wording to make","make the terms","the terms for","terms for other","for other programs","other programs the","programs the license","software companies keep","companies keep you","keep you at","you at the","to give everyone","give everyone the","everyone the right","right to share","to share nethack","share nethack to","nethack to make","that you get","get the rights","the rights we","rights we want","we want you","want you to","you to have","to have we","have we need","the rights hence","rights hence this","hence this license","license agreement specifically","agreement specifically we","specifically we want","right to give","give away copies","away copies of","of nethack that","nethack that you","code or else","or else can","else can get","can change nethack","change nethack or","nethack or use","things to make","sure that everyone","that everyone has","everyone has such","has such rights","such rights we","rights we have","we have to","have to forbid","forbid you to","you to deprive","to deprive anyone","deprive anyone else","anyone else of","else of these","these rights for","rights for example","of nethack you","nethack you must","their rights also","rights also for","also for our","for our own","our own protection","own protection we","protection we must","we must make","must make certain","that everyone finds","everyone finds out","finds out that","out that there","warranty for nethack","for nethack if","nethack if nethack","if nethack is","nethack is modified","is not what","not what we","what we distributed","we distributed therefore","distributed therefore we","therefore we mike","we mike stephenson","mike stephenson and","stephenson and other","and other holders","other holders of","holders of nethack","of nethack copyrights","nethack copyrights make","copyrights make the","make the following","following terms which","terms which say","which say what","say what you","what you must","must do to","do to be","to be allowed","distribute or change","or change nethack","change nethack copying","nethack copying policies","copying policies 1","policies 1 you","of nethack source","nethack source code","that you keep","you keep intact","keep intact the","intact the notices","the notices on","notices on all","on all files","files that refer","refer to copyrights","to copyrights to","copyrights to this","of the nethack","the nethack program","nethack program a","license agreement along","agreement along with","program 2 you","1 above including","above including distributing","including distributing this","distributing this license","or is a","derivative of nethack","third parties on","parties on terms","on terms identical","terms identical to","identical to those","to those contained","license agreement except","agreement except that","to grant more","grant more extensive","more extensive warranty","extensive warranty protection","option c you","a fee 3","fee 3 you","and distribute nethack","distribute nethack or","nethack or a","it with full","with full information","full information as","information as to","to how to","obtain the complete","code from an","from an appropriate","an appropriate archive","appropriate archive site","archive site this","site this alternative","noncommercial distribution for","distribution for these","these purposes complete","purposes complete source","code means either","either the full","full source distribution","source distribution as","distribution as originally","as originally released","originally released over","released over usenet","over usenet or","usenet or updated","or updated copies"]},{"licenseTexts":["Norwegian Licence for Open Government Data (NLOD)\n\nPreface of licence\n\nThis licence grants you the right to copy, use and distribute information, provided you acknowledge the contributors and comply with the terms and conditions stipulated in this licence. By using information made available under this licence, you accept the terms and conditions set forth in this licence. As set out in Section 7, the licensor disclaims any and all liability for the quality of the information and what the information is used for.\n\nThis licence shall not impose any limitations on the rights or freedoms of the licensee under the Norwegian Freedom of Information Act or any other legislation granting the general public a right of access to public sector information, or that follow from exemptions or limitations stipulated in the Norwegian Copyright Act. Further, the licence shall not impose any limitations on the licensee's freedom of expression recognized by law.\n\n   1. Definitions\n\n   «Database» shall mean a database or similar protected under Section 43 of the Norwegian Copyright Act.\n\n   «Information» shall mean texts, images, recordings, data sets or other works protected under Section 1 of the Norwegian Copyright Act, or which are protected under provisions addressing what is referred to as «neighbouring rights» in Chapter 5 of the Norwegian Copyright Act (including databases and photographs), and which are distributed under this licence.\n\n   «Copy» shall mean reproduction in any form.\n\n   «Licensee» and «you» shall mean natural or legal persons using information under this licence.\n\n   «Licensor» shall mean the natural or legal person that makes information available under this licence.\n\n   «Distribute» shall mean any actions whereby information is made available, including to distribute, transfer, communicate, disperse, show, perform, sell, lend and rent.\n\n   «Use» shall mean one or more actions relevant to copyright law requiring permission from the owner of the copyright.\n\n   2. Licence\n\n   The licensee, subject to the limitations that follow from this licence, may use the information for any purpose and in all contexts, by:\n\n   * copying the information and distributing the information to others,\n\n   * modifying the information and/or combining the information with other information, and\n\n   * copying and distributing such changed or combined information.\n\n   * This is a non-exclusive, free, perpetual and worldwide licence. The information may be used in any medium and format known today and/or which will become known in the future. The Licensee shall not sub-license or transfer this licence.\n\n   3. Exemptions\n\n   The licence does not apply to and therefore does not grant a right to use:\n\n   * information which contains personal data covered by the Norwegian Personal Data Act unless there is a legitimate basis for the disclosure and further processing of the personal data\n\n   * information distributed in violation of a statutory obligation to observe confidentiality\n\n   * information excluded from public disclosure pursuant to law, including information deemed sensitive under the Norwegian National Security Act\n\n   * information subject to third party rights which the licensor is not authorised to license to the licensee\n\n   * information protected by intellectual property rights other than copyright and neighbouring rights in accordance with Chapter 5 of the Norwegian Copyright Act, such as trademarks, patents and design rights, but this does not entail an impediment to use information where the licensor's logo has been permanently integrated into the information or to attribute the origin of the information in accordance with the article below relating to attribution.\n\n   If the licensor has made available information not covered by the licence according to the above list, the licensee must cease all use of the information under the licence, and erase the information as soon as he or she becomes aware of or should have understood that the information is not covered by the licence.\n\n   4. Effects of breach of the licence\n\n   The licence is subject to the licensee's compliance with the terms and conditions of this licence. In the event that the licensee commits a breach of this licence, this will entail that the licensee's right to use the information will be revoked immediately without further notice. In case of such a breach, the licensee must immediately and without further notice take measures to cause the infringement to end. Because the right to use the information has been terminated, the licensee must cease all use of the information by virtue of the licence.\n\n   5. Attribution\n\n   The licensee shall attribute the licensor as specified by the licensor and include a reference to this licence. To the extent practically possible, the licensee shall provide a link to both this licence and the source of the information.\n\n   If the licensor has not specified how attributions shall be made, the licensee shall normally state the following: «Contains data under the Norwegian licence for Open Government data (NLOD) distributed by [name of licensor]».\n\n   If the licensor has specified that the information shall only be available under a specific version of this licence, cf. Section 10, the licensee shall also state this.\n\n   If the information has been changed, the licensee must clearly indicate that changes have been made by the licensee.\n\n   6. Proper use\n\n   The licensee shall not use the information in a manner that appears misleading nor present the information in a distorted or incorrect manner.\n\n   Neither the licensor's nor other contributors' names or trademarks must be used to support, recommend or market the licensee or any products or services using the information.\n\n   7. Disclaimer of liability\n\n   The information is licensed «as is». The information may contain errors and omissions. The licensor provides no warranties, including relating to the content and relevance of the information.\n\n   The licensor disclaims any liability for errors and defects associated with the information to the maximum extent permitted by law.\n\n   The licensor shall not be liable for direct or indirect losses as a result of use of the information or in connection with copying or further distribution of the information.\n\n   8. Guarantees regarding data quality and accessibility\n\n   This licence does not prevent the licensor from issuing supplementary statements regarding expected or intended data quality and accessibility. Such statements shall be regarded as indicative in nature and not binding on the part of the licensor. The disclaimers in Section 7 also apply in full for such indicative statements. Based on separate agreement, the licensor may provide guarantees and distribute the information on terms and conditions different from those set forth in this licence.\n\n   9. Licence compatibility\n\n   If the licensee is to distribute an adapted or combined work based on information covered by this licence and some other work licensed under a licence compatible by contract, such distribution may be based on an appropriate licence compatible by contract, cf. the list below.\n\n   A licence compatible by contract shall mean the following licences:\n\n   * for all information: Open Government Licence (version 1.0),\n\n   * for those parts of the information which do not constitute databases: Creative Commons Attribution Licence (generic version 1.0, 2.0, 2.5 and unported version 3.0) and Creative Commons Navngivelse 3.0 Norge,\n\n   * for those parts of the information which constitute databases: Open Data Commons Attribution License (version 1.0).\n\n   This provision does not prevent other licences from being compatible with this licence based on their content.\n\n   10. New versions of the licence\n\n   The licensee may choose to use the information covered by this licence under any new versions of the Norwegian licence for Open Government data (NLOD) issued by the responsible ministry (currently the Ministry of Government Administration, Reform and Church Affairs) when these versions are final and official, unless the licensor when making the information available under this licence specifically has stated that solely version 1.0 of this licence may be used.\n\n   11. Governing law and legal venue\n\nThis licence, including its formation, and any disputes and claims arising in connection with or relating to this licence, shall be regulated by Norwegian law. The legal venue shall be the licensor's ordinary legal venue. The licensor may, with regard to intellectual proprietary rights, choose to pursue a claim at other competent legal venues and/or based on the laws of the country where the intellectual property rights are sought enforced."],"licenseIds":["NLOD-1.0"],"keywords":["data nlod preface","nlod preface of","preface of licence","of licence this","this licence grants","licence grants you","right to copy","to copy use","copy use and","and distribute information","distribute information provided","information provided you","acknowledge the contributors","the contributors and","contributors and comply","and conditions stipulated","conditions stipulated in","stipulated in this","licence by using","by using information","using information made","information made available","licence you accept","licence as set","section 7 the","7 the licensor","liability for the","for the quality","information and what","what the information","information is used","used for this","for this licence","on the rights","the rights or","rights or freedoms","or freedoms of","freedoms of the","the norwegian freedom","norwegian freedom of","of information act","information act or","act or any","any other legislation","other legislation granting","legislation granting the","granting the general","general public a","public a right","right of access","access to public","to public sector","sector information or","information or that","or that follow","follow from exemptions","from exemptions or","exemptions or limitations","or limitations stipulated","limitations stipulated in","stipulated in the","in the norwegian","copyright act further","act further the","further the licence","the licence shall","licensee s freedom","s freedom of","freedom of expression","of expression recognized","expression recognized by","recognized by law","by law 1","law 1 definitions","1 definitions database","definitions database shall","database shall mean","mean a database","database or similar","or similar protected","similar protected under","under section 43","section 43 of","copyright act information","act information shall","information shall mean","shall mean texts","mean texts images","texts images recordings","images recordings data","recordings data sets","data sets or","sets or other","other works protected","works protected under","section 1 of","act or which","or which are","which are protected","are protected under","protected under provisions","under provisions addressing","provisions addressing what","addressing what is","what is referred","to as neighbouring","as neighbouring rights","rights in chapter","in chapter 5","copyright act including","act including databases","including databases and","databases and photographs","and photographs and","photographs and which","are distributed under","this licence copy","licence copy shall","copy shall mean","mean reproduction in","reproduction in any","any form licensee","form licensee and","licensee and you","you shall mean","shall mean natural","mean natural or","or legal persons","legal persons using","persons using information","licence licensor shall","mean the natural","that makes information","makes information available","this licence distribute","licence distribute shall","distribute shall mean","mean any actions","any actions whereby","actions whereby information","whereby information is","information is made","made available including","available including to","including to distribute","distribute transfer communicate","transfer communicate disperse","communicate disperse show","disperse show perform","show perform sell","perform sell lend","sell lend and","and rent use","rent use shall","shall mean one","mean one or","or more actions","more actions relevant","actions relevant to","relevant to copyright","to copyright law","copyright law requiring","law requiring permission","requiring permission from","from the owner","the copyright 2","copyright 2 licence","2 licence the","the licensee subject","licensee subject to","the limitations that","limitations that follow","follow from this","from this licence","licence may use","information for any","in all contexts","all contexts by","contexts by copying","by copying the","copying the information","information and distributing","distributing the information","information to others","to others modifying","others modifying the","modifying the information","information and or","and or combining","or combining the","combining the information","the information with","information with other","other information and","information and copying","and copying and","copying and distributing","and distributing such","distributing such changed","such changed or"]},{"licenseTexts":["NO LIMIT PUBLIC LICENSE\n\nVersion 0, June 2012 Gilles LAMIRAL\n\nLa Billais\n\n35580 Baulon\n\nFrance NO LIMIT PUBLIC LICENSE\n\nTerms and conditions for copying, distribution, modification or anything else.\n\n   0. No limit to do anything with this work and this license."],"licenseIds":["NLPL"],"keywords":["version 0 june","0 june 2012","june 2012 gilles","2012 gilles lamiral","gilles lamiral la","lamiral la billais","la billais 35580","billais 35580 baulon","35580 baulon france","baulon france no","france no limit","copying distribution modification","distribution modification or","modification or anything","or anything else","anything else 0","else 0 no","0 no limit","no limit to","limit to do","with this work","work and this","limit public license version","public license version 0","license version 0 june","version 0 june 2012","0 june 2012 gilles","june 2012 gilles lamiral","2012 gilles lamiral la","gilles lamiral la billais","lamiral la billais 35580","la billais 35580 baulon","billais 35580 baulon france","35580 baulon france no","baulon france no limit","france no limit public","limit public license terms","for copying distribution modification","copying distribution modification or","distribution modification or anything","modification or anything else","or anything else 0","anything else 0 no","else 0 no limit","0 no limit to","no limit to do","limit to do anything","anything with this work","with this work and","this work and this","work and this license","no limit public license version","limit public license version 0","public license version 0 june","license version 0 june 2012","version 0 june 2012 gilles","0 june 2012 gilles lamiral","june 2012 gilles lamiral la","2012 gilles lamiral la billais","gilles lamiral la billais 35580","lamiral la billais 35580 baulon","la billais 35580 baulon france","billais 35580 baulon france no","35580 baulon france no limit","baulon france no limit public","france no limit public license","no limit public license terms","limit public license terms and","conditions for copying distribution modification","for copying distribution modification or","copying distribution modification or anything","distribution modification or anything else","modification or anything else 0","or anything else 0 no","anything else 0 no limit","else 0 no limit to","0 no limit to do","no limit to do anything","limit to do anything with","to do anything with this","do anything with this work","anything with this work and","with this work and this","this work and this license"]},{"licenseTexts":["NETIZEN OPEN SOURCE LICENSE\n\nVersion 1.0\n\n   1. Definitions.\n\n      1.0.1. \"Commercial Use\" means distribution or otherwise making the Covered Code available to a third party.\n\n      1.1. \"Contributor\" means each entity that creates or contributes to the creation of Modifications.\n\n      1.2. \"Contributor Version\" means the combination of the Original Code, prior Modifications used by a Contributor, and the Modifications made by that particular Contributor.\n\n      1.3. \"Covered Code\" means the Original Code or Modifications or the combination of the Original Code and Modifications, in each case including portions thereof.\n\n      1.4. \"Electronic Distribution Mechanism\" means a mechanism generally accepted in the software development community for the electronic transfer of data.\n\n      1.5. \"Executable\" means Covered Code in any form other than Source Code.\n\n      1.6. \"Initial Developer\" means the individual or entity identified as the Initial Developer in the Source Code notice required by Exhibit A.\n\n      1.7. \"Larger Work\" means a work which combines Covered Code or portions thereof with code not governed by the terms of this License.\n\n      1.8. \"License\" means this document.\n\n      1.8.1. \"Licensable\" means having the right to grant, to the maximum extent possible, whether at the time of the initial grant or subsequently acquired, any and all of the rights conveyed herein.\n\n      1.9. \"Modifications\" means any addition to or deletion from the substance or structure of either the Original Code or any previous Modifications. When Covered Code is released as a series of files, a Modification is:\n\n         A. Any addition to or deletion from the contents of a file containing Original Code or previous Modifications.\n\n         B. Any new file that contains any part of the Original Code or previous Modifications.\n\n      1.10. \"Original Code\" means Source Code of computer software code which is described in the Source Code notice required by Exhibit A as Original Code, and which, at the time of its release under this License is not already Covered Code governed by this License.\n\n      1.10.1. \"Patent Claims\" means any patent claim(s), now owned or hereafter acquired, including without limitation, method, process, and apparatus claims, in any patent Licensable by grantor.\n\n      1.11. \"Source Code\" means the preferred form of the Covered Code for making modifications to it, including all modules it contains, plus any associated interface definition files, scripts used to control compilation and installation of an Executable, or source code differential comparisons against either the Original Code or another well known, available Covered Code of the Contributor's choice. The Source Code can be in a compressed or archival form, provided the appropriate decompression or de-archiving software is widely available for no charge.\n\n      1.12. \"You\" (or \"Your\") means an individual or a legal entity exercising rights under, and complying with all of the terms of, this License or a future version of this License issued under Section 6.1. For legal entities, \"You\" includes any entity which controls, is controlled by, or is under common control with You. For purposes of this definition, \"control\" means (a) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (b) ownership of more than fifty percent (50%) of the outstanding shares or beneficial ownership of such entity.\n\n   2. Source Code License.\n\n      2.1. The Initial Developer Grant. The Initial Developer hereby grants You a world-wide, royalty-free, non-exclusive license, subject to third party intellectual property claims:\n\n         (a) under intellectual property rights (other than patent or trademark) Licensable by Initial Developer to use, reproduce, modify, display, perform, sublicense and distribute the Original Code (or portions thereof) with or without Modifications, and/or as part of a Larger Work; and\n\n         (b) under Patents Claims infringed by the making, using or selling of Original Code, to make, have made, use, practice, sell, and offer for sale, and/or otherwise dispose of the Original Code (or portions thereof).\n\n         (c) the licenses granted in this Section 2.1(a) and (b) are effective on the date Initial Developer first distributes Original Code under the terms of this License.\n\n         (d) Notwithstanding Section 2.1(b) above, no patent license is granted: 1) for code that You delete from the Original Code; 2) separate from the Original Code; or 3) for infringements caused by: i) the modification of the Original Code or ii) the combination of the Original Code with other software or devices.\n\n      2.2. Contributor Grant.\n\n      Subject to third party intellectual property claims, each Contributor hereby grants You a world-wide, royalty-free, non-exclusive license\n\n         (a) under intellectual property rights (other than patent or trademark) Licensable by Contributor, to use, reproduce, modify, display, perform, sublicense and distribute the Modifications created by such Contributor (or portions thereof) either on an unmodified basis, with other Modifications, as Covered Code and/or as part of a Larger Work; and\n\n         (b) under Patent Claims infringed by the making, using, or selling of Modifications made by that Contributor either alone and/or in combination with its Contributor Version (or portions of such combination), to make, use, sell, offer for sale, have made, and/or otherwise dispose of: 1) Modifications made by that Contributor (or portions thereof); and 2) the combination of Modifications made by that Contributor with its Contributor Version (or portions of such combination).\n\n         (c) the licenses granted in Sections 2.2(a) and 2.2(b) are effective on the date Contributor first makes Commercial Use of the Covered Code.\n\n         (d) Notwithstanding Section 2.2(b) above, no patent license is granted: 1) for any code that Contributor has deleted from the Contributor Version; 2) separate from the Contributor Version; 3) for infringements caused by: i) third party modifications of Contributor Version or ii) the combination of Modifications made by that Contributor with other software (except as part of the Contributor Version) or other devices; or 4) under Patent Claims infringed by Covered Code in the absence of Modifications made by that Contributor.\n\n   3. Distribution Obligations.\n\n      3.1. Application of License. The Modifications which You create or to which You contribute are governed by the terms of this License, including without limitation Section 2.2. The Source Code version of Covered Code may be distributed only under the terms of this License or a future version of this License released under Section 6.1, and You must include a copy of this License with every copy of the Source Code You distribute. You may not offer or impose any terms on any Source Code version that alters or restricts the applicable version of this License or the recipients' rights hereunder. However, You may include an additional document offering the additional rights described in Section 3.5.\n\n      3.2. Availability of Source Code. Any Modification which You create or to which You contribute must be made available in Source Code form under the terms of this License either on the same media as an Executable version or via an accepted Electronic Distribution Mechanism to anyone to whom you made an Executable version available; and if made available via Electronic Distribution Mechanism, must remain available for at least twelve (12) months after the date it initially became available, or at least six (6) months after a subsequent version of that particular Modification has been made available to such recipients. You are responsible for ensuring that the Source Code version remains available even if the Electronic Distribution Mechanism is maintained by a third party.\n\n      3.3. Description of Modifications. You must cause all Covered Code to which You contribute to contain a file documenting the changes You made to create that Covered Code and the date of any change. You must include a prominent statement that the Modification is derived, directly or indirectly, from Original Code provided by the Initial Developer and including the name of the Initial Developer in (a) the Source Code, and (b) in any notice in an Executable version or related documentation in which You describe the origin or ownership of the Covered Code.\n\n      3.4. Intellectual Property Matters\n\n         (a) Third Party Claims.\n\n         If Contributor has knowledge that a license under a third party's intellectual property rights is required to exercise the rights granted by such Contributor under Sections 2.1 or 2.2, Contributor must include a text file with the Source Code distribution titled \"LEGAL\" which describes the claim and the party making the claim in sufficient detail that a recipient will know whom to contact. If Contributor obtains such knowledge after the Modification is made available as described in Section 3.2, Contributor shall promptly modify the LEGAL file in all copies Contributor makes available thereafter and shall take other steps (such as notifying appropriate mailing lists or newsgroups) reasonably calculated to inform those who received the Covered Code that new knowledge has been obtained.\n\n         (b) Contributor APIs.\n\n         If Contributor's Modifications include an application programming interface and Contributor has knowledge of patent licenses which are reasonably necessary to implement that API, Contributor must also include this information in the LEGAL file.\n\n         (c) Representations.\n\n         Contributor represents that, except as disclosed pursuant to Section 3.4(a) above, Contributor believes that Contributor's Modifications are Contributor's original creation(s) and/or Contributor has sufficient rights to grant the rights conveyed by this License.\n\n      3.5. Required Notices.\n\n      You must duplicate the notice in Exhibit A in each file of the Source Code. If it is not possible to put such notice in a particular Source Code file due to its structure, then You must include such notice in a location (such as a relevant directory) where a user would be likely to look for such a notice. If You created one or more Modification(s) You may add your name as a Contributor to the notice described in Exhibit A. You must also duplicate this License in any documentation for the Source Code where You describe recipients' rights or ownership rights relating to Covered Code. You may choose to offer, and to charge a fee for, warranty, support, indemnity or liability obligations to one or more recipients of Covered Code. However, You may do so only on Your own behalf, and not on behalf of the Initial Developer or any Contributor. You must make it absolutely clear than any such warranty, support, indemnity or liability obligation is offered by You alone, and You hereby agree to indemnify the Initial Developer and every Contributor for any liability incurred by the Initial Developer or such Contributor as a result of warranty, support, indemnity or liability terms You offer.\n\n      3.6. Distribution of Executable Versions.\n\n      You may distribute Covered Code in Executable form only if the requirements of Section 3.1-3.5 have been met for that Covered Code, and if You include a notice stating that the Source Code version of the Covered Code is available under the terms of this License, including a description of how and where You have fulfilled the obligations of Section 3.2. The notice must be conspicuously included in any notice in an Executable version, related documentation or collateral in which You describe recipients' rights relating to the Covered Code. You may distribute the Executable version of Covered Code or ownership rights under a license of Your choice, which may contain terms different from this License, provided that You are in compliance with the terms of this License and that the license for the Executable version does not attempt to limit or alter the recipient's rights in the Source Code version from the rights set forth in this License. If You distribute the Executable version under a different license You must make it absolutely clear that any terms which differ from this License are offered by You alone, not by the Initial Developer or any Contributor. You hereby agree to indemnify the Initial Developer and every Contributor for any liability incurred by the Initial Developer or such Contributor as a result of any such terms You offer.\n\n      3.7. Larger Works.\n\n      You may create a Larger Work by combining Covered Code with other code not governed by the terms of this License and distribute the Larger Work as a single LEDs product. In such a case, You must make sure the requirements of this License are fulfilled for the Covered Code.\n\n   4. Inability to Comply Due to Statute or Regulation.\n\n   If it is impossible for You to comply with any of the terms of this License with respect to some or all of the Covered Code due to statute, judicial order, or regulation then You must: (a) comply with the terms of this License to the maximum extent possible; and (b) describe the limitations and the code they affect. Such description must be included in the LEGAL file described in Section 3.4 and must be included with all distributions of the Source Code. Except to the extent prohibited by statute or regulation, such description must be sufficiently detailed for a recipient of ordinary skill to be able to understand it.\n\n   5. Application of this License.\n\n   This License applies to code to which the Initial Developer has attached the notice in Exhibit A and to related Covered Code.\n\n   6. Versions of the License.\n\n      6.1. New Versions.\n\n      Netizen Pty Ltd (\"Netizen \") may publish revised and/or new versions of the License from time to time. Each version will be given a distinguishing version number.\n\n      6.2. Effect of New Versions.\n\n      Once Covered Code has been published under a particular version of the License, You may always continue to use it under the terms of that version. You may also choose to use such Covered Code under the terms of any subsequent version of the License published by Netizen. No one other than Netizen has the right to modify the terms applicable to Covered Code created under this License.\n\n      6.3. Derivative Works.\n\n      If You create or use a modified version of this License (which you may only do in order to apply it to code which is not already Covered Code governed by this License), You must (a) rename Your license so that the phrases \"Netizen\", \"NOSL\" or any confusingly similar phrase do not appear in your license (except to note that your license differs from this License) and (b) otherwise make it clear that Your version of the license contains terms which differ from the Netizen Open Source License and Xen Open Source License. (Filling in the name of the Initial Developer, Original Code or Contributor in the notice described in Exhibit A shall not of themselves be deemed to be modifications of this License.)\n\n   7. DISCLAIMER OF WARRANTY.\n\n   COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN \"AS IS\" BASIS, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER.\n\n      7.1 To the extent permitted by law and except as expressly provided to the contrary in this Agreement, all warranties whether express, implied, statutory or otherwise, relating in any way to the subject matter of this Agreement or to this Agreement generally, are excluded. Where legislation implies in this Agreement any condition or warranty and that legislation avoids or prohibits provisions in a contract excluding or modifying the application of or the exercise of or liability under such term, such term shall be deemed to be included in this Agreement. However, the liability of Supplier for any breach of such term shall be limited, at the option of Supplier, to any one or more of the following: if the breach related to goods: the replacement of the goods or the supply of equivalent goods; the repair of such goods; the payment of the cost of replacing the goods or of acquiring equivalent goods; or the payment of the cost of having the goods repaired; and if the breach relates to services the supplying of the services again; or the payment of the cost of having the services supplied again.\n\n   8. TERMINATION.\n\n      8.1. This License and the rights granted hereunder will terminate automatically if You fail to comply with terms herein and fail to cure such breach within 30 days of becoming aware of the breach. All sublicenses to the Covered Code which are properly granted shall survive any termination of this License. Provisions which, by their nature, must remain in effect beyond the termination of this License shall survive.\n\n      8.2. If You initiate litigation by asserting a patent infringement claim (excluding declatory judgment actions) against Initial Developer or a Contributor (the Initial Developer or Contributor against whom You file such action is referred to as \"Participant\") alleging that:\n\n         (a) such Participant's Contributor Version directly or indirectly infringes any patent, then any and all rights granted by such Participant to You under Sections 2.1 and/or 2.2 of this License shall, upon 60 days notice from Participant terminate prospectively, unless if within 60 days after receipt of notice You either: (i) agree in writing to pay Participant a mutually agreeable reasonable royalty for Your past and future use of Modifications made by such Participant, or (ii) withdraw Your litigation claim with respect to the Contributor Version against such Participant. If within 60 days of notice, a reasonable royalty and payment arrangement are not mutually agreed upon in writing by the parties or the litigation claim is not withdrawn, the rights granted by Participant to You under Sections 2.1 and/or 2.2 automatically terminate at the expiration of the 60 day notice period specified above.\n\n         (b) any software, hardware, or device, other than such Participant's Contributor Version, directly or indirectly infringes any patent, then any rights granted to You by such Participant under Sections 2.1(b) and 2.2(b) are revoked effective as of the date You first made, used, sold, distributed, or had made, Modifications made by that Participant.\n\n      8.3. If You assert a patent infringement claim against Participant alleging that such Participant's Contributor Version directly or indirectly infringes any patent where such claim is resolved (such as by license or settlement) prior to the initiation of patent infringement litigation, then the reasonable value of the licenses granted by such Participant under Sections 2.1 or 2.2 shall be taken into account in determining the amount or value of any payment or license.\n\n      8.4. In the event of termination under Sections 8.1 or 8.2 above, all end user license agreements (excluding distributors and resellers) which have been validly granted by You or any distributor hereunder prior to termination shall survive termination.\n\n   9. LIMITATION OF LIABILITY.\n\n   UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER TORT (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL YOU, THE INITIAL DEVELOPER, ANY OTHER CONTRIBUTOR, OR ANY DISTRIBUTOR OF COVERED CODE, OR ANY SUPPLIER OF ANY OF SUCH PARTIES, BE LIABLE TO ANY PERSON FOR ANY INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, COMPUTER FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER COMMERCIAL DAMAGES OR LOSSES, EVEN IF SUCH PARTY SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF LIABILITY SHALL NOT APPLY TO LIABILITY FOR DEATH OR PERSONAL INJURY RESULTING FROM SUCH PARTY'S NEGLIGENCE TO THE EXTENT APPLICABLE LAW PROHIBITS SUCH LIMITATION. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OR LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THIS EXCLUSION AND LIMITATION MAY NOT APPLY TO YOU.\n\n   10. U.S. GOVERNMENT END USERS.\n\n   The Covered Code is a \"commercial item,\" as that term is defined in 48 C.F.R. 2.101 (Oct. 1995), consisting of \"commercial computer software\" and \"commercial computer software documentation,\" as such terms are used in 48 C.F.R. 12.212 (Sept. 1995). Consistent with 48 C.F.R. 12.212 and 48 C.F.R. 227.7202-1 through 227.7202-4 (June 1995), all U.S. Government End Users acquire Covered Code with only those rights set forth herein.\n\n   11. MISCELLANEOUS.\n\n   This License represents the complete agreement concerning subject matter hereof. If any provision of this License is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable.\n\n   This Agreement shall be governed by and construed according to the law of the State of Victoria. The parties irrevocably submit to the exclusive jurisdiction of the Courts of Victoria and Australia and any Courts hearing appeals from such Courts. This Agreement is deemed to have been made in Victoria.\n\n   The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded. Any law or regulation which provides that the language of a contract shall be construed against the drafter shall not apply to this License.\n\n   12. RESPONSIBILITY FOR CLAIMS.\n\n   As between Initial Developer and the Contributors, each party is responsible for claims and damages arising, directly or indirectly, out of its utilization of rights under this License and You agree to work with Initial Developer and Contributors to distribute such responsibility on an equitable basis. Nothing herein is intended or shall be deemed to constitute any admission of liability.\n\n   13. MULTIPLE-LICENSED CODE.\n\n   Initial Developer may designate portions of the Covered Code as \"Multiple-Licensed\". \"Multiple-Licensed\" means that the Initial Developer permits you to utilize portions of the Covered Code under Your choice of the NPL or the alternative licenses, if any, specified by the Initial Developer in the file described in Exhibit A. EXHIBIT A - Netizen Open Source License\n\n``The contents of this file are subject to the Netizen Open Source License Version 1.0 (the \"License\"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://netizen.com.au/licenses/NOPL/\n\nSoftware distributed under the License is distributed on an \"AS IS\" basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the specific language governing rights and limitations under the License.\n\nThe Original Code is ______________________________________.\n\nThe Initial Developer of the Original Code is ________________________. Portions created by ______________________ are Copyright (C) ______ _______________________. All Rights Reserved.\n\nContributor(s): ______________________________________.\n\nAlternatively, the contents of this file may be used under the terms of the _____ license (the \"[___] License\"), in which case the provisions of [______] License are applicable instead of those above. If you wish to allow use of your version of this file only under the terms of the [____] License and not to allow others to use your version of this file under the NOSL, indicate your decision by deleting the provisions above and replace them with the notice and other provisions required by the [___] License. If you do not delete the provisions above, a recipient may use your version of this file under either the NOSL or the [___] License.\"\n\n[NOTE: The text of this Exhibit A may differ slightly from the text of the notices in the Source Code files of the Original Code. You should use the text of this Exhibit A rather than the text found in the Original Code Source Code for Your Modifications.]"],"licenseIds":["NOSL"],"keywords":["a single leds","single leds product","leds product in","new versions netizen","versions netizen pty","netizen pty ltd","pty ltd netizen","ltd netizen may","netizen may publish","published by netizen","by netizen no","netizen no one","other than netizen","than netizen has","netizen has the","the phrases netizen","phrases netizen nosl","netizen nosl or","nosl or any","from the netizen","license and xen","and xen open","xen open source","source license filling","7 1 to","expressly provided to","contrary in this","agreement all warranties","all warranties whether","or otherwise relating","otherwise relating in","relating in any","way to the","or to this","this agreement generally","agreement generally are","generally are excluded","are excluded where","excluded where legislation","where legislation implies","legislation implies in","implies in this","agreement any condition","any condition or","condition or warranty","or warranty and","and that legislation","that legislation avoids","legislation avoids or","avoids or prohibits","or prohibits provisions","prohibits provisions in","provisions in a","in a contract","a contract excluding","contract excluding or","excluding or modifying","modifying the application","application of or","of or liability","or liability under","liability under such","under such term","such term such","term such term","agreement however the","however the liability","the liability of","liability of supplier","of supplier for","supplier for any","for any breach","breach of such","of such term","be limited at","limited at the","option of supplier","of supplier to","supplier to any","to any one","any one or","following if the","the breach related","breach related to","related to goods","to goods the","goods the replacement","the replacement of","of the goods","or the supply","the supply of","supply of equivalent","of equivalent goods","equivalent goods the","goods the repair","the repair of","repair of such","of such goods","such goods the","goods the payment","cost of replacing","of replacing the","replacing the goods","goods or of","or of acquiring","of acquiring equivalent","acquiring equivalent goods","equivalent goods or","having the goods","the goods repaired","goods repaired and","repaired and if","the breach relates","breach relates to","relates to services","to services the","services the supplying","the supplying of","supplying of the","of the services","the services again","services again or","again or the","having the services","the services supplied","services supplied again","supplied again 8","again 8 termination","enforceable this agreement","and construed according","to the law","state of victoria","of victoria the","victoria the parties","the parties irrevocably","parties irrevocably submit","irrevocably submit to","submit to the","courts of victoria","of victoria and","victoria and australia","and australia and","australia and any","and any courts","any courts hearing","courts hearing appeals","hearing appeals from","appeals from such","from such courts","such courts this","courts this agreement","agreement is deemed","is deemed to","been made in","made in victoria","in victoria the","victoria the application","exhibit a netizen","a netizen open","to the netizen","at http netizen","http netizen com","netizen com au","com au licenses","au licenses nopl","licenses nopl software","nopl software distributed","under the nosl","the nosl indicate","nosl indicate your","either the nosl","the nosl or","nosl or the","as a single leds","a single leds product","single leds product in","leds product in such","1 new versions netizen","new versions netizen pty","versions netizen pty ltd","netizen pty ltd netizen","pty ltd netizen may","ltd netizen may publish","netizen may publish revised","license published by netizen","published by netizen no","by netizen no one","netizen no one other","one other than netizen","other than netizen has","than netizen has the","netizen has the right","that the phrases netizen","the phrases netizen nosl","phrases netizen nosl or","netizen nosl or any","nosl or any confusingly","differ from the netizen","from the netizen open","open source license and"]},{"licenseTexts":["NETSCAPE PUBLIC LICENSE\n\nVersion 1.0\n\n   1. Definitions.\n\n      1.1. ``Contributor'' means each entity that creates or contributes to the creation of Modifications.\n\n      1.2. ``Contributor Version'' means the combination of the Original Code, prior Modifications used by a Contributor, and the Modifications made by that particular Contributor.\n\n      1.3. ``Covered Code'' means the Original Code or Modifications or the combination of the Original Code and Modifications, in each case including portions thereof.\n\n      1.4. ``Electronic Distribution Mechanism'' means a mechanism generally accepted in the software development community for the electronic transfer of data.\n\n      1.5. ``Executable'' means Covered Code in any form other than Source Code.\n\n      1.6. ``Initial Developer'' means the individual or entity identified as the Initial Developer in the Source Code notice required byExhibit A.\n\n      1.7. ``Larger Work'' means a work which combines Covered Code or portions thereof with code not governed by the terms of this License.\n\n      1.8. ``License'' means this document.\n\n      1.9. ``Modifications'' means any addition to or deletion from the substance or structure of either the Original Code or any previous Modifications. When Covered Code is released as a series of files, a Modification is:\n\n         A. Any addition to or deletion from the contents of a file containing Original Code or previous Modifications.\n\n         B. Any new file that contains any part of the Original Code or previous Modifications.\n\n      1.10. ``Original Code'' means Source Code of computer software code which is described in the Source Code notice required byExhibit A as Original Code, and which, at the time of its release under this License is not already Covered Code governed by this License.\n\n      1.11. ``Source Code'' means the preferred form of the Covered Code for making modifications to it, including all modules it contains, plus any associated interface definition files, scripts used to control compilation and installation of an Executable, or a list of source code differential comparisons against either the Original Code or another well known, available Covered Code of the Contributor's choice. The Source Code can be in a compressed or archival form, provided the appropriate decompression or de-archiving software is widely available for no charge.\n\n      1.12. ``You'' means an individual or a legal entity exercising rights under, and complying with all of the terms of, this License or a future version of this License issued under Section 6.1. For legal entities, ``You'' includes any entity which controls, is controlled by, or is under common control with You. For purposes of this definition, ``control'' means (a) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (b) ownership of fifty percent (50%) or more of the outstanding shares or beneficial ownership of such entity.\n\n   2. Source Code License.\n\n      2.1. The Initial Developer Grant. The Initial Developer hereby grants You a world-wide, royalty-free, non-exclusive license, subject to third party intellectual property claims:\n\n         a) to use, reproduce, modify, display, perform, sublicense and distribute the Original Code (or portions thereof) with or without Modifications, or as part of a Larger Work; and\n\n         (b) under patents now or hereafter owned or controlled by Initial Developer, to make, have made, use and sell (``Utilize'') the Original Code (or portions thereof), but solely to the extent that any such patent is reasonably necessary to enable You to Utilize the Original Code (or portions thereof) and not to any greater extent that may be necessary to Utilize further Modifications or combinations.\n\n      \n\n      2.2. Contributor Grant.\n\n      Each Contributor hereby grants You a world-wide, royalty-free, non-exclusive license, subject to third party intellectual property claims:\n\n         (a) to use, reproduce, modify, display, perform, sublicense and distribute the Modifications created by such Contributor (or portions thereof) either on an unmodified basis, with other Modifications, as Covered Code or as part of a Larger Work; and\n\n         (b) under patents now or hereafter owned or controlled by Contributor, to Utilize the Contributor Version (or portions thereof), but solely to the extent that any such patent is reasonably necessary to enable You to Utilize the Contributor Version (or portions thereof), and not to any greater extent that may be necessary to Utilize further Modifications or combinations.\n\n   3. Distribution Obligations.\n\n      3.1. Application of License. The Modifications which You create or to which You contribute are governed by the terms of this License, including without limitation Section 2.2. The Source Code version of Covered Code may be distributed only under the terms of this License or a future version of this License released under Section 6.1, and You must include a copy of this License with every copy of the Source Code You distribute. You may not offer or impose any terms on any Source Code version that alters or restricts the applicable version of this License or the recipients' rights hereunder. However, You may include an additional document offering the additional rights described in Section 3.5.\n\n      3.2. Availability of Source Code. Any Modification which You create or to which You contribute must be made available in Source Code form under the terms of this License either on the same media as an Executable version or via an accepted Electronic Distribution Mechanism to anyone to whom you made an Executable version available; and if made available via Electronic Distribution Mechanism, must remain available for at least twelve (12) months after the date it initially became available, or at least six (6) months after a subsequent version of that particular Modification has been made available to such recipients. You are responsible for ensuring that the Source Code version remains available even if the Electronic Distribution Mechanism is maintained by a third party.\n\n      3.3. Description of Modifications. You must cause all Covered Code to which you contribute to contain a file documenting the changes You made to create that Covered Code and the date of any change. You must include a prominent statement that the Modification is derived, directly or indirectly, from Original Code provided by the Initial Developer and including the name of the Initial Developer in (a) the Source Code, and (b) in any notice in an Executable version or related documentation in which You describe the origin or ownership of the Covered Code.\n\n      3.4. Intellectual Property Matters\n\n         (a) Third Party Claims. If You have knowledge that a party claims an intellectual property right in particular functionality or code (or its utilization under this License), you must include a text file with the source code distribution titled ``LEGAL'' which describes the claim and the party making the claim in sufficient detail that a recipient will know whom to contact. If you obtain such knowledge after You make Your Modification available as described in Section 3.2, You shall promptly modify the LEGAL file in all copies You make available thereafter and shall take other steps (such as notifying appropriate mailing lists or newsgroups) reasonably calculated to inform those who received the Covered Code that new knowledge has been obtained.\n\n         (b) Contributor APIs. If Your Modification is an application programming interface and You own or control patents which are reasonably necessary to implement that API, you must also include this information in the LEGAL file.\n\n      3.5. Required Notices. You must duplicate the notice in Exhibit A in each file of the Source Code, and this License in any documentation for the Source Code, where You describe recipients' rights relating to Covered Code. If You created one or more Modification(s), You may add your name as a Contributor to the notice described in Exhibit A. If it is not possible to put such notice in a particular Source Code file due to its structure, then you must include such notice in a location (such as a relevant directory file) where a user would be likely to look for such a notice. You may choose to offer, and to charge a fee for, warranty, support, indemnity or liability obligations to one or more recipients of Covered Code. However, You may do so only on Your own behalf, and not on behalf of the Initial Developer or any Contributor. You must make it absolutely clear than any such warranty, support, indemnity or liability obligation is offered by You alone, and You hereby agree to indemnify the Initial Developer and every Contributor for any liability incurred by the Initial Developer or such Contributor as a result of warranty, support, indemnity or liability terms You offer.\n\n      3.6. Distribution of Executable Versions. You may distribute Covered Code in Executable form only if the requirements of Section 3.1-3.5 have been met for that Covered Code, and if You include a notice stating that the Source Code version of the Covered Code is available under the terms of this License, including a description of how and where You have fulfilled the obligations of Section 3.2. The notice must be conspicuously included in any notice in an Executable version, related documentation or collateral in which You describe recipients' rights relating to the Covered Code. You may distribute the Executable version of Covered Code under a license of Your choice, which may contain terms different from this License, provided that You are in compliance with the terms of this License and that the license for the Executable version does not attempt to limit or alter the recipient's rights in the Source Code version from the rights set forth in this License. If You distribute the Executable version under a different license You must make it absolutely clear that any terms which differ from this License are offered by You alone, not by the Initial Developer or any Contributor. You hereby agree to indemnify the Initial Developer and every Contributor for any liability incurred by the Initial Developer or such Contributor as a result of any such terms You offer.\n\n      3.7. Larger Works. You may create a Larger Work by combining Covered Code with other code not governed by the terms of this License and distribute the Larger Work as a single product. In such a case, You must make sure the requirements of this License are fulfilled for the Covered Code.\n\n   4. Inability to Comply Due to Statute or Regulation.\n\n   If it is impossible for You to comply with any of the terms of this License with respect to some or all of the Covered Code due to statute or regulation then You must: (a) comply with the terms of this License to the maximum extent possible; and (b) describe the limitations and the code they affect. Such description must be included in the LEGAL file described in Section 3.4 and must be included with all distributions of the Source Code. Except to the extent prohibited by statute or regulation, such description must be sufficiently detailed for a recipient of ordinary skill to be able to understand it.\n\n   5. Application of this License.\n\n   This License applies to code to which the Initial Developer has attached the notice in Exhibit A, and to related Covered Code.\n\n   6. Versions of the License.\n\n      6.1. New Versions. Netscape Communications Corporation (``Netscape'') may publish revised and/or new versions of the License from time to time. Each version will be given a distinguishing version number.\n\n      6.2. Effect of New Versions. Once Covered Code has been published under a particular version of the License, You may always continue to use it under the terms of that version. You may also choose to use such Covered Code under the terms of any subsequent version of the License published by Netscape. No one other than Netscape has the right to modify the terms applicable to Covered Code created under this License.\n\n      6.3. Derivative Works. If you create or use a modified version of this License (which you may only do in order to apply it to code which is not already Covered Code governed by this License), you must (a) rename Your license so that the phrases ``Mozilla'', ``MOZILLAPL'', ``MOZPL'', ``Netscape'', ``NPL'' or any confusingly similar phrase do not appear anywhere in your license and (b) otherwise make it clear that your version of the license contains terms which differ from the Mozilla Public License and Netscape Public License. (Filling in the name of the Initial Developer, Original Code or Contributor in the notice described in Exhibit A shall not of themselves be deemed to be modifications of this License.)\n\n   7. DISCLAIMER OF WARRANTY.\n\n   COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN ``AS IS'' BASIS, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER.\n\n   8. TERMINATION.\n\n   This License and the rights granted hereunder will terminate automatically if You fail to comply with terms herein and fail to cure such breach within 30 days of becoming aware of the breach. All sublicenses to the Covered Code which are properly granted shall survive any termination of this License. Provisions which, by their nature, must remain in effect beyond the termination of this License shall survive.\n\n   9. LIMITATION OF LIABILITY.\n\n   UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER TORT (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL THE INITIAL DEVELOPER, ANY OTHER CONTRIBUTOR, OR ANY DISTRIBUTOR OF COVERED CODE, OR ANY SUPPLIER OF ANY OF SUCH PARTIES, BE LIABLE TO YOU OR ANY OTHER PERSON FOR ANY INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, COMPUTER FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER COMMERCIAL DAMAGES OR LOSSES, EVEN IF SUCH PARTY SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF LIABILITY SHALL NOT APPLY TO LIABILITY FOR DEATH OR PERSONAL INJURY RESULTING FROM SUCH PARTY'S NEGLIGENCE TO THE EXTENT APPLICABLE LAW PROHIBITS SUCH LIMITATION. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OR LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THAT EXCLUSION AND LIMITATION MAY NOT APPLY TO YOU.\n\n   10. U.S. GOVERNMENT END USERS.\n\n   The Covered Code is a ``commercial item,'' as that term is defined in 48 C.F.R. 2.101 (Oct. 1995), consisting of ``commercial computer software'' and ``commercial computer software documentation,'' as such terms are used in 48 C.F.R. 12.212 (Sept. 1995). Consistent with 48 C.F.R. 12.212 and 48 C.F.R. 227.7202-1 through 227.7202-4 (June 1995), all U.S. Government End Users acquire Covered Code with only those rights set forth herein.\n\n   11. MISCELLANEOUS.\n\n   This License represents the complete agreement concerning subject matter hereof. If any provision of this License is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable. This License shall be governed by California law provisions (except to the extent applicable law, if any, provides otherwise), excluding its conflict-of-law provisions. With respect to disputes in which at least one party is a citizen of, or an entity chartered or registered to do business in, the United States of America: (a) unless otherwise agreed in writing, all disputes relating to this License (excepting any dispute relating to intellectual property rights) shall be subject to final and binding arbitration, with the losing party paying all costs of arbitration; (b) any arbitration relating to this Agreement shall be held in Santa Clara County, California, under the auspices of JAMS/EndDispute; and (c) any litigation relating to this Agreement shall be subject to the jurisdiction of the Federal Courts of the Northern District of California, with venue lying in Santa Clara County, California, with the losing party responsible for costs, including without limitation, court costs and reasonable attorneys fees and expenses. The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded. Any law or regulation which provides that the language of a contract shall be construed against the drafter shall not apply to this License.\n\n   12. RESPONSIBILITY FOR CLAIMS.\n\n   Except in cases where another Contributor has failed to comply with Section 3.4, You are responsible for damages arising, directly or indirectly, out of Your utilization of rights under this License, based on the number of copies of Covered Code you made available, the revenues you received from utilizing such rights, and other relevant factors. You agree to work with affected parties to distribute responsibility on an equitable basis.\n\nAMENDMENTS\n\nAdditional Terms applicable to the Netscape Public License.\n\n   I. Effect.\n\n   These additional terms described in this Netscape Public License -- Amendments shall apply to the Mozilla Communicator client code and to all Covered Code under this License.\n\n   II. ``Netscape's Branded Code'' means Covered Code that Netscape distributes and/or permits others to distribute under one or more trademark(s) which are controlled by Netscape but which are not licensed for use under this License.\n\n   III. Netscape and logo.\n\n   This License does not grant any rights to use the trademark ``Netscape'', the ``Netscape N and horizon'' logo or the Netscape lighthouse logo, even if such marks are included in the Original Code.\n\n   IV. Inability to Comply Due to Contractual Obligation.\n\n   Prior to licensing the Original Code under this License, Netscape has licensed third party code for use in Netscape's Branded Code. To the extent that Netscape is limited contractually from making such third party code available under this License, Netscape may choose to reintegrate such code into Covered Code without being required to distribute such code in Source Code form, even if such code would otherwise be considered ``Modifications'' under this License.\n\n   V. Use of Modifications and Covered Code by Initial Developer.\n\n   V.1. In General. The obligations of Section 3 apply to Netscape, except to the extent specified in this Amendment, Section V.2 and V.3.\n\n   V.2. Other Products. Netscape may include Covered Code in products other than the Netscape's Branded Code which are released by Netscape during the two (2) years following the release date of the Original Code, without such additional products becoming subject to the terms of this License, and may license such additional products on different terms from those contained in this License. V.3. Alternative Licensing. Netscape may license the Source Code of Netscape's Branded Code, including Modifications incorporated therein, without such additional products becoming subject to the terms of this License, and may license such additional products on different terms from those contained in this License.\n\n   VI. Arbitration and Litigation.\n\n   Notwithstanding the limitations of Section 11 above, the provisions regarding arbitration and litigation in Section 11(a), (b) and (c) of the License shall apply to all disputes relating to this License. EXHIBIT A.\n\n\"The contents of this file are subject to the Netscape Public License Version 1.0 (the \"License\"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.mozilla.org/NPL/\n\nSoftware distributed under the License is distributed on an \"AS IS\" basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the specific language governing rights and limitations under the License.\n\nThe Original Code is Mozilla Communicator client code, released March 31, 1998.\n\nThe Initial Developer of the Original Code is Netscape Communications Corporation. Portions created by Netscape are Copyright (C) 1998 Netscape Communications Corporation. All Rights Reserved.\n\nContributor(s): ______________________________________.\"\n\n[NOTE: The text of this Exhibit A may differ slightly from the text of the notices in the Source Code files of the Original Code. This is due to time constraints encountered in simultaneously finalizing the License and in preparing the Original Code for release. You should use the text of this Exhibit A rather than the text found in the Original Code Source Code for Your Modifications.]"],"licenseIds":["NPL-1.0"],"keywords":["byexhibit a 1","byexhibit a as","equitable basis amendments","basis amendments additional","amendments additional terms","the trademark netscape","trademark netscape the","lighthouse logo even","original code iv","code iv inability","license vi arbitration","vi arbitration and","and litigation notwithstanding","provisions regarding arbitration","regarding arbitration and","and litigation in","c 1998 netscape","1998 netscape communications","original code this","code this is","this is due","is due to","due to time","to time constraints","time constraints encountered","constraints encountered in","encountered in simultaneously","in simultaneously finalizing","simultaneously finalizing the","finalizing the license","and in preparing","in preparing the","preparing the original","code for release","for release you","release you should","required byexhibit a 1","byexhibit a 1 7","required byexhibit a as","byexhibit a as original","an equitable basis amendments","equitable basis amendments additional","basis amendments additional terms","amendments additional terms applicable","use the trademark netscape","the trademark netscape the","trademark netscape the netscape","netscape lighthouse logo even","lighthouse logo even if","the original code iv","original code iv inability","code iv inability to","therein without such additional","this license vi arbitration","license vi arbitration and","vi arbitration and litigation","arbitration and litigation notwithstanding","and litigation notwithstanding the","the provisions regarding arbitration","provisions regarding arbitration and","regarding arbitration and litigation","arbitration and litigation in","and litigation in section","copyright c 1998 netscape","c 1998 netscape communications","1998 netscape communications corporation","the original code this","original code this is","code this is due","this is due to","is due to time","due to time constraints","to time constraints encountered","time constraints encountered in","constraints encountered in simultaneously","encountered in simultaneously finalizing","in simultaneously finalizing the","simultaneously finalizing the license","finalizing the license and","license and in preparing","and in preparing the","in preparing the original","preparing the original code","original code for release","code for release you","for release you should","release you should use","notice required byexhibit a 1","required byexhibit a 1 7","byexhibit a 1 7 larger","notice required byexhibit a as","required byexhibit a as original","byexhibit a as original code","on an equitable basis amendments","an equitable basis amendments additional","equitable basis amendments additional terms","basis amendments additional terms applicable","amendments additional terms applicable to","to use the trademark netscape","use the trademark netscape the","the trademark netscape the netscape","trademark netscape the netscape n","the netscape lighthouse logo even","netscape lighthouse logo even if","lighthouse logo even if such","in the original code iv","the original code iv inability","original code iv inability to","code iv inability to comply","incorporated therein without such additional","therein without such additional products","in this license vi arbitration","this license vi arbitration and","license vi arbitration and litigation","vi arbitration and litigation notwithstanding","arbitration and litigation notwithstanding the","and litigation notwithstanding the limitations","above the provisions regarding arbitration","the provisions regarding arbitration and","provisions regarding arbitration and litigation","regarding arbitration and litigation in","arbitration and litigation in section","and litigation in section 11","are copyright c 1998 netscape","copyright c 1998 netscape communications","c 1998 netscape communications corporation","1998 netscape communications corporation all","of the original code this","the original code this is","original code this is due","code this is due to","this is due to time","is due to time constraints","due to time constraints encountered","to time constraints encountered in","time constraints encountered in simultaneously","constraints encountered in simultaneously finalizing","encountered in simultaneously finalizing the","in simultaneously finalizing the license","simultaneously finalizing the license and","finalizing the license and in","the license and in preparing","license and in preparing the","and in preparing the original","in preparing the original code","preparing the original code for","the original code for release","original code for release you","code for release you should","for release you should use","release you should use the"]},{"licenseTexts":["Netscape Public LIcense version 1.1\n\nAMENDMENTS\n\nThe Netscape Public License Version 1.1 (\"NPL\") consists of the Mozilla Public License Version 1.1 with the following Amendments, including Exhibit A-Netscape Public License. Files identified with \"Exhibit A-Netscape Public License\" are governed by the Netscape Public License Version 1.1.\n\nAdditional Terms applicable to the Netscape Public License.\n\n   I. Effect.\n\n   These additional terms described in this Netscape Public License -- Amendments shall apply to the Mozilla Communicator client code and to all Covered Code under this License.\n\n   II. \"Netscape's Branded Code\" means Covered Code that Netscape distributes and/or permits others to distribute under one or more trademark(s) which are controlled by Netscape but which are not licensed for use under this License.\n\n   III. Netscape and logo.\n\n   This License does not grant any rights to use the trademarks \"Netscape\", the \"Netscape N and horizon\" logo or the \"Netscape lighthouse\" logo, \"Netcenter\", \"Gecko\", \"Java\" or \"JavaScript\", \"Smart Browsing\" even if such marks are included in the Original Code or Modifications.\n\n   IV. Inability to Comply Due to Contractual Obligation.\n\n   Prior to licensing the Original Code under this License, Netscape has licensed third party code for use in Netscape's Branded Code. To the extent that Netscape is limited contractually from making such third party code available under this License, Netscape may choose to reintegrate such code into Covered Code without being required to distribute such code in Source Code form, even if such code would otherwise be considered \"Modifications\" under this License.\n\n   V. Use of Modifications and Covered Code by Initial Developer.\n\n      V.1. In General.\n\n      The obligations of Section 3 apply to Netscape, except to the extent specified in this Amendment, Section V.2 and V.3.\n\n      V.2. Other Products.\n\n      Netscape may include Covered Code in products other than the Netscape's Branded Code which are released by Netscape during the two (2) years following the release date of the Original Code, without such additional products becoming subject to the terms of this License, and may license such additional products on different terms from those contained in this License.\n\n      V.3. Alternative Licensing.\n\n      Netscape may license the Source Code of Netscape's Branded Code, including Modifications incorporated therein, without such Netscape Branded Code becoming subject to the terms of this License, and may license such Netscape Branded Code on different terms from those contained in this License.\n\n   VI. Litigation.\n\n   Notwithstanding the limitations of Section 11 above, the provisions regarding litigation in Section 11(a), (b) and (c) of the License shall apply to all disputes relating to this License.\n\n   EXHIBIT A-Netscape Public License.\n\n   \"The contents of this file are subject to the Netscape Public License Version 1.1 (the \"License\"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.mozilla.org/NPL/\n\nSoftware distributed under the License is distributed on an \"AS IS\" basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the specific language governing rights and limitations under the License.\n\nThe Original Code is Mozilla Communicator client code, released March 31, 1998.\n\nThe Initial Developer of the Original Code is Netscape Communications Corporation. Portions created by Netscape are Copyright (C) 1998-1999 Netscape Communications Corporation. All Rights Reserved.\n\nContributor(s): ______________________________________.\n\nAlternatively, the contents of this file may be used under the terms of the _____ license (the \"[___] License\"), in which case the provisions of [______] License are applicable instead of those above. If you wish to allow use of your version of this file only under the terms of the [____] License and not to allow others to use your version of this file under the NPL, indicate your decision by deleting the provisions above and replace them with the notice and other provisions required by the [___] License. If you do not delete the provisions above, a recipient may use your version of this file under either the NPL or the [___] License.\"\n\nMozilla Public License Version 1.1\n\n   1. Definitions.\n\n   1.0.1. \"Commercial Use\" means distribution or otherwise making the Covered Code available to a third party.\n\n      1.1. \"Contributor\" means each entity that creates or contributes to the creation of Modifications.\n\n      1.2. \"Contributor Version\" means the combination of the Original Code, prior Modifications used by a Contributor, and the Modifications made by that particular Contributor.\n\n      1.3. \"Covered Code\" means the Original Code or Modifications or the combination of the Original Code and Modifications, in each case including portions thereof.\n\n      1.4. \"Electronic Distribution Mechanism\" means a mechanism generally accepted in the software development community for the electronic transfer of data.\n\n      1.5. \"Executable\" means Covered Code in any form other than Source Code.\n\n      1.6. \"Initial Developer\" means the individual or entity identified as the Initial Developer in the Source Code notice required by Exhibit A.\n\n      1.7. \"Larger Work\" means a work which combines Covered Code or portions thereof with code not governed by the terms of this License.\n\n      1.8. \"License\" means this document.\n\n      1.8.1. \"Licensable\" means having the right to grant, to the maximum extent possible, whether at the time of the initial grant or subsequently acquired, any and all of the rights conveyed herein.\n\n      1.9. \"Modifications\" means any addition to or deletion from the substance or structure of either the Original Code or any previous Modifications. When Covered Code is released as a series of files, a Modification is:\n\n      Any addition to or deletion from the contents of a file containing Original Code or previous Modifications.\n\n      Any new file that contains any part of the Original Code or previous Modifications.\n\n      1.10. \"Original Code\" means Source Code of computer software code which is described in the Source Code notice required by Exhibit A as Original Code, and which, at the time of its release under this License is not already Covered Code governed by this License.\n\n      1.10.1. \"Patent Claims\" means any patent claim(s), now owned or hereafter acquired, including without limitation, method, process, and apparatus claims, in any patent Licensable by grantor.\n\n      1.11. \"Source Code\" means the preferred form of the Covered Code for making modifications to it, including all modules it contains, plus any associated interface definition files, scripts used to control compilation and installation of an Executable, or source code differential comparisons against either the Original Code or another well known, available Covered Code of the Contributor's choice. The Source Code can be in a compressed or archival form, provided the appropriate decompression or de-archiving software is widely available for no charge.\n\n      1.12. \"You\" (or \"Your\") means an individual or a legal entity exercising rights under, and complying with all of the terms of, this License or a future version of this License issued under Section 6.1. For legal entities, \"You\" includes any entity which controls, is controlled by, or is under common control with You. For purposes of this definition, \"control\" means (a) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (b) ownership of more than fifty percent (50%) of the outstanding shares or beneficial ownership of such entity.\n\n   2. Source Code License.\n\n      2.1. The Initial Developer Grant. The Initial Developer hereby grants You a world-wide, royalty-free, non-exclusive license, subject to third party intellectual property claims:\n\n         a. under intellectual property rights (other than patent or trademark) Licensable by Initial Developer to use, reproduce, modify, display, perform, sublicense and distribute the Original Code (or portions thereof) with or without Modifications, and/or as part of a Larger Work; and\n\n         b. under Patents Claims infringed by the making, using or selling of Original Code, to make, have made, use, practice, sell, and offer for sale, and/or otherwise dispose of the Original Code (or portions thereof).\n\n         c. the licenses granted in this Section 2.1 (a) and (b) are effective on the date Initial Developer first distributes Original Code under the terms of this License.\n\n         d. Notwithstanding Section 2.1 (b) above, no patent license is granted: 1) for code that You delete from the Original Code; 2) separate from the Original Code; or 3) for infringements caused by: i) the modification of the Original Code or ii) the combination of the Original Code with other software or devices.\n\n      2.2. Contributor Grant. Subject to third party intellectual property claims, each Contributor hereby grants You a world-wide, royalty-free, non-exclusive license\n\n         a. under intellectual property rights (other than patent or trademark) Licensable by Contributor, to use, reproduce, modify, display, perform, sublicense and distribute the Modifications created by such Contributor (or portions thereof) either on an unmodified basis, with other Modifications, as Covered Code and/or as part of a Larger Work; and\n\n         b. under Patent Claims infringed by the making, using, or selling of Modifications made by that Contributor either alone and/or in combination with its Contributor Version (or portions of such combination), to make, use, sell, offer for sale, have made, and/or otherwise dispose of: 1) Modifications made by that Contributor (or portions thereof); and 2) the combination of Modifications made by that Contributor with its Contributor Version (or portions of such combination).\n\n         c. the licenses granted in Sections 2.2 (a) and 2.2 (b) are effective on the date Contributor first makes Commercial Use of the Covered Code.\n\n         d. Notwithstanding Section 2.2 (b) above, no patent license is granted: 1) for any code that Contributor has deleted from the Contributor Version; 2) separate from the Contributor Version; 3) for infringements caused by: i) third party modifications of Contributor Version or ii) the combination of Modifications made by that Contributor with other software (except as part of the Contributor Version) or other devices; or 4) under Patent Claims infringed by Covered Code in the absence of Modifications made by that Contributor.\n\n   3. Distribution Obligations.\n\n      3.1. Application of License. The Modifications which You create or to which You contribute are governed by the terms of this License, including without limitation Section 2.2. The Source Code version of Covered Code may be distributed only under the terms of this License or a future version of this License released under Section 6.1, and You must include a copy of this License with every copy of the Source Code You distribute. You may not offer or impose any terms on any Source Code version that alters or restricts the applicable version of this License or the recipients' rights hereunder. However, You may include an additional document offering the additional rights described in Section 3.5.\n\n      3.2. Availability of Source Code. Any Modification which You create or to which You contribute must be made available in Source Code form under the terms of this License either on the same media as an Executable version or via an accepted Electronic Distribution Mechanism to anyone to whom you made an Executable version available; and if made available via Electronic Distribution Mechanism, must remain available for at least twelve (12) months after the date it initially became available, or at least six (6) months after a subsequent version of that particular Modification has been made available to such recipients. You are responsible for ensuring that the Source Code version remains available even if the Electronic Distribution Mechanism is maintained by a third party.\n\n      3.3. Description of Modifications. You must cause all Covered Code to which You contribute to contain a file documenting the changes You made to create that Covered Code and the date of any change. You must include a prominent statement that the Modification is derived, directly or indirectly, from Original Code provided by the Initial Developer and including the name of the Initial Developer in (a) the Source Code, and (b) in any notice in an Executable version or related documentation in which You describe the origin or ownership of the Covered Code.\n\n      3.4. Intellectual Property Matters\n\n         (a) Third Party Claims\n\n         If Contributor has knowledge that a license under a third party's intellectual property rights is required to exercise the rights granted by such Contributor under Sections 2.1 or 2.2, Contributor must include a text file with the Source Code distribution titled \"LEGAL\" which describes the claim and the party making the claim in sufficient detail that a recipient will know whom to contact. If Contributor obtains such knowledge after the Modification is made available as described in Section 3.2, Contributor shall promptly modify the LEGAL file in all copies Contributor makes available thereafter and shall take other steps (such as notifying appropriate mailing lists or newsgroups) reasonably calculated to inform those who received the Covered Code that new knowledge has been obtained.\n\n         (b) Contributor APIs\n\n         If Contributor's Modifications include an application programming interface and Contributor has knowledge of patent licenses which are reasonably necessary to implement that API, Contributor must also include this information in the LEGAL file.\n\n         (c) Representations.\n\n         Contributor represents that, except as disclosed pursuant to Section 3.4 (a) above, Contributor believes that Contributor's Modifications are Contributor's original creation(s) and/or Contributor has sufficient rights to grant the rights conveyed by this License.\n\n      3.5. Required Notices. You must duplicate the notice in Exhibit A in each file of the Source Code. If it is not possible to put such notice in a particular Source Code file due to its structure, then You must include such notice in a location (such as a relevant directory) where a user would be likely to look for such a notice. If You created one or more Modification(s) You may add your name as a Contributor to the notice described in Exhibit A. You must also duplicate this License in any documentation for the Source Code where You describe recipients' rights or ownership rights relating to Covered Code. You may choose to offer, and to charge a fee for, warranty, support, indemnity or liability obligations to one or more recipients of Covered Code. However, You may do so only on Your own behalf, and not on behalf of the Initial Developer or any Contributor. You must make it absolutely clear than any such warranty, support, indemnity or liability obligation is offered by You alone, and You hereby agree to indemnify the Initial Developer and every Contributor for any liability incurred by the Initial Developer or such Contributor as a result of warranty, support, indemnity or liability terms You offer.\n\n      3.6. Distribution of Executable Versions. You may distribute Covered Code in Executable form only if the requirements of Sections 3.1, 3.2, 3.3, 3.4 and 3.5 have been met for that Covered Code, and if You include a notice stating that the Source Code version of the Covered Code is available under the terms of this License, including a description of how and where You have fulfilled the obligations of Section 3.2. The notice must be conspicuously included in any notice in an Executable version, related documentation or collateral in which You describe recipients' rights relating to the Covered Code. You may distribute the Executable version of Covered Code or ownership rights under a license of Your choice, which may contain terms different from this License, provided that You are in compliance with the terms of this License and that the license for the Executable version does not attempt to limit or alter the recipient's rights in the Source Code version from the rights set forth in this License. If You distribute the Executable version under a different license You must make it absolutely clear that any terms which differ from this License are offered by You alone, not by the Initial Developer or any Contributor. You hereby agree to indemnify the Initial Developer and every Contributor for any liability incurred by the Initial Developer or such Contributor as a result of any such terms You offer.\n\n      3.7. Larger Works. You may create a Larger Work by combining Covered Code with other code not governed by the terms of this License and distribute the Larger Work as a single product. In such a case, You must make sure the requirements of this License are fulfilled for the Covered Code.\n\n   4. Inability to Comply Due to Statute or Regulation.\n\n   If it is impossible for You to comply with any of the terms of this License with respect to some or all of the Covered Code due to statute, judicial order, or regulation then You must: (a) comply with the terms of this License to the maximum extent possible; and (b) describe the limitations and the code they affect. Such description must be included in the LEGAL file described in Section 3.4 and must be included with all distributions of the Source Code. Except to the extent prohibited by statute or regulation, such description must be sufficiently detailed for a recipient of ordinary skill to be able to understand it.\n\n   5. Application of this License.\n\n   This License applies to code to which the Initial Developer has attached the notice in Exhibit A and to related Covered Code.\n\n   6. Versions of the License.\n\n      6.1. New Versions\n\n      Netscape Communications Corporation (\"Netscape\") may publish revised and/or new versions of the License from time to time. Each version will be given a distinguishing version number.\n\n      6.2. Effect of New Versions\n\n      Once Covered Code has been published under a particular version of the License, You may always continue to use it under the terms of that version. You may also choose to use such Covered Code under the terms of any subsequent version of the License published by Netscape. No one other than Netscape has the right to modify the terms applicable to Covered Code created under this License.\n\n      6.3. Derivative Works\n\n      If You create or use a modified version of this License (which you may only do in order to apply it to code which is not already Covered Code governed by this License), You must (a) rename Your license so that the phrases \"Mozilla\", \"MOZILLAPL\", \"MOZPL\", \"Netscape\", \"MPL\", \"NPL\" or any confusingly similar phrase do not appear in your license (except to note that your license differs from this License) and (b) otherwise make it clear that Your version of the license contains terms which differ from the Mozilla Public License and Netscape Public License. (Filling in the name of the Initial Developer, Original Code or Contributor in the notice described in Exhibit A shall not of themselves be deemed to be modifications of this License.)\n\n   7. DISCLAIMER OF WARRANTY\n\n   COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN \"AS IS\" BASIS, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER.\n\n   8. Termination\n\n      8.1. This License and the rights granted hereunder will terminate automatically if You fail to comply with terms herein and fail to cure such breach within 30 days of becoming aware of the breach. All sublicenses to the Covered Code which are properly granted shall survive any termination of this License. Provisions which, by their nature, must remain in effect beyond the termination of this License shall survive.\n\n      8.2. If You initiate litigation by asserting a patent infringement claim (excluding declatory judgment actions) against Initial Developer or a Contributor (the Initial Developer or Contributor against whom You file such action is referred to as \"Participant\") alleging that:\n\n         a. such Participant's Contributor Version directly or indirectly infringes any patent, then any and all rights granted by such Participant to You under Sections 2.1 and/or 2.2 of this License shall, upon 60 days notice from Participant terminate prospectively, unless if within 60 days after receipt of notice You either: (i) agree in writing to pay Participant a mutually agreeable reasonable royalty for Your past and future use of Modifications made by such Participant, or (ii) withdraw Your litigation claim with respect to the Contributor Version against such Participant. If within 60 days of notice, a reasonable royalty and payment arrangement are not mutually agreed upon in writing by the parties or the litigation claim is not withdrawn, the rights granted by Participant to You under Sections 2.1 and/or 2.2 automatically terminate at the expiration of the 60 day notice period specified above.\n\n         b. any software, hardware, or device, other than such Participant's Contributor Version, directly or indirectly infringes any patent, then any rights granted to You by such Participant under Sections 2.1(b) and 2.2(b) are revoked effective as of the date You first made, used, sold, distributed, or had made, Modifications made by that Participant.\n\n      8.3. If You assert a patent infringement claim against Participant alleging that such Participant's Contributor Version directly or indirectly infringes any patent where such claim is resolved (such as by license or settlement) prior to the initiation of patent infringement litigation, then the reasonable value of the licenses granted by such Participant under Sections 2.1 or 2.2 shall be taken into account in determining the amount or value of any payment or license.\n\n      8.4. In the event of termination under Sections 8.1 or 8.2 above, all end user license agreements (excluding distributors and resellers) which have been validly granted by You or any distributor hereunder prior to termination shall survive termination.\n\n   9. LIMITATION OF LIABILITY\n\n   UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER TORT (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL YOU, THE INITIAL DEVELOPER, ANY OTHER CONTRIBUTOR, OR ANY DISTRIBUTOR OF COVERED CODE, OR ANY SUPPLIER OF ANY OF SUCH PARTIES, BE LIABLE TO ANY PERSON FOR ANY INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, COMPUTER FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER COMMERCIAL DAMAGES OR LOSSES, EVEN IF SUCH PARTY SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF LIABILITY SHALL NOT APPLY TO LIABILITY FOR DEATH OR PERSONAL INJURY RESULTING FROM SUCH PARTY'S NEGLIGENCE TO THE EXTENT APPLICABLE LAW PROHIBITS SUCH LIMITATION. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OR LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THIS EXCLUSION AND LIMITATION MAY NOT APPLY TO YOU.\n\n   10. U.S. government end users\n\n   The Covered Code is a \"commercial item,\" as that term is defined in 48 C.F.R. 2.101 (Oct. 1995), consisting of \"commercial computer software\" and \"commercial computer software documentation,\" as such terms are used in 48 C.F.R. 12.212 (Sept. 1995). Consistent with 48 C.F.R. 12.212 and 48 C.F.R. 227.7202-1 through 227.7202-4 (June 1995), all U.S. Government End Users acquire Covered Code with only those rights set forth herein.\n\n   11. Miscellaneous\n\n   This License represents the complete agreement concerning subject matter hereof. If any provision of this License is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable. This License shall be governed by California law provisions (except to the extent applicable law, if any, provides otherwise), excluding its conflict-of-law provisions. With respect to disputes in which at least one party is a citizen of, or an entity chartered or registered to do business in the United States of America, any litigation relating to this License shall be subject to the jurisdiction of the Federal Courts of the Northern District of California, with venue lying in Santa Clara County, California, with the losing party responsible for costs, including without limitation, court costs and reasonable attorneys' fees and expenses. The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded. Any law or regulation which provides that the language of a contract shall be construed against the drafter shall not apply to this License.\n\n   12. Responsibility for claims\n\n   As between Initial Developer and the Contributors, each party is responsible for claims and damages arising, directly or indirectly, out of its utilization of rights under this License and You agree to work with Initial Developer and Contributors to distribute such responsibility on an equitable basis. Nothing herein is intended or shall be deemed to constitute any admission of liability.\n\n   13. Multiple-licensed code\n\n   Initial Developer may designate portions of the Covered Code as \"Multiple-Licensed\". \"Multiple-Licensed\" means that the Initial Developer permits you to utilize portions of the Covered Code under Your choice of the MPL or the alternative licenses, if any, specified by the Initial Developer in the file described in Exhibit A. Exhibit A - Mozilla Public License.\n\n\"The contents of this file are subject to the Mozilla Public License Version 1.1 (the \"License\"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.mozilla.org/MPL/\n\nSoftware distributed under the License is distributed on an \"AS IS\" basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the specific language governing rights and limitations under the License.\n\nThe Original Code is ______________________________________.\n\nThe Initial Developer of the Original Code is ________________________.\n\nPortions created by ______________________ are Copyright (C) ______\n\n_______________________. All Rights Reserved.\n\nContributor(s): ______________________________________.\n\nAlternatively, the contents of this file may be used under the terms of the _____ license (the \"[___] License\"), in which case the provisions of [______] License are applicable instead of those above. If you wish to allow use of your version of this file only under the terms of the [____] License and not to allow others to use your version of this file under the MPL, indicate your decision by deleting the provisions above and replace them with the notice and other provisions required by the [___] License. If you do not delete the provisions above, a recipient may use your version of this file under either the MPL or the [___] License.\"\n\nNOTE: The text of this Exhibit A may differ slightly from the text of the notices in the Source Code files of the Original Code. You should use the text of this Exhibit A rather than the text found in the Original Code Source Code for Your Modifications."],"licenseIds":["NPL-1.1"],"keywords":["1 1 amendments","1 amendments the","amendments the netscape","1 1 npl","1 npl consists","npl consists of","the following amendments","following amendments including","amendments including exhibit","including exhibit a","public license files","license files identified","files identified with","identified with exhibit","with exhibit a","license are governed","by the netscape","1 additional terms","the trademarks netscape","trademarks netscape the","lighthouse logo netcenter","logo netcenter gecko","netcenter gecko java","gecko java or","or javascript smart","javascript smart browsing","smart browsing even","browsing even if","or modifications iv","modifications iv inability","without such netscape","license such netscape","license vi litigation","vi litigation notwithstanding","provisions regarding litigation","regarding litigation in","1998 1999 netscape","1999 netscape communications","under the npl","the npl indicate","npl indicate your","either the npl","the license mozilla","version 1 1 amendments","1 1 amendments the","1 amendments the netscape","amendments the netscape public","version 1 1 npl","1 1 npl consists","1 npl consists of","npl consists of the","version 1 1 with","with the following amendments","the following amendments including","following amendments including exhibit","amendments including exhibit a","including exhibit a netscape","netscape public license files","public license files identified","license files identified with","files identified with exhibit","identified with exhibit a","with exhibit a netscape","netscape public license are","public license are governed","license are governed by","governed by the netscape","by the netscape public","version 1 1 additional","1 1 additional terms","1 additional terms applicable","use the trademarks netscape","the trademarks netscape the","trademarks netscape the netscape","netscape lighthouse logo netcenter","lighthouse logo netcenter gecko","logo netcenter gecko java","netcenter gecko java or","gecko java or javascript","java or javascript smart","or javascript smart browsing","javascript smart browsing even","smart browsing even if","browsing even if such","code or modifications iv","or modifications iv inability","modifications iv inability to","therein without such netscape","without such netscape branded","netscape branded code becoming","may license such netscape","license such netscape branded","netscape branded code on","this license vi litigation","license vi litigation notwithstanding","vi litigation notwithstanding the","the provisions regarding litigation","provisions regarding litigation in","regarding litigation in section","license exhibit a netscape","netscape public license the","c 1998 1999 netscape","1998 1999 netscape communications","1999 netscape communications corporation","file under the npl","under the npl indicate","the npl indicate your","npl indicate your decision","under either the npl","either the npl or","npl or the license","or the license mozilla","the license mozilla public","license version 1 1 amendments","version 1 1 amendments the","1 1 amendments the netscape","1 amendments the netscape public","amendments the netscape public license","license version 1 1 npl","version 1 1 npl consists","1 1 npl consists of","1 npl consists of the","npl consists of the mozilla","license version 1 1 with","version 1 1 with the","1 with the following amendments","with the following amendments including","the following amendments including exhibit","following amendments including exhibit a","amendments including exhibit a netscape","including exhibit a netscape public","a netscape public license files","netscape public license files identified","public license files identified with","license files identified with exhibit","files identified with exhibit a","identified with exhibit a netscape","with exhibit a netscape public","a netscape public license are","netscape public license are governed","public license are governed by","license are governed by the","are governed by the netscape","governed by the netscape public","by the netscape public license","license version 1 1 additional","version 1 1 additional terms","1 1 additional terms applicable","1 additional terms applicable to","to use the trademarks netscape","use the trademarks netscape the","the trademarks netscape the netscape","trademarks netscape the netscape n","the netscape lighthouse logo netcenter","netscape lighthouse logo netcenter gecko","lighthouse logo netcenter gecko java","logo netcenter gecko java or","netcenter gecko java or javascript","gecko java or javascript smart","java or javascript smart browsing","or javascript smart browsing even","javascript smart browsing even if","smart browsing even if such","browsing even if such marks","original code or modifications iv","code or modifications iv inability","or modifications iv inability to","modifications iv inability to comply","incorporated therein without such netscape","therein without such netscape branded","without such netscape branded code","such netscape branded code becoming","netscape branded code becoming subject","and may license such netscape","may license such netscape branded","license such netscape branded code","such netscape branded code on","netscape branded code on different","in this license vi litigation","this license vi litigation notwithstanding","license vi litigation notwithstanding the","vi litigation notwithstanding the limitations","above the provisions regarding litigation","the provisions regarding litigation in","provisions regarding litigation in section","regarding litigation in section 11","this license exhibit a netscape","license exhibit a netscape public","a netscape public license the","netscape public license the contents","copyright c 1998 1999 netscape","c 1998 1999 netscape communications","1998 1999 netscape communications corporation","1999 netscape communications corporation all","this file under the npl","file under the npl indicate","under the npl indicate your","the npl indicate your decision","npl indicate your decision by","file under either the npl"]},{"licenseTexts":["Non-Profit Open Software License 3.0\n\nThis Non-Profit Open Software License (\"Non-Profit OSL\") version 3.0 (the \"License\") applies to any original work of authorship (the \"Original Work\") whose owner (the \"Licensor\") has placed the following licensing notice adjacent to the copyright notice for the Original Work:\n\nLicensed under the Non-Profit Open Software License version 3.0\n\n   1) Grant of Copyright License. Licensor grants You a worldwide, royalty-free, non-exclusive, sublicensable license, for the duration of the copyright, to do the following:\n\n      a) to reproduce the Original Work in copies, either alone or as part of a collective work;\n\n      b) to translate, adapt, alter, transform, modify, or arrange the Original Work, thereby creating derivative works (\"Derivative Works\") based upon the Original Work;\n\n      c) to distribute or communicate copies of the Original Work and Derivative Works to the public, with the proviso that copies of Original Work or Derivative Works that You distribute or communicate shall be licensed under this Non-Profit Open Software License or as provided in section 17(d);\n\n      d) to perform the Original Work publicly; and\n\n      e) to display the Original Work publicly.\n\n   2) Grant of Patent License. Licensor grants You a worldwide, royalty-free, non-exclusive, sublicensable license, under patent claims owned or controlled by the Licensor that are embodied in the Original Work as furnished by the Licensor, for the duration of the patents, to make, use, sell, offer for sale, have made, and import the Original Work and Derivative Works.\n\n   3) Grant of Source Code License. The term \"Source Code\" means the preferred form of the Original Work for making modifications to it and all available documentation describing how to modify the Original Work. Licensor agrees to provide a machine-readable copy of the Source Code of the Original Work along with each copy of the Original Work that Licensor distributes. Licensor reserves the right to satisfy this obligation by placing a machine-readable copy of the Source Code in an information repository reasonably calculated to permit inexpensive and convenient access by You for as long as Licensor continues to distribute the Original Work.\n\n   4) Exclusions From License Grant. Neither the names of Licensor, nor the names of any contributors to the Original Work, nor any of their trademarks or service marks, may be used to endorse or promote products derived from this Original Work without express prior permission of the Licensor. Except as expressly stated herein, nothing in this License grants any license to Licensor's trademarks, copyrights, patents, trade secrets or any other intellectual property. No patent license is granted to make, use, sell, offer for sale, have made, or import embodiments of any patent claims other than the licensed claims defined in Section 2. No license is granted to the trademarks of Licensor even if such marks are included in the Original Work. Nothing in this License shall be interpreted to prohibit Licensor from licensing under terms different from this License any Original Work that Licensor otherwise would have a right to license.\n\n   5) External Deployment. The term \"External Deployment\" means the use, distribution, or communication of the Original Work or Derivative Works in any way such that the Original Work or Derivative Works may be used by anyone other than You, whether those works are distributed or communicated to those persons or made available as an application intended for use over a network. As an express condition for the grants of license hereunder, You must treat any External Deployment by You of the Original Work or a Derivative Work as a distribution under section 1(c).\n\n   6) Attribution Rights. You must retain, in the Source Code of any Derivative Works that You create, all copyright, patent, or trademark notices from the Source Code of the Original Work, as well as any notices of licensing and any descriptive text identified therein as an \"Attribution Notice.\" You must cause the Source Code for any Derivative Works that You create to carry a prominent Attribution Notice reasonably calculated to inform recipients that You have modified the Original Work.\n\n   7) Warranty of Provenance and Disclaimer of Warranty. The Original Work is provided under this License on an \"AS IS\" BASIS and WITHOUT WARRANTY, either express or implied, including, without limitation, the warranties of non-infringement, merchantability or fitness for a particular purpose. THE ENTIRE RISK AS TO THE QUALITY OF THE ORIGINAL WORK IS WITH YOU. This DISCLAIMER OF WARRANTY constitutes an essential part of this License. No license to the Original Work is granted by this License except under this disclaimer.\n\n   8) Limitation of Liability. Under no circumstances and under no legal theory, whether in tort (including negligence), contract, or otherwise, shall the Licensor be liable to anyone for any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or the use of the Original Work including, without limitation, damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses. This limitation of liability shall not apply to the extent applicable law prohibits such limitation.\n\n   9) Acceptance and Termination. If, at any time, You expressly assented to this License, that assent indicates your clear and irrevocable acceptance of this License and all of its terms and conditions. If You distribute or communicate copies of the Original Work or a Derivative Work, You must make a reasonable effort under the circumstances to obtain the express assent of recipients to the terms of this License. This License conditions your rights to undertake the activities listed in Section 1, including your right to create Derivative Works based upon the Original Work, and doing so without honoring these terms and conditions is prohibited by copyright law and international treaty. Nothing in this License is intended to affect copyright exceptions and limitations (including \"fair use\" or \"fair dealing\"). This License shall terminate immediately and You may no longer exercise any of the rights granted to You by this License upon your failure to honor the conditions in Section 1(c).\n\n   10) Termination for Patent Action. This License shall terminate automatically and You may no longer exercise any of the rights granted to You by this License as of the date You commence an action, including a cross-claim or counterclaim, against Licensor or any licensee alleging that the Original Work infringes a patent. This termination provision shall not apply for an action alleging patent infringement by combinations of the Original Work with other software or hardware.\n\n   11) Jurisdiction, Venue and Governing Law. Any action or suit relating to this License may be brought only in the courts of a jurisdiction wherein the Licensor resides or in which Licensor conducts its primary business, and under the laws of that jurisdiction excluding its conflict-of-law provisions. The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded. Any use of the Original Work outside the scope of this License or after its termination shall be subject to the requirements and penalties of copyright or patent law in the appropriate jurisdiction. This section shall survive the termination of this License.\n\n   12) Attorneys' Fees. In any action to enforce the terms of this License or seeking damages relating thereto, the prevailing party shall be entitled to recover its costs and expenses, including, without limitation, reasonable attorneys' fees and costs incurred in connection with such action, including any appeal of such action. This section shall survive the termination of this License.\n\n   13) Miscellaneous. If any provision of this License is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable.\n\n   14) Definition of \"You\" in This License. \"You\" throughout this License, whether in upper or lower case, means an individual or a legal entity exercising rights under, and complying with all of the terms of, this License. For legal entities, \"You\" includes any entity that controls, is controlled by, or is under common control with you. For purposes of this definition, \"control\" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.\n\n   15) Right to Use. You may use the Original Work in all ways not otherwise restricted or conditioned by this License or by law, and Licensor promises not to interfere with or be responsible for such uses by You.\n\n   16) Modification of This License. This License is Copyright © 2005 Lawrence Rosen. Permission is granted to copy, distribute, or communicate this License without modification. Nothing in this License permits You to modify this License as applied to the Original Work or to Derivative Works. However, You may modify the text of this License and copy, distribute or communicate your modified version (the \"Modified License\") and apply it to other original works of authorship subject to the following conditions: (i) You may not indicate in any way that your Modified License is the \"Open Software License\" or \"OSL\" and you may not use those names in the name of your Modified License; (ii) You must replace the notice specified in the first paragraph above with the notice \"Licensed under \u003cinsert your license name here\u003e\" or with a notice of your own that is not confusingly similar to the notice in this License; and (iii) You may not claim that your original works are open source software unless your Modified License has been approved by Open Source Initiative (OSI) and You comply with its license review and certification process.\n\n   17) Non-Profit Amendment. The name of this amended version of the Open Software License (\"OSL 3.0\") is \"Non-Profit Open Software License 3.0\". The original OSL 3.0 license has been amended as follows:\n\n      (a) Licensor represents and declares that it is a not-for-profit organization that derives no revenue whatsoever from the distribution of the Original Work or Derivative Works thereof, or from support or services relating thereto.\n\n      (b) The first sentence of Section 7 [\"Warranty of Provenance\"] of OSL 3.0 has been stricken. For Original Works licensed under this Non-Profit OSL 3.0, LICENSOR OFFERS NO WARRANTIES WHATSOEVER.\n\n      (c) In the first sentence of Section 8 [\"Limitation of Liability\"] of this Non-Profit OSL 3.0, the list of damages for which LIABILITY IS LIMITED now includes \"direct\" damages.\n\n      (d) The proviso in Section 1(c) of this License now refers to this \"Non-Profit Open Software License\" rather than the \"Open Software License\". You may distribute or communicate the Original Work or Derivative Works thereof under this Non-Profit OSL 3.0 license only if You make the representation and declaration in paragraph (a) of this Section 17. Otherwise, You shall distribute or communicate the Original Work or Derivative Works thereof only under the OSL 3.0 license and You shall publish clear licensing notices so stating. Also by way of clarification, this License does not authorize You to distribute or communicate works under this Non-Profit OSL 3.0 if You received them under the original OSL 3.0 license.\n\n      (e) Original Works licensed under this license shall reference \"Non-Profit OSL 3.0\" in licensing notices to distinguish them from works licensed under the original OSL 3.0 license."],"licenseIds":["NPOSL-3.0"],"keywords":["0 this non","software license non","license non profit","profit osl version","osl version 3","the non profit","or as provided","in section 17","section 17 d","17 d d","d d to","warranty the original","certification process 17","process 17 non","17 non profit","non profit amendment","profit amendment the","amendment the name","of this amended","this amended version","amended version of","license osl 3","3 0 is","0 is non","is non profit","0 the original","0 license has","has been amended","been amended as","amended as follows","follows a licensor","a licensor represents","represents and declares","and declares that","declares that it","is a not","for profit organization","profit organization that","organization that derives","that derives no","derives no revenue","no revenue whatsoever","revenue whatsoever from","works thereof or","thereof or from","or from support","from support or","support or services","or services relating","services relating thereto","relating thereto b","thereto b the","b the first","section 7 warranty","of provenance of","provenance of osl","of osl 3","3 0 has","has been stricken","been stricken for","stricken for original","for original works","3 0 licensor","0 licensor offers","licensor offers no","offers no warranties","warranties whatsoever c","whatsoever c in","c in the","section 8 limitation","liability of this","of this non","0 the list","list of damages","of damages for","damages for which","for which liability","which liability is","is limited now","limited now includes","now includes direct","includes direct damages","direct damages d","damages d the","d the proviso","1 c of","c of this","this license now","license now refers","now refers to","to this non","software license rather","than the open","software license you","works thereof under","thereof under this","0 license only","make the representation","the representation and","representation and declaration","and declaration in","declaration in paragraph","paragraph a of","this section 17","section 17 otherwise","17 otherwise you","otherwise you shall","you shall distribute","shall distribute or","works thereof only","thereof only under","under the osl","the osl 3","0 license and","you shall publish","shall publish clear","publish clear licensing","clear licensing notices","licensing notices so","notices so stating","so stating also","stating also by","also by way","way of clarification","of clarification this","clarification this license","not authorize you","authorize you to","or communicate works","communicate works under","3 0 if","you received them","received them under","0 license e","e original works","license shall reference","shall reference non","reference non profit","3 0 in","0 in licensing","in licensing notices","licensing notices to","notices to distinguish","to distinguish them","distinguish them from","them from works","from works licensed","license 3 0 this","3 0 this non","0 this non profit","open software license non","software license non profit","license non profit osl","non profit osl version","profit osl version 3","osl version 3 0","version 3 0 the","3 0 the license","0 the license applies","under the non profit","the non profit open","software license or as","license or as provided","or as provided in","provided in section 17","in section 17 d","section 17 d d","17 d d to","d d to perform","of warranty the original","warranty the original work","anyone for any direct","and certification process 17","certification process 17 non","process 17 non profit","17 non profit amendment","non profit amendment the","profit amendment the name","amendment the name of","name of this amended","of this amended version","this amended version of","amended version of the","of the open software","software license osl 3","license osl 3 0","osl 3 0 is","3 0 is non","0 is non profit","is non profit open","license 3 0 the","3 0 the original","0 the original osl","3 0 license has","0 license has been","license has been amended","has been amended as","been amended as follows","amended as follows a","as follows a licensor"]},{"licenseTexts":["NRL License COPYRIGHT NOTICE\n\nAll of the documentation and software included in this software distribution from the US Naval Research Laboratory (NRL) are copyrighted by their respective developers.\n\nPortions of the software are derived from the Net/2 and 4.4-Lite Berkeley Software Distributions (BSD) of the University of California at Berkeley and those portions are copyright by The Regents of the University of California. All Rights Reserved. The UC Berkeley Copyright and License agreement is binding on those portions of the software. In all cases, the NRL developers have retained the original UC Berkeley copyright and license notices in the respective files in accordance with the UC Berkeley copyrights and license.\n\nPortions of this software and documentation were developed at NRL by various people. Those developers have each copyrighted the portions that they developed at NRL and have assigned All Rights for those portions to NRL. Outside the USA, NRL has copyright on some of the software developed at NRL. The affected files all contain specific copyright notices and those notices must be retained in any derived work. NRL LICENSE\n\nNRL grants permission for redistribution and use in source and binary forms, with or without modification, of the software and documentation created at NRL provided that the following conditions are met:\n\n   1. All terms of the UC Berkeley copyright and license must be followed.\n\n   2. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n   3. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   4. All advertising materials mentioning features or use of this software must display the following acknowledgements:\n\n      \n\n      This product includes software developed by the University of California, Berkeley and its contributors.\n\n      \n\n      This product includes software developed at the Information Technology Division, US Naval Research Laboratory.\n\n   5. Neither the name of the NRL nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.\n\nTHE SOFTWARE PROVIDED BY NRL IS PROVIDED BY NRL AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NRL OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\nThe views and conclusions contained in the software and documentation are those of the authors and should not be interpreted as representing official policies, either expressed or implied, of the US Naval Research Laboratory (NRL)."],"licenseIds":["NRL"],"keywords":["nrl license copyright","license copyright notice","copyright notice all","notice all of","and software included","software included in","this software distribution","software distribution from","distribution from the","from the us","laboratory nrl are","nrl are copyrighted","by their respective","their respective developers","respective developers portions","developers portions of","software are derived","are derived from","from the net","the net 2","net 2 and","and 4 4","4 4 lite","4 lite berkeley","lite berkeley software","berkeley software distributions","software distributions bsd","distributions bsd of","bsd of the","of california at","california at berkeley","at berkeley and","berkeley and those","and those portions","those portions are","portions are copyright","are copyright by","reserved the uc","and license agreement","agreement is binding","is binding on","binding on those","on those portions","software in all","all cases the","cases the nrl","the nrl developers","nrl developers have","developers have retained","have retained the","retained the original","the original uc","original uc berkeley","in the respective","the respective files","respective files in","files in accordance","with the uc","uc berkeley copyrights","berkeley copyrights and","copyrights and license","and license portions","and documentation were","documentation were developed","were developed at","at nrl by","nrl by various","by various people","various people those","people those developers","those developers have","developers have each","have each copyrighted","each copyrighted the","copyrighted the portions","the portions that","portions that they","that they developed","they developed at","at nrl and","nrl and have","and have assigned","have assigned all","assigned all rights","all rights for","rights for those","those portions to","portions to nrl","to nrl outside","nrl outside the","outside the usa","the usa nrl","usa nrl has","nrl has copyright","has copyright on","copyright on some","on some of","at nrl the","nrl the affected","the affected files","affected files all","files all contain","all contain specific","contain specific copyright","specific copyright notices","notices and those","and those notices","those notices must","in any derived","derived work nrl","work nrl license","nrl license nrl","license nrl grants","nrl grants permission","grants permission for","permission for redistribution","for redistribution and","and documentation created","documentation created at","created at nrl","at nrl provided","nrl provided that","1 all terms","of the uc","and license must","must be followed","be followed 2","followed 2 redistributions","following disclaimer 3","disclaimer 3 redistributions","distribution 4 all","the following acknowledgements","following acknowledgements this","acknowledgements this product","its contributors this","contributors this product","at the information","the information technology","information technology division","technology division us","division us naval","research laboratory 5","laboratory 5 neither","of the nrl","the nrl nor","nrl nor the","by nrl is","nrl is provided","by nrl and","nrl and contributors","event shall nrl","shall nrl or","nrl or contributors","nrl license copyright notice","license copyright notice all","copyright notice all of","notice all of the","all of the documentation","documentation and software included","and software included in","software included in this","included in this software","in this software distribution","this software distribution from","software distribution from the","distribution from the us","from the us naval","research laboratory nrl are","laboratory nrl are copyrighted","nrl are copyrighted by","are copyrighted by their","copyrighted by their respective","by their respective developers","their respective developers portions","respective developers portions of","developers portions of the","of the software are","the software are derived","software are derived from","are derived from the","derived from the net","from the net 2","the net 2 and","net 2 and 4","2 and 4 4","and 4 4 lite","4 4 lite berkeley","4 lite berkeley software","lite berkeley software distributions","berkeley software distributions bsd","software distributions bsd of","distributions bsd of the","bsd of the university","university of california at","of california at berkeley","california at berkeley and","at berkeley and those","berkeley and those portions","and those portions are","those portions are copyright"]},{"licenseTexts":["NTP No Attribution (NTP-0) Copyright (4-digit-year) by (CopyrightHoldersName)\n\nPermission to use, copy, modify, and distribute this software and its documentation for any purpose is hereby granted, provided that the namesof (TrademarkedName) not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission. (TrademarkedName) makesno representations about the suitability of this software for any purpose. It is provided \"as is\" without express or implied warranty."],"licenseIds":["NTP-0"],"keywords":["ntp no attribution","no attribution ntp","attribution ntp 0","ntp 0 copyright","0 copyright 4","copyright 4 digit","digit year by","year by copyrightholdersname","by copyrightholdersname permission","copyrightholdersname permission to","that the namesof","the namesof trademarkedname","namesof trademarkedname not","permission trademarkedname makesno","trademarkedname makesno representations","makesno representations about","ntp no attribution ntp","no attribution ntp 0","attribution ntp 0 copyright","ntp 0 copyright 4","0 copyright 4 digit","copyright 4 digit year","4 digit year by","digit year by copyrightholdersname","year by copyrightholdersname permission","by copyrightholdersname permission to","copyrightholdersname permission to use","provided that the namesof","that the namesof trademarkedname","the namesof trademarkedname not","namesof trademarkedname not be","prior permission trademarkedname makesno","permission trademarkedname makesno representations","trademarkedname makesno representations about","makesno representations about the","ntp no attribution ntp 0","no attribution ntp 0 copyright","attribution ntp 0 copyright 4","ntp 0 copyright 4 digit","0 copyright 4 digit year","copyright 4 digit year by","4 digit year by copyrightholdersname","digit year by copyrightholdersname permission","year by copyrightholdersname permission to","by copyrightholdersname permission to use","copyrightholdersname permission to use copy","purpose is hereby granted provided","granted provided that the namesof","provided that the namesof trademarkedname","that the namesof trademarkedname not","the namesof trademarkedname not be","namesof trademarkedname not be used","written prior permission trademarkedname makesno","prior permission trademarkedname makesno representations","permission trademarkedname makesno representations about","trademarkedname makesno representations about the","makesno representations about the suitability"]},{"licenseTexts":["NTP License (NTP) Copyright (c) (CopyrightHoldersName) (From 4-digit-year)-(To 4-digit-year)\n\nPermission to use, copy, modify, and distribute this software and its documentation for any purpose with or without fee is hereby granted, provided that the above copyright notice appears in all copies and that both the copyright notice and this permission notice appear in supporting documentation, and that the name (TrademarkedName) not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission. (TrademarkedName) makes no representations about the suitability this software for any purpose. It is provided \"as is\" without express or implied warranty."],"licenseIds":["NTP"],"keywords":["ntp license ntp","license ntp copyright","ntp copyright c","copyright c copyrightholdersname","c copyrightholdersname from","copyrightholdersname from 4","from 4 digit","digit year to","year to 4","to 4 digit","digit year permission","year permission to","the name trademarkedname","name trademarkedname not","permission trademarkedname makes","trademarkedname makes no","the suitability this","suitability this software","ntp license ntp copyright","license ntp copyright c","ntp copyright c copyrightholdersname","copyright c copyrightholdersname from","c copyrightholdersname from 4","copyrightholdersname from 4 digit","from 4 digit year","4 digit year to","digit year to 4","year to 4 digit","to 4 digit year","4 digit year permission","digit year permission to","year permission to use","that the name trademarkedname","the name trademarkedname not","name trademarkedname not be","prior permission trademarkedname makes","permission trademarkedname makes no","trademarkedname makes no representations","about the suitability this","the suitability this software","suitability this software for","ntp license ntp copyright c","license ntp copyright c copyrightholdersname","ntp copyright c copyrightholdersname from","copyright c copyrightholdersname from 4","c copyrightholdersname from 4 digit","copyrightholdersname from 4 digit year","from 4 digit year to","4 digit year to 4","digit year to 4 digit","year to 4 digit year","to 4 digit year permission","4 digit year permission to","digit year permission to use","year permission to use copy","and that the name trademarkedname","that the name trademarkedname not","the name trademarkedname not be","name trademarkedname not be used","written prior permission trademarkedname makes","prior permission trademarkedname makes no","permission trademarkedname makes no representations","trademarkedname makes no representations about","representations about the suitability this","about the suitability this software","the suitability this software for","suitability this software for any"]},{"licenseTexts":["NAUMEN Public License This software is Copyright (c) NAUMEN (tm) and Contributors. All rights reserved.\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   1. Redistributions in source code must retain the above copyright notice, this list of conditions, and the following disclaimer.\n\n   2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions, and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   3. The name NAUMEN (tm) must not be used to endorse or promote products derived from this software without prior written permission from NAUMEN.\n\n   4. The right to distribute this software or to use it for any purpose does not give you the right to use Servicemarks (sm) or Trademarks (tm) of NAUMEN.\n\n   5. If any files originating from NAUMEN or Contributors are modified, you must cause the modified files to carry prominent notices stating that you changed the files and the date of any change.\n\nDisclaimer:\n\nTHIS SOFTWARE IS PROVIDED BY NAUMEN \"AS IS\" AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL NAUMEN OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\nThis software consists of contributions made by NAUMEN and Contributors. Specific attributions are listed in the accompanying credits file."],"licenseIds":["Naumen"],"keywords":["naumen public license","copyright c naumen","c naumen tm","naumen tm and","the name naumen","name naumen tm","naumen tm must","permission from naumen","from naumen 4","naumen 4 the","tm of naumen","of naumen 5","naumen 5 if","any files originating","originating from naumen","from naumen or","naumen or contributors","or contributors are","contributors are modified","provided by naumen","by naumen as","naumen as is","event shall naumen","shall naumen or","naumen or its","made by naumen","by naumen and","naumen and contributors","and contributors specific","contributors specific attributions","naumen public license this","public license this software","is copyright c naumen","copyright c naumen tm","c naumen tm and","naumen tm and contributors","3 the name naumen","the name naumen tm","name naumen tm must","naumen tm must not","written permission from naumen","permission from naumen 4","from naumen 4 the","naumen 4 the right","trademarks tm of naumen","tm of naumen 5","of naumen 5 if","naumen 5 if any","if any files originating","any files originating from","files originating from naumen","originating from naumen or","from naumen or contributors","naumen or contributors are","or contributors are modified","contributors are modified you","is provided by naumen","provided by naumen as","by naumen as is","naumen as is and","no event shall naumen","event shall naumen or","shall naumen or its","naumen or its contributors","contributions made by naumen","made by naumen and","by naumen and contributors","naumen and contributors specific","and contributors specific attributions","contributors specific attributions are","naumen public license this software","public license this software is","license this software is copyright","software is copyright c naumen","is copyright c naumen tm","copyright c naumen tm and","c naumen tm and contributors","naumen tm and contributors all","contributors all rights reserved redistribution","distribution 3 the name naumen","3 the name naumen tm","the name naumen tm must","name naumen tm must not","naumen tm must not be","prior written permission from naumen","written permission from naumen 4","permission from naumen 4 the","from naumen 4 the right","naumen 4 the right to","or trademarks tm of naumen","trademarks tm of naumen 5","tm of naumen 5 if","of naumen 5 if any","naumen 5 if any files","5 if any files originating","if any files originating from","any files originating from naumen","files originating from naumen or","originating from naumen or contributors","from naumen or contributors are","naumen or contributors are modified","or contributors are modified you","contributors are modified you must","software is provided by naumen","is provided by naumen as","provided by naumen as is","by naumen as is and","naumen as is and any","in no event shall naumen","no event shall naumen or","event shall naumen or its","shall naumen or its contributors","naumen or its contributors be","of contributions made by naumen","contributions made by naumen and","made by naumen and contributors","by naumen and contributors specific","naumen and contributors specific attributions","and contributors specific attributions are","contributors specific attributions are listed"]},{"licenseTexts":["---- Part 1: CMU/UCD copyright notice: (BSD like) ----- Copyright 1989, 1991, 1992 by Carnegie Mellon University\n\nDerivative Work - 1996, 1998-2000 Copyright 1996, 1998-2000 The Regents of the University of California\n\nAll Rights Reserved\n\nPermission to use, copy, modify and distribute this software and its documentation for any purpose and without fee is hereby granted, provided that the above copyright notice appears in all copies and that both that copyright notice and this permission notice appear in supporting documentation, and that the name of CMU and The Regents of the University of California not be used in advertising or publicity pertaining to distribution of the software without specific written permission.\n\nCMU AND THE REGENTS OF THE UNIVERSITY OF CALIFORNIA DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL CMU OR THE REGENTS OF THE UNIVERSITY OF CALIFORNIA BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM THE LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.\n\n---- Part 2: Networks Associates Technology, Inc copyright notice (BSD) -----\n\nCopyright (c) 2001-2003, Networks Associates Technology, Inc All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n   * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   * Neither the name of the Networks Associates Technology, Inc nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.\n\n   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n   ---- Part 3: Cambridge Broadband Ltd. copyright notice (BSD) -----\n\n   Portions of this code are copyright (c) 2001-2003, Cambridge Broadband Ltd. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n   * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   * The name of Cambridge Broadband Ltd. may not be used to endorse or promote products derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n---- Part 4: Sun Microsystems, Inc. copyright notice (BSD) ----- Copyright © 2003 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, California 95054, U.S.A. All rights reserved.\n\nUse is subject to license terms below.\n\nThis distribution may include materials developed by third parties.\n\nSun, Sun Microsystems, the Sun logo and Solaris are trademarks or registered trademarks of Sun Microsystems, Inc. in the U.S. and other countries.\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n   * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   * Neither the name of the Sun Microsystems, Inc. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.\n\n   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n   ---- Part 5: Sparta, Inc copyright notice (BSD) -----\n\n   Copyright (c) 2003-2009, Sparta, Inc All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n   * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   * Neither the name of Sparta, Inc nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.\n\n   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n   ---- Part 6: Cisco/BUPTNIC copyright notice (BSD) -----\n\n   Copyright (c) 2004, Cisco, Inc and Information Network Center of Beijing University of Posts and Telecommunications. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n   * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   * Neither the name of Cisco, Inc, Beijing University of Posts and Telecommunications, nor the names of their contributors may be used to endorse or promote products derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n---- Part 7: Fabasoft R\u0026D Software GmbH \u0026 Co KG copyright notice (BSD) ----- Copyright (c) Fabasoft R\u0026D Software GmbH \u0026 Co KG, 2003 oss@fabasoft.com Author: Bernhard Penz\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n   * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   * The name of Fabasoft R\u0026D Software GmbH \u0026 Co KG or any of its subsidiaries, brand or product names may not be used to endorse or promote products derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n---- Part 8: Apple Inc. copyright notice (BSD) ----- Copyright (c) 2007 Apple Inc. All rights reserved.\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n   2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   3. Neither the name of Apple Inc. (\"Apple\") nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.\n\n   THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n   ---- Part 9: ScienceLogic, LLC copyright notice (BSD) -----\n\n   Copyright (c) 2009, ScienceLogic, LLC All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n   * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   * Neither the name of ScienceLogic, LLC nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."],"licenseIds":["Net-SNMP"],"keywords":["part 1 cmu","1 cmu ucd","cmu ucd copyright","ucd copyright notice","notice bsd like","bsd like copyright","like copyright 1989","copyright 1989 1991","1989 1991 1992","1991 1992 by","1992 by carnegie","by carnegie mellon","carnegie mellon university","mellon university derivative","university derivative work","derivative work 1996","work 1996 1998","1998 2000 copyright","2000 copyright 1996","copyright 1996 1998","1998 2000 the","2000 the regents","name of cmu","of cmu and","of california not","california not be","written permission cmu","permission cmu and","of california disclaim","california disclaim all","event shall cmu","shall cmu or","cmu or the","or the regents","this software part","software part 2","part 2 networks","2 networks associates","technology inc copyright","2001 2003 networks","2003 networks associates","technology inc all","of the networks","the networks associates","technology inc nor","damage part 3","part 3 cambridge","3 cambridge broadband","broadband ltd copyright","ltd copyright notice","notice bsd portions","bsd portions of","this code are","code are copyright","2001 2003 cambridge","2003 cambridge broadband","broadband ltd all","name of cambridge","of cambridge broadband","broadband ltd may","ltd may not","damage part 4","part 4 sun","4 sun microsystems","microsystems inc copyright","bsd copyright 2003","copyright 2003 sun","2003 sun microsystems","microsystems inc 4150","inc 4150 network","4150 network circle","network circle santa","circle santa clara","clara california 95054","california 95054 u","95054 u s","license terms below","terms below this","below this distribution","distribution may include","may include materials","include materials developed","materials developed by","developed by third","third parties sun","parties sun sun","sun sun microsystems","sun microsystems the","microsystems the sun","the sun logo","sun logo and","logo and solaris","and solaris are","solaris are trademarks","are trademarks or","trademarks or registered","or registered trademarks","trademarks of sun","microsystems inc in","inc in the","s and other","other countries redistribution","countries redistribution and","of the sun","the sun microsystems","microsystems inc nor","damage part 5","part 5 sparta","5 sparta inc","sparta inc copyright","c 2003 2009","2003 2009 sparta","2009 sparta inc","sparta inc all","name of sparta","of sparta inc","sparta inc nor","damage part 6","part 6 cisco","6 cisco buptnic","cisco buptnic copyright","buptnic copyright notice","c 2004 cisco","2004 cisco inc","cisco inc and","inc and information","and information network","information network center","network center of","center of beijing","of beijing university","and telecommunications all","telecommunications all rights","name of cisco","of cisco inc","cisco inc beijing","inc beijing university","and telecommunications nor","telecommunications nor the","damage part 7","part 7 fabasoft","7 fabasoft r","co kg copyright","kg copyright notice","copyright c fabasoft","c fabasoft r","co kg 2003","kg 2003 oss","2003 oss fabasoft","oss fabasoft com","fabasoft com author","com author bernhard","author bernhard penz","bernhard penz redistribution","penz redistribution and","name of fabasoft","of fabasoft r","co kg or","kg or any","its subsidiaries brand","subsidiaries brand or","brand or product","product names may","names may not","damage part 8","part 8 apple","8 apple inc","apple inc copyright","c 2007 apple","name of apple","of apple inc","inc apple nor","apple nor the","by apple and","apple or its","damage part 9","part 9 sciencelogic","9 sciencelogic llc","sciencelogic llc copyright","llc copyright notice","c 2009 sciencelogic","2009 sciencelogic llc","sciencelogic llc all","name of sciencelogic","of sciencelogic llc","sciencelogic llc nor","llc nor the","part 1 cmu ucd","1 cmu ucd copyright","cmu ucd copyright notice","ucd copyright notice bsd","copyright notice bsd like","notice bsd like copyright","bsd like copyright 1989","like copyright 1989 1991","copyright 1989 1991 1992","1989 1991 1992 by","1991 1992 by carnegie","1992 by carnegie mellon","by carnegie mellon university"]},{"licenseTexts":["Copyright 1993-2014 University Corporation for Atmospheric Research/Unidata\n\nPortions of this software were developed by the Unidata Program at the University Corporation for Atmospheric Research.\n\nAccess and use of this software shall impose the following obligations and understandings on the user. The user is granted the right, without any fee or cost, to use, copy, modify, alter, enhance and distribute this software, and any derivative works thereof, and its supporting documentation for any purpose whatsoever, provided that this entire notice appears in all copies of the software, derivative works and supporting documentation. Further, UCAR requests that the user credit UCAR/Unidata in any publications that result from the use of this software or in any product that includes this software, although this is not an obligation. The names UCAR and/or Unidata, however, may not be used in any advertising or publicity to endorse or promote any products or commercial entity unless specific written permission is obtained from UCAR/Unidata. The user also understands that UCAR/Unidata is not obligated to provide the user with any support, consulting, training or assistance of any kind with regard to the use, operation and performance of this software nor to provide the user with any updates, revisions, new versions or \"bug fixes.\"\n\nTHIS SOFTWARE IS PROVIDED BY UCAR/UNIDATA \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL UCAR/UNIDATA BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE ACCESS, USE OR PERFORMANCE OF THIS SOFTWARE."],"licenseIds":["NetCDF"],"keywords":["copyright 1993 2014","1993 2014 university","2014 university corporation","atmospheric research unidata","research unidata portions","unidata portions of","this software were","software were developed","were developed by","by the unidata","the unidata program","unidata program at","program at the","the university corporation","atmospheric research access","research access and","access and use","software shall impose","shall impose the","impose the following","the following obligations","following obligations and","obligations and understandings","and understandings on","understandings on the","the user the","user the user","the user is","user is granted","is granted the","granted the right","the right without","right without any","without any fee","any fee or","fee or cost","or cost to","cost to use","copy modify alter","modify alter enhance","alter enhance and","enhance and distribute","thereof and its","and its supporting","its supporting documentation","supporting documentation for","purpose whatsoever provided","whatsoever provided that","entire notice appears","software derivative works","works and supporting","and supporting documentation","supporting documentation further","documentation further ucar","further ucar requests","ucar requests that","requests that the","the user credit","user credit ucar","credit ucar unidata","ucar unidata in","unidata in any","in any publications","any publications that","publications that result","in any product","any product that","product that includes","that includes this","includes this software","this software although","software although this","although this is","not an obligation","an obligation the","obligation the names","the names ucar","names ucar and","ucar and or","and or unidata","or unidata however","unidata however may","however may not","or publicity to","publicity to endorse","or promote any","promote any products","products or commercial","or commercial entity","commercial entity unless","entity unless specific","unless specific written","permission is obtained","obtained from ucar","from ucar unidata","ucar unidata the","unidata the user","the user also","user also understands","also understands that","understands that ucar","that ucar unidata","ucar unidata is","unidata is not","is not obligated","obligated to provide","with any support","any support consulting","support consulting training","consulting training or","training or assistance","or assistance of","assistance of any","any kind with","kind with regard","the use operation","use operation and","operation and performance","software nor to","nor to provide","with any updates","any updates revisions","updates revisions new","revisions new versions","new versions or","versions or bug","or bug fixes","bug fixes this","fixes this software","provided by ucar","by ucar unidata","ucar unidata as","unidata as is","event shall ucar","shall ucar unidata","ucar unidata be","unidata be liable","with the access","the access use","access use or","copyright 1993 2014 university","1993 2014 university corporation","2014 university corporation for","for atmospheric research unidata","atmospheric research unidata portions","research unidata portions of","unidata portions of this","of this software were","this software were developed","software were developed by","were developed by the","developed by the unidata","by the unidata program","the unidata program at","unidata program at the","program at the university","at the university corporation","the university corporation for","for atmospheric research access","atmospheric research access and","research access and use","access and use of","of this software shall","this software shall impose","software shall impose the","shall impose the following","impose the following obligations","the following obligations and","following obligations and understandings","obligations and understandings on","and understandings on the","understandings on the user","on the user the","the user the user","user the user is","the user is granted","user is granted the","is granted the right","granted the right without","the right without any","right without any fee","without any fee or","any fee or cost","fee or cost to","or cost to use","cost to use copy","use copy modify alter","copy modify alter enhance","modify alter enhance and","alter enhance and distribute","enhance and distribute this","software and any derivative","any derivative works thereof","works thereof and its","thereof and its supporting","and its supporting documentation","its supporting documentation for","supporting documentation for any","any purpose whatsoever provided","purpose whatsoever provided that"]},{"licenseTexts":["Copyright 1989--2004 by Hunter Goatley.\n\nPermission is granted to anyone to use this software for any purpose on any computer system, and to redistribute it freely, subject to the following restrictions:\n\n   1. This software is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n   2. Altered versions must be plainly marked as such, and must not be misrepresented as being the original software."],"licenseIds":["Newsletr"],"keywords":["copyright 1989 2004","1989 2004 by","2004 by hunter","by hunter goatley","hunter goatley permission","goatley permission is","restrictions 1 this","1 this software","particular purpose 2","purpose 2 altered","copyright 1989 2004 by","1989 2004 by hunter","2004 by hunter goatley","by hunter goatley permission","hunter goatley permission is","goatley permission is granted","following restrictions 1 this","restrictions 1 this software","1 this software is","a particular purpose 2","particular purpose 2 altered","purpose 2 altered versions","copyright 1989 2004 by hunter","1989 2004 by hunter goatley","2004 by hunter goatley permission","by hunter goatley permission is","hunter goatley permission is granted","goatley permission is granted to","the following restrictions 1 this","following restrictions 1 this software","restrictions 1 this software is","1 this software is distributed","for a particular purpose 2","a particular purpose 2 altered","particular purpose 2 altered versions","purpose 2 altered versions must"]},{"licenseTexts":["Nokia Open Source License (NOKOS License)\n\nVersion 1.0a 1. DEFINITIONS.\n\n\"Affiliates\" of a party shall mean an entity\n\n   a) which is directly or indirectly controlling such party;\n\n   b) which is under the same direct or indirect ownership or control as such party; or\n\n   c) which is directly or indirectly owned or controlled by such party.\n\nFor these purposes, an entity shall be treated as being controlled by another if that other entity has fifty percent (50%) or more of the votes in such entity, is able to direct its affairs and/or to control the composition of its board of directors or equivalent body.\n\n\"Commercial Use\" shall mean distribution or otherwise making the Covered Software available to a third party.\n\n\"Contributor\" shall mean each entity that creates or contributes to the creation of Modifications.\n\n\"Contributor Version\" shall mean in case of any Contributor the combination of the Original Software, prior Modifications used by a Contributor, and the Modifications made by that particular Contributor and in case of Nokia in addition the Original Software in any form, including the form as Exceutable.\n\n\"Covered Software\" shall mean the Original Software or Modifications or the combination of the Original Software and Modifications, in each case including portions thereof.\n\n\"Electronic Distribution Mechanism\" shall mean a mechanism generally accepted in the software development community for the electronic transfer of data.\n\n\"Executable\" shall mean Covered Software in any form other than Source Code.\n\n\"Nokia\" shall mean Nokia Corporation and its Affiliates.\n\n\"Larger Work\" shall mean a work, which combines Covered Software or portions thereof with code not governed by the terms of this License.\n\n\"License\" shall mean this document.\n\n\"Licensable\" shall mean having the right to grant, to the maximum extent possible, whether at the time of the initial grant or subsequently acquired, any and all of the rights conveyed herein.\n\n\"Modifications\" shall mean any addition to or deletion from the substance or structure of either the Original Software or any previous Modifications. When Covered Software is released as a series of files, a Modification is:\n\n   a) Any addition to or deletion from the contents of a file containing Original Software or previous Modifications.\n\n   b) Any new file that contains any part of the Original Software or previous Modifications.\n\n\"Original Software\" shall mean the Source Code of computer software code which is described in the Source Code notice required by Exhibit A as Original Software, and which, at the time of its release under this License is not already Covered Software governed by this License.\n\n\"Patent Claims\" shall mean any patent claim(s), now owned or hereafter acquired, including without limitation, method, process, and apparatus claims, in any patent Licensable by grantor.\n\n\"Source Code\" shall mean the preferred form of the Covered Software for making modifications to it, including all modules it contains, plus any associated interface definition files, scripts used to control compilation and installation of an Executable, or source code differential comparisons against either the Original Software or another well known, available Covered Software of the Contributor's choice. The Source Code can be in a compressed or archival form, provided the appropriate decompression or de-archiving software is widely available for no charge.\n\n\"You\" (or \"Your\") shall mean an individual or a legal entity exercising rights under, and complying with all of the terms of, this License or a future version of this License issued under Section 6.1. For legal entities, \"You\" includes Affiliates of such entity. 2. SOURCE CODE LICENSE.\n\n   2.1 Nokia Grant.\n\n   Subject to the terms of this License, Nokia hereby grants You a world-wide, royalty-free, non-exclusive license, subject to third party intellectual property claims:\n\n      a) under copyrights Licensable by Nokia to use, reproduce, modify, display, perform, sublicense and distribute the Original Software (or portions thereof) with or without Modifications, and/or as part of a Larger Work;\n\n      b) and under Patents Claims necessarily infringed by the making, using or selling of Original Software, to make, have made, use, practice, sell, and offer for sale, and/or otherwise dispose of the Original Software (or portions thereof).\n\n      c) The licenses granted in this Section 2.1(a) and (b) are effective on the date Nokia first distributes Original Software under the terms of this License.\n\n      d) Notwithstanding Section 2.1(b) above, no patent license is granted: 1) for code that You delete from the Original Software; 2) separate from the Original Software; or 3) for infringements caused by: i) the modification of the Original Software or ii) the combination of the Original Software with other software or devices.\n\n   2.2 Contributor Grant.\n\n   Subject to the terms of this License and subject to third party intellectual property claims, each Contributor hereby grants You a world-wide, royalty-free, non-exclusive license\n\n      a) under copyrights Licensable by Contributor, to use, reproduce, modify, display, perform, sublicense and distribute the Modifications created by such Contributor (or portions thereof) either on an unmodified basis, with other Modifications, as Covered Software and/or as part of a Larger Work; and\n\n      b) under Patent Claims necessarily infringed by the making, using, or selling of Modifications made by that Contributor either alone and/or in combination with its Contributor Version (or portions of such combination), to make, use, sell, offer for sale, have made, and/or otherwise dispose of: 1) Modifications made by that Contributor (or portions thereof); and 2) the combination of Modifications made by that Contributor with its Contributor Version (or portions of such combination).\n\n      c) The licenses granted in Sections 2.2(a) and 2.2(b) are effective on the date Contributor first makes Commercial Use of the Covered Software.\n\n      d) Notwithstanding Section 2.2(b) above, no patent license is granted: 1) for any code that Contributor has deleted from the Contributor Version; 2) separate from the Contributor Version; 3) for infringements caused by: i) third party modifications of Contributor Version or ii) the combination of Modifications made by that Contributor with other software (except as part of the Contributor Version) or other devices; or 4) under Patent Claims infringed by Covered Software in the absence of Modifications made by that Contributor. 3. DISTRIBUTION OBLIGATIONS.\n\n   3.1 Application of License.\n\n   The Modifications which You create or to which You contribute are governed by the terms of this License, including without limitation Section 2.2. The Source Code version of Covered Software may be distributed only under the terms of this License or a future version of this License released under Section 6.1, and You must include a copy of this License with every copy of the Source Code You distribute. You may not offer or impose any terms on any Source Code version that alters or restricts the applicable version of this License or the recipients' rights hereunder. However, You may include an additional document offering the additional rights described in Section 3.5.\n\n   3.2 Availability of Source Code.\n\n   Any Modification which You create or to which You contribute must be made available in Source Code form under the terms of this License either on the same media as an Executable version or via an accepted Electronic Distribution Mechanism to anyone to whom you made an Executable version available; and if made available via Electronic Distribution Mechanism, must remain available for at least twelve (12) months after the date it initially became available, or at least six (6) months after a subsequent version of that particular Modification has been made available to such recipients. You are responsible for ensuring that the Source Code version remains available even if the Electronic Distribution Mechanism is maintained by a third party.\n\n   3.3 Description of Modifications.\n\n   You must cause all Covered Software to which You contribute to contain a file documenting the changes You made to create that Covered Software and the date of any change. You must include a prominent statement that the Modification is derived, directly or indirectly, from Original Software provided by Nokia and including the name of Nokia in (a) the Source Code, and (b) in any notice in an Executable version or related documentation in which You describe the origin or ownership of the Covered Software.\n\n   3.4 Intellectual Property Matters\n\n      (a) Third Party Claims. If Contributor has knowledge that a license under a third party's intellectual property rights is required to exercise the rights granted by such Contributor under Sections 2.1 or 2.2, Contributor must include a text file with the Source Code distribution titled \"LEGAL\" which describes the claim and the party making the claim in sufficient detail that a recipient will know whom to contact. If Contributor obtains such knowledge after the Modification is made available as described in Section 3.2, Contributor shall promptly modify the LEGAL file in all copies Contributor makes available thereafter and shall take other steps (such as notifying appropriate mailing lists or newsgroups) reasonably calculated to inform those who received the Covered Software that new knowledge has been obtained.\n\n      (b) Contributor APIs. If Contributor's Modifications include an application programming interface and Contributor has knowledge of patent licenses which are reasonably necessary to implement that API, Contributor must also include this information in the LEGAL file.\n\n      (c) Representations. Contributor represents that, except as disclosed pursuant to Section 3.4(a) above, Contributor believes that Contributor's Modifications are Contributor's original creation(s) and/or Contributor has sufficient rights to grant the rights conveyed by this License.\n\n   3.5 Required Notices.\n\n   You must duplicate the notice in Exhibit A in each file of the Source Code. If it is not possible to put such notice in a particular Source Code file due to its structure, then You must include such notice in a location (such as a relevant directory) where a user would be likely to look for such a notice. If You created one or more Modification(s) You may add your name as a Contributor to the notice described in Exhibit A. You must also duplicate this License in any documentation for the Source Code where You describe recipients' rights or ownership rights relating to Covered Software. You may choose to offer, and to charge a fee for, warranty, support, indemnity or liability obligations to one or more recipients of Covered Software. However, You may do so only on Your own behalf, and not on behalf of Nokia or any Contributor. You must make it absolutely clear that any such warranty, support, indemnity or liability obligation is offered by You alone, and You hereby agree to indemnify Nokia and every Contributor for any liability incurred by Nokia or such Contributor as a result of warranty, support, indemnity or liability terms You offer.\n\n   3.6 Distribution of Executable Versions.\n\n   You may distribute Covered Software in Executable form only if the requirements of Section 3.1-3.5 have been met for that Covered Software, and if You include a notice stating that the Source Code version of the Covered Software is available under the terms of this License, including a description of how and where You have fulfilled the obligations of Section 3.2. The notice must be conspicuously included in any notice in an Executable version, related documentation or collateral in which You describe recipients' rights relating to the Covered Software. You may distribute the Executable version of Covered Software or ownership rights under a license of Your choice, which may contain terms different from this License, provided that You are in compliance with the terms of this License and that the license for the Executable version does not attempt to limit or alter the recipient's rights in the Source Code version from the rights set forth in this License. If You distribute the Executable version under a different license You must make it absolutely clear that any terms which differ from this License are offered by You alone, not by Nokia or any Contributor. You hereby agree to indemnify Nokia and every Contributor for any liability incurred by Nokia or such Contributor as a result of any such terms You offer.\n\n   3.7 Larger Works.\n\n   You may create a Larger Work by combining Covered Software with other software not governed by the terms of this License and distribute the Larger Work as a single product. In such a case, You must make sure the requirements of this License are fulfilled for the Covered Software. 4. INABILITY TO COMPLY DUE TO STATUTE OR REGULATION.\n\nIf it is impossible for You to comply with any of the terms of this License with respect to some or all of the Covered Software due to statute, judicial order, or regulation then You must: (a) comply with the terms of this License to the maximum extent possible; and (b) describe the limitations and the code they affect. Such description must be included in the LEGAL file described in Section 3.4 and must be included with all distributions of the Source Code.\n\nExcept to the extent prohibited by statute or regulation, such description must be sufficiently detailed for a recipient of ordinary skill to be able to understand it. 5. APPLICATION OF THIS LICENSE.\n\nThis License applies to code to which Nokia has attached the notice in Exhibit A and to related Covered Software. 6. VERSIONS OF THE LICENSE.\n\n   6.1 New Versions.\n\n   Nokia may publish revised and/or new versions of the License from time to time. Each version will be given a distinguishing version number.\n\n   6.2 Effect of New Versions.\n\n   Once Covered Software has been published under a particular version of the License, You may always continue to use it under the terms of that version. You may also choose to use such Covered Software under the terms of any subsequent version of the License published by Nokia. No one other than Nokia has the right to modify the terms applicable to Covered Software created under this License. 7. DISCLAIMER OF WARRANTY.\n\nCOVERED SOFTWARE IS PROVIDED UNDER THIS LICENSE ON AN \"AS IS\" BASIS, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES THAT THE COVERED SOFTWARE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED SOFTWARE IS WITH YOU. SHOULD ANY COVERED SOFTWARE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT NOKIA, ITS LICENSORS OR AFFILIATES OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. NO USE OF ANY COVERED SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER. 8. TERMINATION.\n\n   8.1 This License and the rights granted hereunder will terminate automatically if You fail to comply with terms herein and fail to cure such breach within 30 days of becoming aware of the breach. All sublicenses to the Covered Software which are properly granted shall survive any termination of this License. Provisions which, by their nature, must remain in effect beyond the termination of this License shall survive.\n\n   8.2 If You initiate litigation by asserting a patent infringement claim (excluding declatory judgment actions) against Nokia or a Contributor (Nokia or Contributor against whom You file such action is referred to as \"Participant\") alleging that:\n\n      a) such Participant's Contributor Version directly or indirectly infringes any patent, then any and all rights granted by such Participant to You under Sections 2.1 and/or 2.2 of this License shall, upon 60 days notice from Participant terminate prospectively, unless if within 60 days after receipt of notice You either: (i) agree in writing to pay Participant a mutually agreeable reasonable royalty for Your past and future use of Modifications made by such Participant, or (ii) withdraw Your litigation claim with respect to the Contributor Version against such Participant. If within 60 days of notice, a reasonable royalty and payment arrangement are not mutually agreed upon in writing by the parties or the litigation claim is not withdrawn, the rights granted by Participant to You under Sections 2.1 and/or 2.2 automatically terminate at the expiration of the 60 day notice period specified above.\n\n      b) any software, hardware, or device, other than such Participant's Contributor Version, directly or indirectly infringes any patent, then any rights granted to You by such Participant under Sections 2.1(b) and 2.2(b) are revoked effective as of the date You first made, used, sold, distributed, or had made, Modifications made by that Participant.\n\n   8.3 If You assert a patent infringement claim against Participant alleging that such Participant's Contributor Version directly or indirectly infringes any patent where such claim is resolved (such as by license or settlement) prior to the initiation of patent infringement litigation, then the reasonable value of the licenses granted by such Participant under Sections 2.1 or 2.2 shall be taken into account in determining the amount or value of any payment or license.\n\n   8.4 In the event of termination under Sections 8.1 or 8.2 above, all end user license agreements (excluding distributors and resellers) which have been validly granted by You or any distributor hereunder prior to termination shall survive termination. 9. LIMITATION OF LIABILITY.\n\nUNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER TORT (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL YOU, NOKIA, ANY OTHER CONTRIBUTOR, OR ANY DISTRIBUTOR OF COVERED SOFTWARE, OR ANY SUPPLIER OF ANY OF SUCH PARTIES, BE LIABLE TO ANY PERSON FOR ANY INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, COMPUTER FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER COMMERCIAL DAMAGES OR LOSSES, EVEN IF SUCH PARTY SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF LIABILITY SHALL NOT APPLY TO LIABILITY FOR DEATH OR PERSONAL INJURY RESULTING FROM SUCH PARTY'S NEGLIGENCE TO THE EXTENT APPLICABLE LAW PROHIBITS SUCH LIMITATION. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OR LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, BUT MAY ALLOW LIABILITY TO BE LIMITED; IN SUCH CASES, A PARTY's, ITS EMPLOYEES, LICENSORS OR AFFILIATES' LIABILITY SHALL BE LIMITED TO U.S. $50. Nothing contained in this License shall prejudice the statutory rights of any party dealing as a consumer. 10. MISCELLANEOUS.\n\nThis License represents the complete agreement concerning subject matter hereof. All rights in the Covered Software not expressly granted under this License are reserved. Nothing in this License shall grant You any rights to use any of the trademarks of Nokia or any of its Affiliates, even if any of such trademarks are included in any part of Covered Software and/or documentation to it.\n\nThis License is governed by the laws of Finland excluding its conflict-of-law provisions. All disputes arising from or relating to this Agreement shall be settled by a single arbitrator appointed by the Central Chamber of Commerce of Finland. The arbitration procedure shall take place in Helsinki, Finland in the English language. If any part of this Agreement is found void and unenforceable, it will not affect the validity of the balance of the Agreement, which shall remain valid and enforceable according to its terms. 11. RESPONSIBILITY FOR CLAIMS.\n\nAs between Nokia and the Contributors, each party is responsible for claims and damages arising, directly or indirectly, out of its utilization of rights under this License and You agree to work with Nokia and Contributors to distribute such responsibility on an equitable basis. Nothing herein is intended or shall be deemed to constitute any admission of liability. EXHIBIT A\n\nThe contents of this file are subject to the NOKOS License Version 1.0 (the \"License\"); you may not use this file except in compliance with the License.\n\nSoftware distributed under the License is distributed on an \"AS IS\" basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the specific language governing rights and limitations under the License.\n\nThe Original Software is\n\n______________________________________.\n\nCopyright © \u003cyear\u003e Nokia and others. All Rights Reserved.\n\nContributor(s): ______________________________________."],"licenseIds":["Nokia"],"keywords":["source license nokos","license nokos license","1 0a 1","0a 1 definitions","1 definitions affiliates","definitions affiliates of","affiliates of a","a party shall","party shall mean","mean an entity","an entity a","entity a which","indirectly controlling such","controlling such party","such party b","party b which","b which is","which is under","is under the","the same direct","same direct or","indirect ownership or","ownership or control","or control as","control as such","as such party","party or c","or c which","c which is","or indirectly owned","indirectly owned or","by such party","such party for","party for these","these purposes an","purposes an entity","an entity shall","as being controlled","being controlled by","controlled by another","by another if","another if that","if that other","that other entity","other entity has","entity has fifty","has fifty percent","of the votes","the votes in","votes in such","in such entity","such entity is","entity is able","able to direct","direct its affairs","its affairs and","affairs and or","and or to","or to control","control the composition","the composition of","composition of its","of its board","its board of","board of directors","of directors or","directors or equivalent","or equivalent body","equivalent body commercial","body commercial use","commercial use shall","shall mean distribution","mean distribution or","third party contributor","party contributor shall","shall mean each","mean each entity","of modifications contributor","modifications contributor version","contributor version shall","version shall mean","shall mean in","mean in case","any contributor the","contributor the combination","particular contributor and","contributor and in","and in case","case of nokia","nokia in addition","addition the original","original software in","any form including","form including the","including the form","the form as","form as exceutable","as exceutable covered","exceutable covered software","covered software shall","mean the original","portions thereof electronic","thereof electronic distribution","distribution mechanism shall","mechanism shall mean","mean a mechanism","of data executable","data executable shall","executable shall mean","shall mean covered","mean covered software","source code nokia","code nokia shall","nokia shall mean","shall mean nokia","mean nokia corporation","nokia corporation and","corporation and its","and its affiliates","its affiliates larger","affiliates larger work","larger work shall","mean a work","license license shall","shall mean this","mean this document","this document licensable","document licensable shall","licensable shall mean","shall mean having","mean having the","conveyed herein modifications","herein modifications shall","modifications shall mean","when covered software","previous modifications original","modifications original software","original software shall","mean the source","as original software","software and which","already covered software","covered software governed","license patent claims","patent claims shall","claims shall mean","mean any patent","by grantor source","grantor source code","code shall mean","covered software for","software for making","software or another","available covered software","no charge you","charge you or","you includes affiliates","includes affiliates of","affiliates of such","2 1 nokia","1 nokia grant","nokia grant subject","this license nokia","license nokia hereby","nokia hereby grants","licensable by nokia","by nokia to","nokia to use","work b and","b and under","and under patents","patents claims necessarily","the date nokia","date nokia first","nokia first distributes","distributes original software","original software 2","software 2 separate","software or 3","patent claims necessarily","covered software d","software d notwithstanding","covered software may","all covered software","covered software to","provided by nokia","by nokia and","nokia and including","name of nokia","nokia in a","covered software 3","software 3 4","software that new","behalf of nokia","software and if","software is available","software or ownership","not by nokia","other software not","software 4 inability"]},{"licenseTexts":["Noweb is copyright 1989-2000 by Norman Ramsey. All rights reserved.\n\nNoweb is protected by copyright. It is not public-domain software or shareware, and it is not protected by a ``copyleft'' agreement like the one used by the Free Software Foundation.\n\nNoweb is available free for any use in any field of endeavor. You may redistribute noweb in whole or in part provided you acknowledge its source and include this COPYRIGHT file. You may modify noweb and create derived works, provided you retain this copyright notice, but the result may not be called noweb without my written consent.\n\nYou may sell noweb if you wish. For example, you may sell a CD-ROM including noweb.\n\nYou may sell a derived work, provided that all source code for your derived work is available, at no additional charge, to anyone who buys your derived work in any form. You must give permisson for said source code to be used and modified under the terms of this license. You must state clearly that your work uses or is based on noweb and that noweb is available free of change. You must also request that bug reports on your work be reported to you."],"licenseIds":["Noweb"],"keywords":["noweb is copyright","is copyright 1989","copyright 1989 2000","1989 2000 by","2000 by norman","by norman ramsey","norman ramsey all","ramsey all rights","rights reserved noweb","reserved noweb is","noweb is protected","by copyright it","copyright it is","is not public","not public domain","domain software or","software or shareware","or shareware and","shareware and it","and it is","is not protected","not protected by","protected by a","by a copyleft","a copyleft agreement","copyleft agreement like","agreement like the","like the one","the one used","one used by","software foundation noweb","foundation noweb is","available free for","free for any","any use in","in any field","of endeavor you","endeavor you may","may redistribute noweb","redistribute noweb in","noweb in whole","part provided you","you acknowledge its","acknowledge its source","its source and","source and include","and include this","this copyright file","copyright file you","may modify noweb","modify noweb and","noweb and create","and create derived","create derived works","derived works provided","works provided you","retain this copyright","copyright notice but","notice but the","but the result","the result may","result may not","be called noweb","called noweb without","noweb without my","without my written","my written consent","written consent you","consent you may","may sell noweb","sell noweb if","noweb if you","you wish for","wish for example","sell a cd","cd rom including","rom including noweb","including noweb you","noweb you may","sell a derived","that all source","for your derived","work is available","at no additional","no additional charge","additional charge to","charge to anyone","anyone who buys","who buys your","buys your derived","must give permisson","give permisson for","permisson for said","for said source","said source code","used and modified","and modified under","you must state","must state clearly","state clearly that","clearly that your","your work uses","work uses or","uses or is","based on noweb","on noweb and","noweb and that","and that noweb","that noweb is","available free of","free of change","must also request","also request that","request that bug","that bug reports","bug reports on","reports on your","on your work","your work be","work be reported","reported to you","noweb is copyright 1989","is copyright 1989 2000","copyright 1989 2000 by","1989 2000 by norman","2000 by norman ramsey","by norman ramsey all","norman ramsey all rights","ramsey all rights reserved","all rights reserved noweb","rights reserved noweb is","reserved noweb is protected","noweb is protected by","protected by copyright it","by copyright it is","copyright it is not","it is not public","is not public domain","not public domain software","public domain software or","domain software or shareware","software or shareware and","or shareware and it","shareware and it is","and it is not","it is not protected","is not protected by","not protected by a","protected by a copyleft","by a copyleft agreement","a copyleft agreement like","copyleft agreement like the","agreement like the one","like the one used","the one used by","one used by the","used by the free","free software foundation noweb","software foundation noweb is","foundation noweb is available","is available free for","available free for any","free for any use","for any use in","any use in any","use in any field","in any field of","any field of endeavor","field of endeavor you","of endeavor you may","endeavor you may redistribute","you may redistribute noweb","may redistribute noweb in","redistribute noweb in whole","noweb in whole or","or in part provided","in part provided you","part provided you acknowledge","provided you acknowledge its","you acknowledge its source","acknowledge its source and","its source and include","source and include this","and include this copyright","include this copyright file","this copyright file you","copyright file you may","file you may modify","you may modify noweb","may modify noweb and","modify noweb and create","noweb and create derived","and create derived works","create derived works provided","derived works provided you","works provided you retain","provided you retain this","you retain this copyright","retain this copyright notice","this copyright notice but"]},{"licenseTexts":["Copyright © 2002-2004 James W. Newkirk, Michael C. Two, Alexei A. Vorontsov, Charlie Poole\n\nCopyright © 2000-2004 Philip A. Craig\n\nThis software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software.\n\nPermission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions:\n\n   1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment (see the following) in the product documentation is required.\n\n   Portions Copyright © 2002-2004 James W. Newkirk, Michael C. Two, Alexei A. Vorontsov, Charlie Poole or Copyright © 2000-2004 Philip A. Craig\n\n   2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.\n\n   3. This notice may not be removed or altered from any source distribution."],"licenseIds":["Nunit"],"keywords":["poole copyright 2000","portions copyright 2002","or copyright 2000","vorontsov charlie poole copyright","charlie poole copyright 2000","poole copyright 2000 2004","required portions copyright 2002","portions copyright 2002 2004","vorontsov charlie poole or","poole or copyright 2000","or copyright 2000 2004","a vorontsov charlie poole copyright","vorontsov charlie poole copyright 2000","charlie poole copyright 2000 2004","poole copyright 2000 2004 philip","2004 philip a craig this","is required portions copyright 2002","required portions copyright 2002 2004","portions copyright 2002 2004 james","a vorontsov charlie poole or","vorontsov charlie poole or copyright","charlie poole or copyright 2000","poole or copyright 2000 2004","or copyright 2000 2004 philip","2004 philip a craig 2"]},{"licenseTexts":["Open Use of Data Agreement v1.0\n\nThis is the Open Use of Data Agreement, Version 1.0 (the \"O-UDA\"). Capitalized terms are defined in Section 5. Data Provider and you agree as follows:\n\n   1. Provision of the Data\n\n      1.1. You may use, modify, and distribute the Data made available to you by the Data Provider under this O-UDA if you follow the O-UDA's terms.\n\n      1.2. Data Provider will not sue you or any Downstream Recipient for any claim arising out of the use, modification, or distribution of the Data provided you meet the terms of the O-UDA.\n\n      1.3. This O-UDA does not restrict your use, modification, or distribution of any portions of the Data that are in the public domain or that may be used, modified, or distributed under any other legal exception or limitation.\n\n   2. No Restrictions on Use or Results\n\n      2.1. The O-UDA does not impose any restriction with respect to:\n\n         2.1.1. the use or modification of Data; or\n\n         2.1.2. the use, modification, or distribution of Results.\n\n   3. Redistribution of Data\n\n      3.1. You may redistribute the Data under terms of your choice, so long as:\n\n         3.1.1. You include with any Data you redistribute all credit or attribution information that you received with the Data, and your terms require any Downstream Recipient to do the same; and\n\n         3.1.2. Your terms include a warranty disclaimer and limitation of liability for Upstream Data Providers at least as broad as those contained in Section 4.2 and 4.3 of the O-UDA.\n\n   4. No Warranty, Limitation of Liability\n\n      4.1. Data Provider does not represent or warrant that it has any rights whatsoever in the Data.\n\n      4.2. THE DATA IS PROVIDED ON AN \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.\n\n      4.3. NEITHER DATA PROVIDER NOR ANY UPSTREAM DATA PROVIDER SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE DATA OR RESULTS, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\n   5. Definitions\n\n      5.1. \"Data\" means the material you receive under the O-UDA in modified or unmodified form, but not including Results.\n\n      5.2. \"Data Provider\" means the source from which you receive the Data and with whom you enter into the O-UDA.\n\n      5.3. \"Downstream Recipient\" means any person or persons who receives the Data directly or indirectly from you in accordance with the O-UDA.\n\n      5.4. \"Result\" means anything that you develop or improve from your use of Data that does not include more than a de minimis portion of the Data on which the use is based. Results may include de minimis portions of the Data necessary to report on or explain use that has been conducted with the Data, such as figures in scientific papers, but do not include more. Artificial intelligence models trained on Data (and which do not include more than a de minimis portion of Data) are Results.\n\n      5.5. \"Upstream Data Providers\" means the source or sources from which the Data Provider directly or indirectly received, under the terms of the O-UDA, material that is included in the Data."],"licenseIds":["O-UDA-1.0"],"keywords":["data agreement v1","v1 0 this","the open use","data agreement version","0 the o","o uda capitalized","uda capitalized terms","capitalized terms are","section 5 data","5 data provider","data provider and","provider and you","follows 1 provision","1 provision of","the data 1","data 1 1","distribute the data","the data made","data made available","data provider under","provider under this","under this o","o uda if","uda if you","follow the o","o uda s","uda s terms","s terms 1","terms 1 2","1 2 data","data provider will","provider will not","will not sue","not sue you","sue you or","or any downstream","downstream recipient for","any claim arising","the data provided","data provided you","provided you meet","o uda 1","uda 1 3","3 this o","not restrict your","restrict your use","your use modification","of any portions","any portions of","the data that","data that are","are in the","domain or that","be used modified","used modified or","modified or distributed","or distributed under","other legal exception","legal exception or","or limitation 2","limitation 2 no","2 no restrictions","restrictions on use","on use or","use or results","or results 2","results 2 1","1 the o","does not impose","impose any restriction","any restriction with","restriction with respect","respect to 2","to 2 1","1 the use","use or modification","modification of data","data or 2","or 2 1","2 the use","distribution of results","of results 3","results 3 redistribution","redistribution of data","of data 3","data 3 1","redistribute the data","data under terms","long as 3","as 3 1","3 1 1","1 you include","include with any","with any data","any data you","data you redistribute","you redistribute all","redistribute all credit","or attribution information","attribution information that","information that you","you received with","received with the","data and your","and your terms","your terms require","terms require any","require any downstream","downstream recipient to","recipient to do","the same and","same and 3","and 3 1","3 1 2","1 2 your","2 your terms","your terms include","terms include a","include a warranty","a warranty disclaimer","warranty disclaimer and","of liability for","liability for upstream","for upstream data","data providers at","providers at least","least as broad","as broad as","broad as those","as those contained","contained in section","4 2 and","and 4 3","4 3 of","o uda 4","uda 4 no","4 no warranty","no warranty limitation","warranty limitation of","of liability 4","liability 4 1","4 1 data","1 data provider","data provider does","does not represent","not represent or","represent or warrant","or warrant that","warrant that it","it has any","has any rights","any rights whatsoever","rights whatsoever in","whatsoever in the","the data 4","2 the data","purpose 4 3","4 3 neither","3 neither data","neither data provider","data provider nor","provider nor any","nor any upstream","any upstream data","upstream data provider","data provider shall","provider shall have","data or results","or results even","results even if","damages 5 definitions","5 definitions 5","definitions 5 1","5 1 data","1 data means","means the material","the material you","material you receive","you receive under","receive under the","under the o","o uda in","uda in modified","in modified or","or unmodified form","unmodified form but","form but not","but not including","not including results","including results 5","results 5 2","5 2 data","the source from","source from which","from which you","receive the data","data and with","and with whom","with whom you","whom you enter"]},{"licenseTexts":["Open CASCADE Technology Public License\n\nVersion 6.6, April 2013\n\nOPEN CASCADE releases and makes publicly available the source code of the software Open CASCADE Technology to the free software development community under the terms and conditions of this license.\n\nIt is not the purpose of this license to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this license has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice.\n\nPlease read this license carefully and completely before downloading this software. By downloading, using, modifying, distributing and sublicensing this software, you indicate your acceptance to be bound by the terms and conditions of this license. If you do not want to accept or cannot accept for any reasons the terms and conditions of this license, please do not download or use in any manner this software.\n\n   1. Definitions\n\n   Unless there is something in the subject matter or in the context inconsistent therewith, the capitalized terms used in this License shall have the following meaning.\n\n   \"Applicable Intellectual Property Rights\" means (a) with respect to the Initial Developer, any rights under patents or patents applications or other intellectual property rights that are now or hereafter acquired, owned by or assigned to the Initial Developer and that cover subject matter contained in the Original Code, but only to the extent necessary to use, reproduce, modify, distribute or sublicense the Original Code without infringement; and (b) with respect to You or any Contributor, any rights under patents or patents applications or other intellectual property rights that are now or hereafter acquired, owned by or assigned to You or to such Contributor and that cover subject matter contained in Your Modifications or in such Contributor's Modifications, taken alone or in combination with Original Code.\n\n   \"Contributor\" means each individual or legal entity that creates or contributes to the creation of any Modification, including the Initial Developer.\n\n   \"Derivative Program\": means a new program combining the Software or portions thereof with other source code not governed by the terms of this License.\n\n   \"Initial Developer\": means OPEN CASCADE, with main offices at 1, place des Frères Montgolfier, 78280, Guyancourt, France.\n\n   \"Modifications\": mean any addition to, deletion from or change to the substance or the structure of the Software. When source code of the Software is released as a series of files, a Modification is: (a) any addition to, deletion from or change to the contents of a file containing the Software or (b) any new file or other representation of computer program statements that contains any part of the Software. By way of example, Modifications include any debug of, or improvement to, the Original Code or any of its components or portions as well as its next versions or releases thereof.\n\n   \"Original Code\": means (a) the source code of the software Open CASCADE Technology originally made available by the Initial Developer under this License, including the source code of any updates or upgrades of the Original Code and (b) the object code compiled from such source code and originally made available by Initial Developer under this License.\n\n   \"Software\": means the Original Code, the Modifications, the combination of Original Code and any Modifications or any respective portions thereof.\n\n   \"You\" or \"Your\": means an individual or a legal entity exercising rights under this License\n\n   2. Acceptance of license\n\n   By using, reproducing, modifying, distributing or sublicensing the Software or any portion thereof, You expressly indicate Your acceptance of the terms and conditions of this License and undertake to act in accordance with all the provisions of this License applicable to You.\n\n   3. Scope and purpose\n\n   This License applies to the Software and You may not use, reproduce, modify, distribute, sublicense or circulate the Software, or any portion thereof, except as expressly provided under this License. Any attempt to otherwise use, reproduce, modify, distribute or sublicense the Software is void and will automatically terminate Your rights under this License.\n\n   4. Contributor license\n\n   Subject to the terms and conditions of this License, the Initial Developer and each of the Contributors hereby grant You a world-wide, royalty-free, irrevocable and non-exclusive license under the Applicable Intellectual Property Rights they own or control, to use, reproduce, modify, distribute and sublicense the Software provided that:\n\n   You reproduce in all copies of the Software the copyright and other proprietary notices and disclaimers of the Initial Developer as they appear in the Original Code and attached hereto as Schedule \"A\" and any other notices or disclaimers attached to the Software and keep intact all notices in the Original Code that refer to this License and to the absence of any warranty;\n\n   You include a copy of this License with every copy of the Software You distribute;\n\n   If you distribute or sublicense the Software (as modified by You or on Your behalf as the case may be), You cause such Software to be licensed as a whole, at no charge, to all third parties, under the terms and conditions of the License, making in particular available to all third parties the source code of the Software;\n\n   You document all Your Modifications, indicate the date of each such Modification, designate the version of the Software You used, prominently include a file carrying such information with respect to the Modifications and duplicate the copyright and other proprietary notices and disclaimers attached hereto as Schedule \"B\" or any other notices or disclaimers attached to the Software with your Modifications.\n\n   For greater certainty, it is expressly understood that You may freely create Derivative Programs (without any obligation to publish such Derivative Program) and distribute same as a single product. In such case, You must ensure that all the requirements of this License are fulfilled for the Software or any portion thereof.\n\n   5. Your license\n\n   You hereby grant all Contributors and anyone who becomes a party under this License a world-wide, non-exclusive, royalty-free and irrevocable license under the Applicable Intellectual Property Rights owned or controlled by You, to use, reproduce, modify, distribute and sublicense all Your Modifications under the terms and conditions of this License.\n\n   6. Software subject to license\n\n   Your Modifications shall be governed by the terms and conditions of this License. You are not authorized to impose any other terms or conditions than those prevailing under this License when You distribute and/or sublicense the Software, save and except as permitted under Section 7 hereof.\n\n   7. Additional terms\n\n   You may choose to offer, on a non-exclusive basis, and to charge a fee for any warranty, support, maintenance, liability obligations or other rights consistent with the scope of this License with respect to the Software (the \"Additional Terms\") to the recipients of the Software. However, You may do so only on Your own behalf and on Your sole and exclusive responsibility. You must obtain the recipient's agreement that any such Additional Terms are offered by You alone, and You hereby agree to indemnify, defend and hold the Initial Developer and any Contributor harmless for any liability incurred by or claims asserted against the Initial Developer or any Contributors with respect to any such Additional Terms.\n\n   8. Disclaimer of warranty\n\n   The Software is provided under this License on an \"as is\" basis, without warranty of any kind, including without limitation, warranties that the Software is free of defects, merchantable, fit for a particular purpose or non-infringing. The entire risk as to the quality and performance of the Software is with You.\n\n   9. Liability\n\n   Under no circumstances shall You, the Initial Developer or any Contributor be liable to any person for any direct or indirect damages of any kind including, without limitation, damages for loss of goodwill, loss of data, work stoppage, computer failure or malfunction or any and all other commercial damages or losses resulting from or relating to this License or indirectly to the use of the Software.\n\n   10. Trademark\n\n   This License does not grant any rights to use the trademarks, trade names and domain names \"MATRA\", \"EADS Matra Datavision\", \"CAS.CADE\", \"Open CASCADE\", \"opencascade.com\" and \"opencascade.org\" or any other trademarks, trade names or domain names used or owned by the Initial Developer.\n\n   11. Copyright\n\n   The Initial Developer retains all rights, title and interest in and to the Original Code. You may not remove the copyright © notice which appears when You download the Software.\n\n   12. Term\n\n   This License is granted to You for a term equal to the remaining period of protection covered by the intellectual property rights applicable to the Original Code.\n\n   13. Termination\n\n   In case of termination, as provided in Section 3 above, You agree to immediately stop any further use, reproduction, modification, distribution and sublicensing of the Software and to destroy all copies of the Software that are in Your possession or control. All sublicenses of the Software which have been properly granted prior to termination shall survive any termination of this License. In addition, Sections 5, 8 to 11, 13.2 and 15.2 of this License, in reason of their nature, shall survive the termination of this License for a period of fifteen (15) years.\n\n   14. Versions of the license\n\n   The Initial Developer may publish new versions of this License from time to time. Once Original Code has been published under a particular version of this License, You may choose to continue to use it under the terms and conditions of that version or use the Original Code under the terms of any subsequent version of this License published by the Initial Developer.\n\n   15. Miscellaneous\n\n      15.1 Relationship of the Parties This License will not be construed as creating an agency, partnership, joint venture or any other form of legal association between You and the Initial Developer, and You will not represent to the contrary, whether expressly, by implication or otherwise.\n\n      15.2 Independent Development Nothing in this License will impair the Initial Developer's right to acquire, license, develop, have others develop for it, market or distribute technology or products that perform the same or similar functions as, or otherwise compete with, Modifications, Derivative Programs, technology or products that You may develop, produce, market or distribute.\n\n      15.3 Severability If for any reason a court of competent jurisdiction finds any provision of this License, or portion thereof, to be unenforceable, that provision of the License will be enforced to the maximum extent permissible so as to effect the economic benefits and intent of the parties, and the remainder of this License will continue in full force and extent. END OF THE TERMS AND CONDITIONS OF THIS LICENSE\n\nOPEN CASCADE is a French société par actions simplifiée having its registered head office at 1, place des Frères Montgolfier, 78280, Guyancourt, France and main offices at 1, place des Frères Montgolfier, 78280, Guyancourt, France. Its web site is located at the following address opencascade.com\n\nOpen CASCADE Technology Public License\n\nSchedule \"A\"\n\nThe content of this file is subject to the Open CASCADE Technology Public License (the \"License\"). You may not use the content of this file except in compliance with the License. Please obtain a copy of the License at opencascade.com and read it completely before using this file.\n\nThe Initial Developer of the Original Code is OPEN CASCADE, with main offices at 1, place des Frères Montgolfier, 78280, Guyancourt, France. The Original Code is copyright © OPEN CASCADE SAS, 2001. All rights reserved. \"The Original Code and all software distributed under the License are distributed on an \"AS IS\" basis, without warranty of any kind, and the Initial Developer hereby disclaims all such warranties, including without limitation, any warranties of merchantability, fitness for a particular purpose or non-infringement.\n\nPlease see the License for the specific terms and conditions governing rights and limitations under the License\".\n\nEnd of Schedule \"A\"\n\nOpen CASCADE Technology Public License\n\nSchedule \"B\"\n\n\"The content of this file is subject to the Open CASCADE Technology Public License (the \"License\"). You may not use the content of this file except in compliance with the License. Please obtain a copy of the License at opencascade.com and read it completely before using this file.\n\nThe Initial Developer of the Original Code is OPEN CASCADE, with main offices at 1, place des Frères Montgolfier, 78280, Guyancourt, France. The Original Code is copyright © Open CASCADE SAS, 2001. All rights reserved.\n\nModifications to the Original Code have been made by ________________________. Modifications are copyright © [Year to be included]. All rights reserved.\n\nThe software Open CASCADE Technology and all software distributed under the License are distributed on an \"AS IS\" basis, without warranty of any kind, and the Initial Developer hereby disclaims all such warranties, including without limitation, any warranties of merchantability, fitness for a particular purpose or non-infringement.\n\nPlease see the License for the specific terms and conditions governing rights and limitations under the License\"\n\nEnd of Schedule \"B\""],"licenseIds":["OCCT-PL"],"keywords":["license version 6","version 6 6","6 6 april","6 april 2013","april 2013 open","2013 open cascade","open cascade releases","cascade releases and","releases and makes","and makes publicly","publicly available the","cascade technology to","technology to the","free software development","development community under","community under the","license to induce","claims this license","license has the","that choice please","choice please read","license carefully and","carefully and completely","and completely before","completely before downloading","by downloading using","downloading using modifying","using modifying distributing","modifying distributing and","distributing and sublicensing","and sublicensing this","sublicensing this software","your acceptance to","not want to","want to accept","to accept or","accept or cannot","or cannot accept","cannot accept for","accept for any","for any reasons","any reasons the","reasons the terms","or use in","any manner this","manner this software","this software 1","1 definitions unless","definitions unless there","there is something","is something in","something in the","matter or in","in the context","the context inconsistent","context inconsistent therewith","inconsistent therewith the","therewith the capitalized","the capitalized terms","capitalized terms used","terms used in","following meaning applicable","meaning applicable intellectual","property rights means","rights means a","means a with","a with respect","developer any rights","sublicense the original","and b with","b with respect","respect to you","any contributor any","contributor any rights","you or to","or to such","to such contributor","contained in your","modifications or in","or in such","in such contributor","s modifications taken","original code contributor","code contributor means","creation of any","of any modification","any modification including","modification including the","initial developer derivative","developer derivative program","derivative program means","program means a","means a new","new program combining","program combining the","combining the software","thereof with other","with other source","other source code","source code not","this license initial","developer means open","means open cascade","guyancourt france modifications","france modifications mean","substance or the","or the structure","the structure of","the software when","software when source","when source code","containing the software","software by way","of example modifications","example modifications include","modifications include any","include any debug","any debug of","debug of or","of or improvement","or improvement to","its components or","components or portions","or portions as","portions as well","as its next","its next versions","next versions or","versions or releases","or releases thereof","releases thereof original","thereof original code","cascade technology originally","technology originally made","or upgrades of","upgrades of the","available by initial","this license software","license software means","code the modifications","the modifications the","portions thereof you","thereof you or","license 2 acceptance","2 acceptance of","of license by","by using reproducing","using reproducing modifying","reproducing modifying distributing","distributing or sublicensing","or sublicensing the","sublicensing the software","portion thereof you","thereof you expressly","you expressly indicate","expressly indicate your","license and undertake","and undertake to","undertake to act","act in accordance","accordance with all","applicable to you","to you 3","you 3 scope","3 scope and","scope and purpose","and purpose this","not use reproduce","modify distribute sublicense","distribute sublicense or","sublicense or circulate","or circulate the","circulate the software","portion thereof except","thereof except as","attempt to otherwise","to otherwise use","otherwise use reproduce","software is void","license 4 contributor","4 contributor license","contributor license subject","developer and each","and each of","free irrevocable and","irrevocable and non","and non exclusive","property rights they","rights they own","they own or","that you reproduce","you reproduce in","software the copyright","disclaimers of the","developer as they","code and attached","and attached hereto","as schedule a","schedule a and","a and any"]},{"licenseTexts":["OCLC Research Public License 2.0\n\nTerms \u0026 Conditions Of Use\n\nMay, 2002 Copyright © 2002. OCLC Online Computer Library Center, Inc. All Rights Reserved\n\nPLEASE READ THIS DOCUMENT CAREFULLY. BY DOWNLOADING OR USING THE CODE BASE AND/OR DOCUMENTATION ACCOMPANYING THIS LICENSE (THE \"License\"), YOU AGREE TO THE FOLLOWING TERMS AND CONDITIONS OF THIS LICENSE.\n\nSection 1. Your Rights\n\nSubject to these terms and conditions of this License, the OCLC Office of Research (the \"Original Contributor\") and each subsequent contributor (collectively with the Original Contributor, the \"Contributors\") hereby grant you a non-exclusive, worldwide, no-charge, transferable license to execute, prepare derivative works of, and distribute (internally and externally), for commercial and noncommercial purposes, the original code contributed by Original Contributor and all Modifications (collectively called the \"Program\").\n\nSection 2. Definitions\n\nA \"Modification\" to the Program is any addition to or deletion from the contents of any file of the Program and any new file that contains any part of the Program. If you make a Modification and distribute the Program externally you are a \"Contributor.\" The distribution of the Program must be under the terms of this license including those in Section 3 below.\n\nA \"Combined Work\" results from combining and integrating all or parts of the Program with other code. A Combined Work may be thought of as having multiple parents or being result of multiple lines of code development.\n\nSection 3. Distribution Licensing Terms\n\n   A. General Requirements\n\n   Except as necessary to recognize third-party rights or third-party restriction (see below), a distribution of the Program in any of the forms listed below must not put any further restrictions on the recipient's exercise of the rights granted herein.\n\n   As a Contributor, you represent that your Modification(s) are your original creation(s) and, to the best of your knowledge, no third party has any claim (including but not limited to intellectual property claims) relating to your Modification(s). You represent that each of your Modifications includes complete details of any third-party right or other third-party restriction associated with any part of your Modification (including a copy of any applicable license agreement).\n\n   The Program must be distributed without charge beyond the costs of physically transferring the files to the recipient.\n\n   This Warranty Disclaimer/Limitation of Liability must be prominently displayed with every distribution of the Program in any form:\n\n   YOU AGREE THAT THE PROGRAM IS PROVIDED AS-IS, WITHOUT WARRANTY OF ANY KIND (EITHER EXPRESS OR IMPLIED). ACCORDINGLY, OCLC MAKES NO WARRANTIES, REPRESENTATIONS OR GUARANTEES, EITHER EXPRESS OR IMPLIED, AND DISCLAIMS ALL SUCH WARRANTIES, REPRESENTATIONS OR GUARANTEES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ANY PARTICULAR PURPOSE, AS TO: (A) THE FUNCTIONALITY OR NONINFRINGEMENT OF PROGRAM, ANY MODIFICATION, A COMBINED WORK OR AN AGGREGATE WORK; OR (B) THE RESULTS OF ANY PROJECT UNDERTAKEN USING THE PROGRAM, ANY MODIFICATION, A COMBINED WORK OR AN AGGREGATE WORK. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, CONSEQUENTIAL OR ANY OTHER DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE PROGRAM, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. YOU HEREBY WAIVE ANY CLAIMS FOR DAMAGES OF ANY KIND AGAINST CONTRIBUTORS WHICH MAY RESULT FROM YOUR USE OF THE PROGRAM.\n\n   B. Requirements for a Distribution of Modifiable Code\n\n   If you distribute the Program in a form to which the recipient can make Modifications (e.g. source code), the terms of this license apply to use by recipient. In addition, each source and data file of the Program and any Modification you distribute must contain the following notice:\n\n   \"Copyright (c) 2000- (insert then current year) OCLC Online Computer Library Center, Inc. and other contributors . All rights reserved. The contents of this file, as updated from time to time by the OCLC Office of Research, are subject to OCLC Research Public License Version 2.0 (the \"License\"); you may not use this file except in compliance with the License. You may obtain a current copy of the License at http://purl.oclc.org/oclc/research/ORPL/. Software distributed under the License is distributed on an \"AS IS\" basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the specific language governing rights and limitations under the License. This software consists of voluntary contributions made by many individuals on behalf of OCLC Research. For more information on OCLC Research, please see http://www.oclc.org/research/. The Original Code is ______________________________ . The Initial Developer of the Original Code is ________________________ . Portions created by ______________________ are Copyright (C) ____________________________ . All Rights Reserved. Contributor(s): ______________________________________ .\"\n\n   C. Requirements for a Distribution of Non-modifiable Code\n\n   If you distribute the Program in a form to which the recipient cannot make Modifications (e.g. object code), the terms of this license apply to use by recipient and you must include the following statement in appropriate and conspicuous locations:\n\n   \"Copyright (c) 2000- (insert then current year) OCLC Online Computer Library Center, Inc. and other contributors. All rights reserved.\"\n\n   In addition, the source code must be included with the object code distribution or the distributor must provide the source code to the recipient upon request.\n\n   D. Requirements for a Combined Work Distribution\n\n   Distributions of Combined Works are subject to the terms of this license and must be made at no charge to the recipient beyond the costs of physically transferring the files to recipient.\n\n   A Combined Work may be distributed as either modifiable or non-modifiable code. The requirements of Section 3.B or 3.C above (as appropriate) apply to such distributions.\n\n   An \"Aggregate Work\" is when the Program exists, without integration, with other programs on a storage medium. This License does not apply to portions of an Aggregate Work which are not covered by the definition of \"Program\" provided in this License. You are not forbidden from selling an Aggregate Work. However, the Program contained in an Aggregate Work is subject to this License. Also, should the Program be extracted from an Aggregate Work, this License applies to any use of the Program apart from the Aggregate Work.\n\n   Section 4. License Grant\n\n   For purposes of permitting use of your Modifications by OCLC and other licensees hereunder, you hereby grant to OCLC and such other licensees the non-exclusive, worldwide, royalty-free, transferable, sublicenseable license to execute, copy, alter, delete, modify, adapt, change, revise, enhance, develop, publicly display, distribute (internally and externally) and/or create derivative works based on your Modifications (and derivative works thereof) in accordance with these Terms. This Section 4 shall survive termination of this License for any reason.\n\nSection 5. Termination of Rights\n\nThis non-exclusive license (with respect to the grant from a particular Contributor) automatically terminates for any entity that initiates legal action for intellectual property infringement (with respect to the Program) against such Contributor as of the initiation of such action.\n\nIf you fail to comply with this License, your rights (but not your obligations) under this License shall terminate automatically unless you cure such breach within thirty (30) days of becoming aware of the noncompliance. All sublicenses granted by you which preexist such termination and are properly granted shall survive such termination.\n\nSection 6. Other Terms\n\nExcept for the copyright notices required above, you may not use any trademark of any of the Contributors without the prior written consent of the relevant Contributor. You agree not to remove, alter or obscure any copyright or other proprietary rights notice contained in the Program.\n\nAll transfers of the Program or any part thereof shall be made in compliance with U.S. import/export regulations or other restrictions of the U.S. Department of Commerce, as well as other similar trade or commerce restrictions which might apply.\n\nAny patent obtained by any party covering the Program or any part thereof must include a provision providing for the free, perpetual and unrestricted commercial and noncommercial use by any third party.\n\nIf, as a consequence of a court judgment or settlement relating to intellectual property infringement or any other cause of action, conditions are imposed on you that contradict the conditions of this License, such conditions do not excuse you from compliance with this License. If you cannot distribute the Program so as to simultaneously satisfy your obligations under this License and such other conditions, you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, you could not satisfy both the patent license and this License, and you would be required to refrain entirely from distribution of the Program.\n\nIf you learn of a third party claim or other restriction relating to a Program you have already distributed you shall promptly redo your Program to address the issue and take all reasonable steps to inform those who may have received the Program at issue. An example of an appropriate reasonable step to inform would be posting an announcement on an appropriate web bulletin board.\n\nThe provisions of this License are deemed to be severable, and the invalidity or unenforceability of any provision shall not affect or impair the remaining provisions which shall continue in full force and effect. In substitution for any provision held unlawful, there shall be substituted a provision of similar import reflecting the original intent of the parties hereto to the extent permissible under law.\n\nThe Original Contributor from time to time may change this License, and the amended license will apply to all copies of the Program downloaded after the new license is posted. This License grants only the rights expressly stated herein and provides you with no implied rights or licenses to the intellectual property of any Contributor.\n\nThis License is the complete and exclusive statement of the agreement between the parties concerning the subject matter hereof and may not be amended except by the written agreement of the parties. This License shall be governed by and construed in accordance with the laws of the State of Ohio and the United States of America, without regard to principles of conflicts of law."],"licenseIds":["OCLC-2.0"],"keywords":["0 terms conditions","terms conditions of","of use may","use may 2002","may 2002 copyright","copyright 2002 oclc","2002 oclc online","center inc all","document carefully by","carefully by downloading","using the code","the code base","base and or","or documentation accompanying","documentation accompanying this","license section 1","section 1 your","1 your rights","your rights subject","license the oclc","of research the","subsequent contributor collectively","contributor collectively with","collectively with the","original contributor the","contributor the contributors","exclusive worldwide no","worldwide no charge","no charge transferable","charge transferable license","to execute prepare","execute prepare derivative","works of and","of and distribute","and distribute internally","and externally for","externally for commercial","and noncommercial purposes","noncommercial purposes the","purposes the original","original code contributed","code contributed by","contributed by original","by original contributor","all modifications collectively","modifications collectively called","collectively called the","called the program","the program section","program section 2","section 2 definitions","2 definitions a","definitions a modification","a modification to","program is any","contents of any","of any file","any file of","and any new","make a modification","modification and distribute","the program externally","program externally you","externally you are","contributor the distribution","license including those","including those in","those in section","3 below a","below a combined","combined work results","results from combining","from combining and","combining and integrating","and integrating all","integrating all or","all or parts","other code a","code a combined","may be thought","be thought of","thought of as","of as having","as having multiple","having multiple parents","multiple parents or","parents or being","or being result","being result of","result of multiple","of multiple lines","multiple lines of","of code development","code development section","development section 3","section 3 distribution","3 distribution licensing","distribution licensing terms","licensing terms a","terms a general","a general requirements","general requirements except","requirements except as","except as necessary","necessary to recognize","to recognize third","recognize third party","party rights or","rights or third","or third party","party restriction see","restriction see below","see below a","below a distribution","in any of","of the forms","the forms listed","forms listed below","listed below must","below must not","must not put","not put any","put any further","granted herein as","herein as a","represent that your","that your modification","modification s are","s are your","to your modification","s you represent","represent that each","that each of","your modifications includes","modifications includes complete","third party right","party right or","right or other","or other third","party restriction associated","of your modification","your modification including","modification including a","any applicable license","applicable license agreement","be distributed without","distributed without charge","without charge beyond","recipient this warranty","this warranty disclaimer","warranty disclaimer limitation","of liability must","liability must be","be prominently displayed","prominently displayed with","displayed with every","with every distribution","every distribution of","form you agree","or implied accordingly","implied accordingly oclc","accordingly oclc makes","oclc makes no","no warranties representations","or guarantees either","guarantees either express","implied and disclaims","and disclaims all","or guarantees including","guarantees including without","particular purpose as","purpose as to","a the functionality","the functionality or","functionality or noninfringement","or noninfringement of","noninfringement of program","of program any","aggregate work or","work or b","b the results","results of any","of any project","any project undertaken","project undertaken using","undertaken using the","using the program","aggregate work in","work in no","the contributors be","special exemplary consequential","exemplary consequential or","consequential or any","program even if","damages you hereby","you hereby waive","hereby waive any","waive any claims","any claims for","claims for damages"]},{"licenseTexts":["##\n\nODC Attribution License (ODC-By) ###\n\nPreamble\n\nThe Open Data Commons Attribution License is a license agreement intended to allow users to freely share, modify, and use this Database subject only to the attribution requirements set out in Section 4.\n\nDatabases can contain a wide variety of types of content (images, audiovisual material, and sounds all in the same database, for example), and so this license only governs the rights over the Database, and not the contents of the Database individually. Licensors may therefore wish to use this license together with another license for the contents.\n\nSometimes the contents of a database, or the database itself, can be covered by other rights not addressed here (such as private contracts, trademark over the name, or privacy rights / data protection rights over information in the contents), and so you are advised that you may have to consult other documents or clear other rights before doing activities not covered by this License.\n\n------\n\nThe Licensor (as defined below)\n\nand\n\nYou (as defined below)\n\nagree as follows:\n\n   1.0 Definitions of Capitalised Words\n\n   \"Collective Database\" - Means this Database in unmodified form as part of a collection of independent databases in themselves that together are assembled into a collective whole. A work that constitutes a Collective Database will not be considered a Derivative Database.\n\n   \"Convey\" - As a verb, means Using the Database, a Derivative Database, or the Database as part of a Collective Database in any way that enables a Person to make or receive copies of the Database or a Derivative Database. Conveying does not include interaction with a user through a computer network, or creating and Using a Produced Work, where no transfer of a copy of the Database or a Derivative Database occurs.\n\n   \"Contents\" - The contents of this Database, which includes the information, independent works, or other material collected into the Database. For example, the contents of the Database could be factual data or works such as images, audiovisual material, text, or sounds.\n\n   \"Database\" - A collection of material (the Contents) arranged in a systematic or methodical way and individually accessible by electronic or other means offered under the terms of this License.\n\n   \"Database Directive\" - Means Directive 96/9/EC of the European Parliament and of the Council of 11 March 1996 on the legal protection of databases, as amended or succeeded.\n\n   \"Database Right\" - Means rights resulting from the Chapter III (\"sui generis\") rights in the Database Directive (as amended and as transposed by member states), which includes the Extraction and Re-utilisation of the whole or a Substantial part of the Contents, as well as any similar rights available in the relevant jurisdiction under Section 10.4.\n\n   \"Derivative Database\" - Means a database based upon the Database, and includes any translation, adaptation, arrangement, modification, or any other alteration of the Database or of a Substantial part of the Contents. This includes, but is not limited to, Extracting or Re-utilising the whole or a Substantial part of the Contents in a new Database.\n\n   \"Extraction\" - Means the permanent or temporary transfer of all or a Substantial part of the Contents to another medium by any means or in any form.\n\n   \"License\" - Means this license agreement and is both a license of rights such as copyright and Database Rights and an agreement in contract.\n\n   \"Licensor\" - Means the Person that offers the Database under the terms of this License.\n\n   \"Person\" - Means a natural or legal person or a body of persons corporate or incorporate.\n\n   \"Produced Work\" - a work (such as an image, audiovisual material, text, or sounds) resulting from using the whole or a Substantial part of the Contents (via a search or other query) from this Database, a Derivative Database, or this Database as part of a Collective Database.\n\n   \"Publicly\" - means to Persons other than You or under Your control by either more than 50% ownership or by the power to direct their activities (such as contracting with an independent consultant).\n\n   \"Re-utilisation\" - means any form of making available to the public all or a Substantial part of the Contents by the distribution of copies, by renting, by online or other forms of transmission.\n\n   \"Substantial\" - Means substantial in terms of quantity or quality or a combination of both. The repeated and systematic Extraction or Re-utilisation of insubstantial parts of the Contents may amount to the Extraction or Re-utilisation of a Substantial part of the Contents.\n\n   \"Use\" - As a verb, means doing any act that is restricted by copyright or Database Rights whether in the original medium or any other; and includes without limitation distributing, copying, publicly performing, publicly displaying, and preparing derivative works of the Database, as well as modifying the Database as may be technically necessary to use it in a different mode or format.\n\n   \"You\" - Means a Person exercising rights under this License who has not previously violated the terms of this License with respect to the Database, or who has received express permission from the Licensor to exercise rights under this License despite a previous violation.\n\n   Words in the singular include the plural and vice versa.\n\n   2.0 What this License covers\n\n   2.1. Legal effect of this document. This License is:\n\n      a. A license of applicable copyright and neighbouring rights;\n\n      b. A license of the Database Right; and\n\n      c. An agreement in contract between You and the Licensor.\n\n   2.2 Legal rights covered. This License covers the legal rights in the Database, including:\n\n      a. Copyright. Any copyright or neighbouring rights in the Database. The copyright licensed includes any individual elements of the Database, but does not cover the copyright over the Contents independent of this Database. See Section 2.4 for details. Copyright law varies between jurisdictions, but is likely to cover: the Database model or schema, which is the structure, arrangement, and organisation of the Database, and can also include the Database tables and table indexes; the data entry and output sheets; and the Field names of Contents stored in the Database;\n\n      b. Database Rights. Database Rights only extend to the Extraction and Re-utilisation of the whole or a Substantial part of the Contents. Database Rights can apply even when there is no copyright over the Database. Database Rights can also apply when the Contents are removed from the Database and are selected and arranged in a way that would not infringe any applicable copyright; and\n\n      c. Contract. This is an agreement between You and the Licensor for access to the Database. In return you agree to certain conditions of use on this access as outlined in this License.\n\n   2.3 Rights not covered.\n\n      a. This License does not apply to computer programs used in the making or operation of the Database;\n\n      b. This License does not cover any patents over the Contents or the Database; and\n\n      c. This License does not cover any trademarks associated with the Database.\n\n   2.4 Relationship to Contents in the Database. The individual items of the Contents contained in this Database may be covered by other rights, including copyright, patent, data protection, privacy, or personality rights, and this License does not cover any rights (other than Database Rights or in contract) in individual Contents contained in the Database. For example, if used on a Database of images (the Contents), this License would not apply to copyright over individual images, which could have their own separate licenses, or one single license covering all of the rights over the images.\n\n   3.0 Rights granted\n\n   3.1 Subject to the terms and conditions of this License, the Licensor grants to You a worldwide, royalty-free, non-exclusive, terminable (but only under Section 9) license to Use the Database for the duration of any applicable copyright and Database Rights. These rights explicitly include commercial use, and do not exclude any field of endeavour. To the extent possible in the relevant jurisdiction, these rights may be exercised in all media and formats whether now known or created in the future.\n\n   The rights granted cover, for example:\n\n      a. Extraction and Re-utilisation of the whole or a Substantial part of the Contents;\n\n      b. Creation of Derivative Databases;\n\n      c. Creation of Collective Databases;\n\n      d. Creation of temporary or permanent reproductions by any means and in any form, in whole or in part, including of any Derivative Databases or as a part of Collective Databases; and\n\n      e. Distribution, communication, display, lending, making available, or performance to the public by any means and in any form, in whole or in part, including of any Derivative Database or as a part of Collective Databases.\n\n   3.2 Compulsory license schemes. For the avoidance of doubt:\n\n      a. Non-waivable compulsory license schemes. In those jurisdictions in which the right to collect royalties through any statutory or compulsory licensing scheme cannot be waived, the Licensor reserves the exclusive right to collect such royalties for any exercise by You of the rights granted under this License;\n\n      b. Waivable compulsory license schemes. In those jurisdictions in which the right to collect royalties through any statutory or compulsory licensing scheme can be waived, the Licensor waives the exclusive right to collect such royalties for any exercise by You of the rights granted under this License; and,\n\n      c. Voluntary license schemes. The Licensor waives the right to collect royalties, whether individually or, in the event that the Licensor is a member of a collecting society that administers voluntary licensing schemes, via that society, from any exercise by You of the rights granted under this License.\n\n   3.3 The right to release the Database under different terms, or to stop distributing or making available the Database, is reserved. Note that this Database may be multiple-licensed, and so You may have the choice of using alternative licenses for this Database. Subject to Section 10.4, all other rights not expressly granted by Licensor are reserved.\n\n   4.0 Conditions of Use\n\n   4.1 The rights granted in Section 3 above are expressly made subject to Your complying with the following conditions of use. These are important conditions of this License, and if You fail to follow them, You will be in material breach of its terms.\n\n   4.2 Notices. If You Publicly Convey this Database, any Derivative Database, or the Database as part of a Collective Database, then You must:\n\n      a. Do so only under the terms of this License;\n\n      b. Include a copy of this License or its Uniform Resource Identifier (URI) with the Database or Derivative Database, including both in the Database or Derivative Database and in any relevant documentation;\n\n      c. Keep intact any copyright or Database Right notices and notices that refer to this License; and\n\n      d. If it is not possible to put the required notices in a particular file due to its structure, then You must include the notices in a location (such as a relevant directory) where users would be likely to look for it.\n\n   4.3 Notice for using output (Contents). Creating and Using a Produced Work does not require the notice in Section 4.2. However, if you Publicly Use a Produced Work, You must include a notice associated with the Produced Work reasonably calculated to make any Person that uses, views, accesses, interacts with, or is otherwise exposed to the Produced Work aware that Content was obtained from the Database, Derivative Database, or the Database as part of a Collective Database, and that it is available under this License.\n\n      a. Example notice. The following text will satisfy notice under Section 4.3:\n\n      Contains information from DATABASE NAME which is made available under the ODC Attribution License.\n\n      DATABASE NAME should be replaced with the name of the Database and a hyperlink to the location of the Database. \"ODC Attribution License\" should contain a hyperlink to the URI of the text of this License. If hyperlinks are not possible, You should include the plain text of the required URI's with the above notice.\n\n   4.4 Licensing of others. You may not sublicense the Database. Each time You communicate the Database, the whole or Substantial part of the Contents, or any Derivative Database to anyone else in any way, the Licensor offers to the recipient a license to the Database on the same terms and conditions as this License. You are not responsible for enforcing compliance by third parties with this License, but You may enforce any rights that You have over a Derivative Database. You are solely responsible for any modifications of a Derivative Database made by You or another Person at Your direction. You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License.\n\n   5.0 Moral rights\n\n   5.1 Moral rights. This section covers moral rights, including any rights to be identified as the author of the Database or to object to treatment that would otherwise prejudice the author's honour and reputation, or any other derogatory treatment:\n\n      a. For jurisdictions allowing waiver of moral rights, Licensor waives all moral rights that Licensor may have in the Database to the fullest extent possible by the law of the relevant jurisdiction under Section 10.4;\n\n      b. If waiver of moral rights under Section 5.1 a in the relevant jurisdiction is not possible, Licensor agrees not to assert any moral rights over the Database and waives all claims in moral rights to the fullest extent possible by the law of the relevant jurisdiction under Section 10.4; and\n\n      c. For jurisdictions not allowing waiver or an agreement not to assert moral rights under Section 5.1 a and b, the author may retain their moral rights over certain aspects of the Database.\n\n      Please note that some jurisdictions do not allow for the waiver of moral rights, and so moral rights may still subsist over the Database in some jurisdictions.\n\n   6.0 Fair dealing, Database exceptions, and other rights not affected\n\n   6.1 This License does not affect any rights that You or anyone else may independently have under any applicable law to make any use of this Database, including without limitation:\n\n      a. Exceptions to the Database Right including: Extraction of Contents from non-electronic Databases for private purposes, Extraction for purposes of illustration for teaching or scientific research, and Extraction or Re-utilisation for public security or an administrative or judicial procedure.\n\n      b. Fair dealing, fair use, or any other legally recognised limitation or exception to infringement of copyright or other applicable laws.\n\n   6.2 This License does not affect any rights of lawful users to Extract and Re-utilise insubstantial parts of the Contents, evaluated quantitatively or qualitatively, for any purposes whatsoever, including creating a Derivative Database (subject to other rights over the Contents, see Section 2.4). The repeated and systematic Extraction or Re-utilisation of insubstantial parts of the Contents may however amount to the Extraction or Re-utilisation of a Substantial part of the Contents.\n\n   7.0 Warranties and Disclaimer\n\n   7.1 The Database is licensed by the Licensor \"as is\" and without any warranty of any kind, either express, implied, or arising by statute, custom, course of dealing, or trade usage. Licensor specifically disclaims any and all implied warranties or conditions of title, non-infringement, accuracy or completeness, the presence or absence of errors, fitness for a particular purpose, merchantability, or otherwise. Some jurisdictions do not allow the exclusion of implied warranties, so this exclusion may not apply to You.\n\n   8.0 Limitation of liability\n\n   8.1 Subject to any liability that may not be excluded or limited by law, the Licensor is not liable for, and expressly excludes, all liability for loss or damage however and whenever caused to anyone by any use under this License, whether by You or by anyone else, and whether caused by any fault on the part of the Licensor or not. This exclusion of liability includes, but is not limited to, any special, incidental, consequential, punitive, or exemplary damages such as loss of revenue, data, anticipated profits, and lost business. This exclusion applies even if the Licensor has been advised of the possibility of such damages.\n\n   8.2 If liability may not be excluded by law, it is limited to actual and direct financial loss to the extent it is caused by proved negligence on the part of the Licensor.\n\n   9.0 Termination of Your rights under this License\n\n   9.1 Any breach by You of the terms and conditions of this License automatically terminates this License with immediate effect and without notice to You. For the avoidance of doubt, Persons who have received the Database, the whole or a Substantial part of the Contents, Derivative Databases, or the Database as part of a Collective Database from You under this License will not have their licenses terminated provided their use is in full compliance with this License or a license granted under Section 4.8 of this License. Sections 1, 2, 7, 8, 9 and 10 will survive any termination of this License.\n\n   9.2 If You are not in breach of the terms of this License, the Licensor will not terminate Your rights under it.\n\n   9.3 Unless terminated under Section 9.1, this License is granted to You for the duration of applicable rights in the Database.\n\n   9.4 Reinstatement of rights. If you cease any breach of the terms and conditions of this License, then your full rights under this License will be reinstated:\n\n      a. Provisionally and subject to permanent termination until the 60th day after cessation of breach;\n\n      b. Permanently on the 60th day after cessation of breach unless otherwise reasonably notified by the Licensor; or\n\n      c. Permanently if reasonably notified by the Licensor of the violation, this is the first time You have received notice of violation of this License from the Licensor, and You cure the violation prior to 30 days after your receipt of the notice.\n\n   9.5 Notwithstanding the above, Licensor reserves the right to release the Database under different license terms or to stop distributing or making available the Database. Releasing the Database under different license terms or stopping the distribution of the Database will not withdraw this License (or any other license that has been, or is required to be, granted under the terms of this License), and this License will continue in full force and effect unless terminated as stated above.\n\n   10.0 General\n\n   10.1 If any provision of this License is held to be invalid or unenforceable, that must not affect the validity or enforceability of the remainder of the terms and conditions of this License and each remaining provision of this License shall be valid and enforced to the fullest extent permitted by law.\n\n   10.2 This License is the entire agreement between the parties with respect to the rights granted here over the Database. It replaces any earlier understandings, agreements or representations with respect to the Database.\n\n   10.3 If You are in breach of the terms of this License, You will not be entitled to rely on the terms of this License or to complain of any breach by the Licensor.\n\n   10.4 Choice of law. This License takes effect in and will be governed by the laws of the relevant jurisdiction in which the License terms are sought to be enforced. If the standard suite of rights granted under applicable copyright law and Database Rights in the relevant jurisdiction includes additional rights not granted under this License, these additional rights are granted in this License in order to meet the terms of this License."],"licenseIds":["ODC-By-1.0"],"keywords":["attribution license odc","license odc by","odc by preamble","by preamble the","attribution license is","database subject only","the attribution requirements","attribution requirements set","section 4 databases","4 databases can","and so this","so this license","license only governs","individually licensors may","licensors may therefore","may therefore wish","therefore wish to","wish to use","this license together","license together with","the contents sometimes","contents sometimes the","private contracts trademark","contracts trademark over","trademark over the","license or its","relevant documentation c","documentation c keep","license and d","under the odc","the odc attribution","attribution license database","license database name","the database odc","database odc attribution","attribution license should","4 4 licensing","4 licensing of","the notice 9","notice 9 5","odc attribution license odc","attribution license odc by","license odc by preamble","odc by preamble the","by preamble the open","commons attribution license is","attribution license is a","license is a license","use this database subject","this database subject only","database subject only to","only to the attribution","to the attribution requirements","the attribution requirements set","attribution requirements set out","out in section 4","in section 4 databases","section 4 databases can","4 databases can contain","example and so this","and so this license","so this license only","this license only governs","license only governs the","database individually licensors may","individually licensors may therefore","licensors may therefore wish","may therefore wish to","therefore wish to use","wish to use this","use this license together","this license together with","license together with another","for the contents sometimes","the contents sometimes the","contents sometimes the contents","as private contracts trademark","private contracts trademark over","contracts trademark over the","trademark over the name","this license or its","license or its uniform","any relevant documentation c","relevant documentation c keep","documentation c keep intact","this license and d","license and d if","and d if it","available under the odc","under the odc attribution","the odc attribution license","odc attribution license database","attribution license database name","license database name should","hyperlink to the location","location of the database","of the database odc","the database odc attribution","database odc attribution license","odc attribution license should","attribution license should contain","notice 4 4 licensing","4 4 licensing of","4 licensing of others","of the notice 9","the notice 9 5","notice 9 5 notwithstanding","odc attribution license odc by","attribution license odc by preamble","license odc by preamble the","odc by preamble the open","by preamble the open data","data commons attribution license is","commons attribution license is a","attribution license is a license","license is a license agreement","and use this database subject","use this database subject only","this database subject only to","database subject only to the","subject only to the attribution","only to the attribution requirements","to the attribution requirements set","the attribution requirements set out","attribution requirements set out in","requirements set out in section","set out in section 4","out in section 4 databases","in section 4 databases can","section 4 databases can contain","4 databases can contain a","for example and so this","example and so this license","and so this license only","so this license only governs","this license only governs the","license only governs the rights","the database individually licensors may","database individually licensors may therefore","individually licensors may therefore wish","licensors may therefore wish to","may therefore wish to use","therefore wish to use this","wish to use this license","to use this license together","use this license together with","this license together with another","license together with another license","license for the contents sometimes","for the contents sometimes the","the contents sometimes the contents","contents sometimes the contents of","such as private contracts trademark","as private contracts trademark over","private contracts trademark over the","contracts trademark over the name","trademark over the name or","of this license b include","of this license or its","this license or its uniform","license or its uniform resource","in any relevant documentation c","any relevant documentation c keep","relevant documentation c keep intact","documentation c keep intact any","to this license and d","this license and d if","license and d if it","and d if it is","which is made available under","made available under the odc","available under the odc attribution","under the odc attribution license","the odc attribution license database","odc attribution license database name","attribution license database name should","license database name should be","a hyperlink to the location","hyperlink to the location of","to the location of the","the location of the database","location of the database odc","of the database odc attribution","the database odc attribution license","database odc attribution license should","odc attribution license should contain","attribution license should contain a","above notice 4 4 licensing","notice 4 4 licensing of","4 4 licensing of others","4 licensing of others you","receipt of the notice 9","of the notice 9 5","the notice 9 5 notwithstanding","notice 9 5 notwithstanding the"]},{"licenseTexts":["ODC Open Database License (ODbL) Preamble\n\nThe Open Database License (ODbL) is a license agreement intended to allow users to freely share, modify, and use this Database while maintaining this same freedom for others. Many databases are covered by copyright, and therefore this document licenses these rights. Some jurisdictions, mainly in the European Union, have specific rights that cover databases, and so the ODbL addresses these rights, too. Finally, the ODbL is also an agreement in contract for users of this Database to act in certain ways in return for accessing this Database.\n\nDatabases can contain a wide variety of types of content (images, audiovisual material, and sounds all in the same database, for example), and so the ODbL only governs the rights over the Database, and not the contents of the Database individually. Licensors should use the ODbL together with another license for the contents, if the contents have a single set of rights that uniformly covers all of the contents. If the contents have multiple sets of different rights, Licensors should describe what rights govern what contents together in the individual record or in some other way that clarifies what rights apply.\n\nSometimes the contents of a database, or the database itself, can be covered by other rights not addressed here (such as private contracts, trade mark over the name, or privacy rights / data protection rights over information in the contents), and so you are advised that you may have to consult other documents or clear other rights before doing activities not covered by this License.\n\n------\n\nThe Licensor (as defined below)\n\nand\n\nYou (as defined below)\n\nagree as follows:\n\n   1.0 Definitions of Capitalised Words\n\n   \"Collective Database\" - Means this Database in unmodified form as part of a collection of independent databases in themselves that together are assembled into a collective whole. A work that constitutes a Collective Database will not be considered a Derivative Database.\n\n   \"Convey\" - As a verb, means Using the Database, a Derivative Database, or the Database as part of a Collective Database in any way that enables a Person to make or receive copies of the Database or a Derivative Database. Conveying does not include interaction with a user through a computer network, or creating and Using a Produced Work, where no transfer of a copy of the Database or a Derivative Database occurs.\n\n   \"Contents\" - The contents of this Database, which includes the information, independent works, or other material collected into the Database. For example, the contents of the Database could be factual data or works such as images, audiovisual material, text, or sounds.\n\n   \"Database\" - A collection of material (the Contents) arranged in a systematic or methodical way and individually accessible by electronic or other means offered under the terms of this License.\n\n   \"Database Directive\" - Means Directive 96/9/EC of the European Parliament and of the Council of 11 March 1996 on the legal protection of databases, as amended or succeeded.\n\n   \"Database Right\" - Means rights resulting from the Chapter III (\"sui generis\") rights in the Database Directive (as amended and as transposed by member states), which includes the Extraction and Re-utilisation of the whole or a Substantial part of the Contents, as well as any similar rights available in the relevant jurisdiction under Section 10.4.\n\n   \"Derivative Database\" - Means a database based upon the Database, and includes any translation, adaptation, arrangement, modification, or any other alteration of the Database or of a Substantial part of the Contents. This includes, but is not limited to, Extracting or Re-utilising the whole or a Substantial part of the Contents in a new Database.\n\n   \"Extraction\" - Means the permanent or temporary transfer of all or a Substantial part of the Contents to another medium by any means or in any form.\n\n   \"License\" - Means this license agreement and is both a license of rights such as copyright and Database Rights and an agreement in contract.\n\n   \"Licensor\" - Means the Person that offers the Database under the terms of this License.\n\n   \"Person\" - Means a natural or legal person or a body of persons corporate or incorporate.\n\n   \"Produced Work\" - a work (such as an image, audiovisual material, text, or sounds) resulting from using the whole or a Substantial part of the Contents (via a search or other query) from this Database, a Derivative Database, or this Database as part of a Collective Database.\n\n   \"Publicly\" - means to Persons other than You or under Your control by either more than 50% ownership or by the power to direct their activities (such as contracting with an independent consultant).\n\n   \"Re-utilisation\" - means any form of making available to the public all or a Substantial part of the Contents by the distribution of copies, by renting, by online or other forms of transmission.\n\n   \"Substantial\" - Means substantial in terms of quantity or quality or a combination of both. The repeated and systematic Extraction or Re-utilisation of insubstantial parts of the Contents may amount to the Extraction or Re-utilisation of a Substantial part of the Contents.\n\n   \"Use\" - As a verb, means doing any act that is restricted by copyright or Database Rights whether in the original medium or any other; and includes without limitation distributing, copying, publicly performing, publicly displaying, and preparing derivative works of the Database, as well as modifying the Database as may be technically necessary to use it in a different mode or format.\n\n   \"You\" - Means a Person exercising rights under this License who has not previously violated the terms of this License with respect to the Database, or who has received express permission from the Licensor to exercise rights under this License despite a previous violation.\n\n   Words in the singular include the plural and vice versa.\n\n   2.0 What this License covers\n\n   2.1. Legal effect of this document. This License is:\n\n      a. A license of applicable copyright and neighbouring rights;\n\n      b. A license of the Database Right; and\n\n      c. An agreement in contract between You and the Licensor.\n\n   2.2 Legal rights covered. This License covers the legal rights in the Database, including:\n\n      a. Copyright. Any copyright or neighbouring rights in the Database. The copyright licensed includes any individual elements of the Database, but does not cover the copyright over the Contents independent of this Database. See Section 2.4 for details. Copyright law varies between jurisdictions, but is likely to cover: the Database model or schema, which is the structure, arrangement, and organisation of the Database, and can also include the Database tables and table indexes; the data entry and output sheets; and the Field names of Contents stored in the Database;\n\n      b. Database Rights. Database Rights only extend to the Extraction and Re-utilisation of the whole or a Substantial part of the Contents. Database Rights can apply even when there is no copyright over the Database. Database Rights can also apply when the Contents are removed from the Database and are selected and arranged in a way that would not infringe any applicable copyright; and\n\n      c. Contract. This is an agreement between You and the Licensor for access to the Database. In return you agree to certain conditions of use on this access as outlined in this License.\n\n   2.3 Rights not covered.\n\n      a. This License does not apply to computer programs used in the making or operation of the Database;\n\n      b. This License does not cover any patents over the Contents or the Database; and\n\n      c. This License does not cover any trademarks associated with the Database.\n\n   2.4 Relationship to Contents in the Database. The individual items of the Contents contained in this Database may be covered by other rights, including copyright, patent, data protection, privacy, or personality rights, and this License does not cover any rights (other than Database Rights or in contract) in individual Contents contained in the Database. For example, if used on a Database of images (the Contents), this License would not apply to copyright over individual images, which could have their own separate licenses, or one single license covering all of the rights over the images.\n\n   3.0 Rights granted\n\n   3.1 Subject to the terms and conditions of this License, the Licensor grants to You a worldwide, royalty-free, non-exclusive, terminable (but only under Section 9) license to Use the Database for the duration of any applicable copyright and Database Rights. These rights explicitly include commercial use, and do not exclude any field of endeavour. To the extent possible in the relevant jurisdiction, these rights may be exercised in all media and formats whether now known or created in the future.\n\n   The rights granted cover, for example:\n\n      a. Extraction and Re-utilisation of the whole or a Substantial part of the Contents;\n\n      b. Creation of Derivative Databases;\n\n      c. Creation of Collective Databases;\n\n      d. Creation of temporary or permanent reproductions by any means and in any form, in whole or in part, including of any Derivative Databases or as a part of Collective Databases; and\n\n      e. Distribution, communication, display, lending, making available, or performance to the public by any means and in any form, in whole or in part, including of any Derivative Database or as a part of Collective Databases.\n\n   3.2 Compulsory license schemes. For the avoidance of doubt:\n\n      a. Non-waivable compulsory license schemes. In those jurisdictions in which the right to collect royalties through any statutory or compulsory licensing scheme cannot be waived, the Licensor reserves the exclusive right to collect such royalties for any exercise by You of the rights granted under this License;\n\n      b. Waivable compulsory license schemes. In those jurisdictions in which the right to collect royalties through any statutory or compulsory licensing scheme can be waived, the Licensor waives the exclusive right to collect such royalties for any exercise by You of the rights granted under this License; and,\n\n      c. Voluntary license schemes. The Licensor waives the right to collect royalties, whether individually or, in the event that the Licensor is a member of a collecting society that administers voluntary licensing schemes, via that society, from any exercise by You of the rights granted under this License.\n\n   3.3 The right to release the Database under different terms, or to stop distributing or making available the Database, is reserved. Note that this Database may be multiple-licensed, and so You may have the choice of using alternative licenses for this Database. Subject to Section 10.4, all other rights not expressly granted by Licensor are reserved.\n\n   4.0 Conditions of Use\n\n   4.1 The rights granted in Section 3 above are expressly made subject to Your complying with the following conditions of use. These are important conditions of this License, and if You fail to follow them, You will be in material breach of its terms.\n\n   4.2 Notices. If You Publicly Convey this Database, any Derivative Database, or the Database as part of a Collective Database, then You must:\n\n      a. Do so only under the terms of this License or another license permitted under Section 4.4;\n\n      b. Include a copy of this License (or, as applicable, a license permitted under Section 4.4) or its Uniform Resource Identifier (URI) with the Database or Derivative Database, including both in the Database or Derivative Database and in any relevant documentation; and\n\n      c. Keep intact any copyright or Database Right notices and notices that refer to this License.\n\n      d. If it is not possible to put the required notices in a particular file due to its structure, then You must include the notices in a location (such as a relevant directory) where users would be likely to look for it.\n\n   4.3 Notice for using output (Contents). Creating and Using a Produced Work does not require the notice in Section 4.2. However, if you Publicly Use a Produced Work, You must include a notice associated with the Produced Work reasonably calculated to make any Person that uses, views, accesses, interacts with, or is otherwise exposed to the Produced Work aware that Content was obtained from the Database, Derivative Database, or the Database as part of a Collective Database, and that it is available under this License.\n\n      a. Example notice. The following text will satisfy notice under Section 4.3:\n\n      Contains information from DATABASE NAME, which is made available here under the Open Database License (ODbL).\n\n      DATABASE NAME should be replaced with the name of the Database and a hyperlink to the URI of the Database. \"Open Database License\" should contain a hyperlink to the URI of the text of this License. If hyperlinks are not possible, You should include the plain text of the required URI's with the above notice.\n\n   4.4 Share alike.\n\n      a. Any Derivative Database that You Publicly Use must be only under the terms of:\n\n         i. This License;\n\n         ii. A later version of this License similar in spirit to this License; or\n\n         iii. A compatible license.\n\n         If You license the Derivative Database under one of the licenses mentioned in (iii), You must comply with the terms of that license.\n\n      b. For the avoidance of doubt, Extraction or Re-utilisation of the whole or a Substantial part of the Contents into a new database is a Derivative Database and must comply with Section 4.4.\n\n      c. Derivative Databases and Produced Works. A Derivative Database is Publicly Used and so must comply with Section 4.4. if a Produced Work created from the Derivative Database is Publicly Used.\n\n      d. Share Alike and additional Contents. For the avoidance of doubt, You must not add Contents to Derivative Databases under Section 4.4 a that are incompatible with the rights granted under this License.\n\n      e. Compatible licenses. Licensors may authorise a proxy to determine compatible licenses under Section 4.4 a iii. If they do so, the authorised proxy's public statement of acceptance of a compatible license grants You permission to use the compatible license.\n\n   4.5 Limits of Share Alike. The requirements of Section 4.4 do not apply in the following:\n\n      a. For the avoidance of doubt, You are not required to license Collective Databases under this License if You incorporate this Database or a Derivative Database in the collection, but this License still applies to this Database or a Derivative Database as a part of the Collective Database;\n\n      b. Using this Database, a Derivative Database, or this Database as part of a Collective Database to create a Produced Work does not create a Derivative Database for purposes of Section 4.4; and\n\n      c. Use of a Derivative Database internally within an organisation is not to the public and therefore does not fall under the requirements of Section 4.4.\n\n   4.6 Access to Derivative Databases. If You Publicly Use a Derivative Database or a Produced Work from a Derivative Database, You must also offer to recipients of the Derivative Database or Produced Work a copy in a machine readable form of:\n\n      a. The entire Derivative Database; or\n\n      b. A file containing all of the alterations made to the Database or the method of making the alterations to the Database (such as an algorithm), including any additional Contents, that make up all the differences between the Database and the Derivative Database.\n\n      The Derivative Database (under a.) or alteration file (under b.) must be available at no more than a reasonable production cost for physical distributions and free of charge if distributed over the internet.\n\n   4.7 Technological measures and additional terms\n\n      a. This License does not allow You to impose (except subject to Section 4.7 b.) any terms or any technological measures on the Database, a Derivative Database, or the whole or a Substantial part of the Contents that alter or restrict the terms of this License, or any rights granted under it, or have the effect or intent of restricting the ability of any person to exercise those rights.\n\n      b. Parallel distribution. You may impose terms or technological measures on the Database, a Derivative Database, or the whole or a Substantial part of the Contents (a \"Restricted Database\") in contravention of Section 4.74 a. only if You also make a copy of the Database or a Derivative Database available to the recipient of the Restricted Database:\n\n         i. That is available without additional fee;\n\n         ii. That is available in a medium that does not alter or restrict the terms of this License, or any rights granted under it, or have the effect or intent of restricting the ability of any person to exercise those rights (an \"Unrestricted Database\"); and\n\n         iii. The Unrestricted Database is at least as accessible to the recipient as a practical matter as the Restricted Database.\n\n      c. For the avoidance of doubt, You may place this Database or a Derivative Database in an authenticated environment, behind a password, or within a similar access control scheme provided that You do not alter or restrict the terms of this License or any rights granted under it or have the effect or intent of restricting the ability of any person to exercise those rights.\n\n   4.8 Licensing of others. You may not sublicense the Database. Each time You communicate the Database, the whole or Substantial part of the Contents, or any Derivative Database to anyone else in any way, the Licensor offers to the recipient a license to the Database on the same terms and conditions as this License. You are not responsible for enforcing compliance by third parties with this License, but You may enforce any rights that You have over a Derivative Database. You are solely responsible for any modifications of a Derivative Database made by You or another Person at Your direction. You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License.\n\n   5.0 Moral rights\n\n   5.1 Moral rights. This section covers moral rights, including any rights to be identified as the author of the Database or to object to treatment that would otherwise prejudice the author's honour and reputation, or any other derogatory treatment:\n\n      a. For jurisdictions allowing waiver of moral rights, Licensor waives all moral rights that Licensor may have in the Database to the fullest extent possible by the law of the relevant jurisdiction under Section 10.4;\n\n      b. If waiver of moral rights under Section 5.1 a in the relevant jurisdiction is not possible, Licensor agrees not to assert any moral rights over the Database and waives all claims in moral rights to the fullest extent possible by the law of the relevant jurisdiction under Section 10.4; and\n\n      c. For jurisdictions not allowing waiver or an agreement not to assert moral rights under Section 5.1 a and b, the author may retain their moral rights over certain aspects of the Database.\n\n      Please note that some jurisdictions do not allow for the waiver of moral rights, and so moral rights may still subsist over the Database in some jurisdictions.\n\n   6.0 Fair dealing, Database exceptions, and other rights not affected\n\n   6.1 This License does not affect any rights that You or anyone else may independently have under any applicable law to make any use of this Database, including without limitation:\n\n      a. Exceptions to the Database Right including: Extraction of Contents from non-electronic Databases for private purposes, Extraction for purposes of illustration for teaching or scientific research, and Extraction or Re-utilisation for public security or an administrative or judicial procedure.\n\n      b. Fair dealing, fair use, or any other legally recognised limitation or exception to infringement of copyright or other applicable laws.\n\n   6.2 This License does not affect any rights of lawful users to Extract and Re-utilise insubstantial parts of the Contents, evaluated quantitatively or qualitatively, for any purposes whatsoever, including creating a Derivative Database (subject to other rights over the Contents, see Section 2.4). The repeated and systematic Extraction or Re-utilisation of insubstantial parts of the Contents may however amount to the Extraction or Re-utilisation of a Substantial part of the Contents.\n\n   7.0 Warranties and Disclaimer\n\n   7.1 The Database is licensed by the Licensor \"as is\" and without any warranty of any kind, either express, implied, or arising by statute, custom, course of dealing, or trade usage. Licensor specifically disclaims any and all implied warranties or conditions of title, non-infringement, accuracy or completeness, the presence or absence of errors, fitness for a particular purpose, merchantability, or otherwise. Some jurisdictions do not allow the exclusion of implied warranties, so this exclusion may not apply to You.\n\n   8.0 Limitation of liability\n\n   8.1 Subject to any liability that may not be excluded or limited by law, the Licensor is not liable for, and expressly excludes, all liability for loss or damage however and whenever caused to anyone by any use under this License, whether by You or by anyone else, and whether caused by any fault on the part of the Licensor or not. This exclusion of liability includes, but is not limited to, any special, incidental, consequential, punitive, or exemplary damages such as loss of revenue, data, anticipated profits, and lost business. This exclusion applies even if the Licensor has been advised of the possibility of such damages.\n\n   8.2 If liability may not be excluded by law, it is limited to actual and direct financial loss to the extent it is caused by proved negligence on the part of the Licensor.\n\n   9.0 Termination of Your rights under this License\n\n   9.1 Any breach by You of the terms and conditions of this License automatically terminates this License with immediate effect and without notice to You. For the avoidance of doubt, Persons who have received the Database, the whole or a Substantial part of the Contents, Derivative Databases, or the Database as part of a Collective Database from You under this License will not have their licenses terminated provided their use is in full compliance with this License or a license granted under Section 4.8 of this License. Sections 1, 2, 7, 8, 9 and 10 will survive any termination of this License.\n\n   9.2 If You are not in breach of the terms of this License, the Licensor will not terminate Your rights under it.\n\n   9.3 Unless terminated under Section 9.1, this License is granted to You for the duration of applicable rights in the Database.\n\n   9.4 Reinstatement of rights. If you cease any breach of the terms and conditions of this License, then your full rights under this License will be reinstated:\n\n      a. Provisionally and subject to permanent termination until the 60th day after cessation of breach;\n\n      b. Permanently on the 60th day after cessation of breach unless otherwise reasonably notified by the Licensor; or\n\n      c. Permanently if reasonably notified by the Licensor of the violation, this is the first time You have received notice of violation of this License from the Licensor, and You cure the violation prior to 30 days after your receipt of the notice.\n\n      Persons subject to permanent termination of rights are not eligible to be a recipient and receive a license under Section 4.8.\n\n   9.5 Notwithstanding the above, Licensor reserves the right to release the Database under different license terms or to stop distributing or making available the Database. Releasing the Database under different license terms or stopping the distribution of the Database will not withdraw this License (or any other license that has been, or is required to be, granted under the terms of this License), and this License will continue in full force and effect unless terminated as stated above.\n\n   10.0 General\n\n   10.1 If any provision of this License is held to be invalid or unenforceable, that must not affect the validity or enforceability of the remainder of the terms and conditions of this License and each remaining provision of this License shall be valid and enforced to the fullest extent permitted by law.\n\n   10.2 This License is the entire agreement between the parties with respect to the rights granted here over the Database. It replaces any earlier understandings, agreements or representations with respect to the Database.\n\n   10.3 If You are in breach of the terms of this License, You will not be entitled to rely on the terms of this License or to complain of any breach by the Licensor.\n\n   10.4 Choice of law. This License takes effect in and will be governed by the laws of the relevant jurisdiction in which the License terms are sought to be enforced. If the standard suite of rights granted under applicable copyright law and Database Rights in the relevant jurisdiction includes additional rights not granted under this License, these additional rights are granted in this License in order to meet the terms of this License."],"licenseIds":["ODbL-1.0"],"keywords":["odc open database","license odbl preamble","odbl preamble the","license odbl is","odbl is a","this database while","database while maintaining","while maintaining this","maintaining this same","this same freedom","same freedom for","freedom for others","for others many","others many databases","copyright and therefore","and therefore this","therefore this document","this document licenses","document licenses these","licenses these rights","these rights some","rights some jurisdictions","mainly in the","in the european","european union have","union have specific","have specific rights","specific rights that","cover databases and","databases and so","the odbl addresses","odbl addresses these","addresses these rights","these rights too","rights too finally","too finally the","finally the odbl","the odbl is","odbl is also","is also an","also an agreement","in contract for","contract for users","for users of","this database to","database to act","act in certain","in certain ways","certain ways in","ways in return","return for accessing","for accessing this","accessing this database","this database databases","database databases can","the odbl only","odbl only governs","individually licensors should","licensors should use","use the odbl","the odbl together","odbl together with","contents have a","have a single","a single set","single set of","set of rights","rights that uniformly","that uniformly covers","uniformly covers all","covers all of","contents have multiple","have multiple sets","multiple sets of","sets of different","of different rights","different rights licensors","rights licensors should","licensors should describe","should describe what","describe what rights","what rights govern","rights govern what","govern what contents","what contents together","contents together in","together in the","the individual record","individual record or","record or in","some other way","other way that","way that clarifies","that clarifies what","clarifies what rights","what rights apply","rights apply sometimes","apply sometimes the","private contracts trade","contracts trade mark","trade mark over","mark over the","another license permitted","4 4 b","4 b include","or as applicable","as applicable a","applicable a license","a license permitted","4 4 or","4 or its","relevant documentation and","and c keep","made available here","available here under","here under the","license odbl database","odbl database name","the database open","database open database","database license should","4 4 share","4 share alike","share alike a","alike a any","a any derivative","derivative database that","database that you","that you publicly","publicly use must","use must be","must be only","be only under","this license similar","license similar in","spirit to this","license or iii","or iii a","iii a compatible","license the derivative","database under one","mentioned in iii","in iii you","that license b","license b for","of doubt extraction","doubt extraction or","the contents into","contents into a","into a new","new database is","database is a","database and must","and must comply","4 4 c","4 c derivative","c derivative databases","derivative databases and","databases and produced","and produced works","produced works a","works a derivative","publicly used and","used and so","and so must","so must comply","4 4 if","4 if a","if a produced","produced work created","work created from","publicly used d","used d share","d share alike","share alike and","alike and additional","and additional contents","additional contents for","contents for the","doubt you must","must not add","not add contents","add contents to","contents to derivative","derivative databases under","databases under section","4 a that","a that are","that are incompatible","license e compatible","e compatible licenses","compatible licenses licensors","licenses licensors may","licensors may authorise","may authorise a","authorise a proxy","a proxy to","proxy to determine","to determine compatible","determine compatible licenses"]},{"licenseTexts":["SIL OPEN FONT LICENSE\n\nVersion 1.0 - 22 November 2005\n\nPREAMBLE\n\nThe goals of the Open Font License (OFL) are to stimulate worldwide development of cooperative font projects, to support the font creation efforts of academic and linguistic communities, and to provide an open framework in which fonts may be shared and improved in partnership with others.\n\nThe OFL allows the licensed fonts to be used, studied, modified and redistributed freely as long as they are not sold by themselves. The fonts, including any derivative works, can be bundled, embedded, redistributed and sold with any software provided that the font names of derivative works are changed. The fonts and derivatives, however, cannot be released under any other type of license.\n\nDEFINITIONS\n\n\"Font Software\" refers to any and all of the following:\n\n   - font files\n\n   - data files\n\n   - source code\n\n   - build scripts\n\n   - documentation\n\n\"Reserved Font Name\" refers to the Font Software name as seen by users and any other names as specified after the copyright statement.\n\n\"Standard Version\" refers to the collection of Font Software components as distributed by the Copyright Holder.\n\n\"Modified Version\" refers to any derivative font software made by adding to, deleting, or substituting — in part or in whole -- any of the components of the Standard Version, by changing formats or by porting the Font Software to a new environment.\n\n\"Author\" refers to any designer, engineer, programmer, technical writer or other person who contributed to the Font Software.\n\nPERMISSION \u0026 CONDITIONS\n\nPermission is hereby granted, free of charge, to any person obtaining a copy of the Font Software, to use, study, copy, merge, embed, modify, redistribute, and sell modified and unmodified copies of the Font Software, subject to the following conditions:\n\n   1) Neither the Font Software nor any of its individual components, in Standard or Modified Versions, may be sold by itself.\n\n   2) Standard or Modified Versions of the Font Software may be bundled, redistributed and sold with any software, provided that each copy contains the above copyright notice and this license. These can be included either as stand-alone text files, human-readable headers or in the appropriate machine-readable metadata fields within text or binary files as long as those fields can be easily viewed by the user.\n\n   3) No Modified Version of the Font Software may use the Reserved Font Name(s), in part or in whole, unless explicit written permission is granted by the Copyright Holder. This restriction applies to all references stored in the Font Software, such as the font menu name and other font description fields, which are used to differentiate the font from others.\n\n   4) The name(s) of the Copyright Holder or the Author(s) of the Font Software shall not be used to promote, endorse or advertise any Modified Version, except to acknowledge the contribution(s) of the Copyright Holder and the Author(s) or with their explicit written permission.\n\n   5) The Font Software, modified or unmodified, in part or in whole, must be distributed using this license, and may not be distributed under any other license.\n\nTERMINATION\n\nThis license becomes null and void if any of the above conditions are not met.\n\nDISCLAIMER\n\nTHE FONT SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER DEALINGS IN THE FONT SOFTWARE."],"licenseIds":["OFL-1.0-no-RFN","OFL-1.0-RFN","OFL-1.0"],"keywords":["1 0 22","0 22 november","22 november 2005","november 2005 preamble","2005 preamble the","development of cooperative","of cooperative font","cooperative font projects","to provide an","provide an open","an open framework","that the font","the font names","font names of","names of derivative","works are changed","are changed the","changed the fonts","of license definitions","license definitions font","to any and","the following font","following font files","font files data","data files source","files source code","build scripts documentation","scripts documentation reserved","font software name","software name as","name as seen","as seen by","seen by users","by users and","users and any","any other names","other names as","names as specified","as specified after","specified after the","copyright statement standard","statement standard version","any derivative font","derivative font software","font software made","standard version by","components in standard","in standard or","itself 2 standard","2 standard or","name s in","s in part","in whole unless","whole unless explicit","this restriction applies","restriction applies to","to all references","all references stored","references stored in","font software such","as the font","the font menu","font menu name","menu name and","name and other","and other font","other font description","font description fields","description fields which","fields which are","are used to","used to differentiate","to differentiate the","differentiate the font","the font from","font from others","from others 4","others 4 the","holder or the","holder and the","be distributed using","distributed using this","other license termination","license termination this","version 1 0 22","1 0 22 november","0 22 november 2005","22 november 2005 preamble","november 2005 preamble the","2005 preamble the goals","worldwide development of cooperative","development of cooperative font","of cooperative font projects","cooperative font projects to","and to provide an","to provide an open","provide an open framework","an open framework in","embedded redistributed and sold","software provided that the","provided that the font","that the font names","the font names of","font names of derivative","names of derivative works","of derivative works are","derivative works are changed","works are changed the","are changed the fonts","changed the fonts and","type of license definitions","of license definitions font","license definitions font software","software refers to any","refers to any and","to any and all","of the following font","the following font files","following font files data","font files data files","files data files source","data files source code","files source code build","code build scripts documentation","build scripts documentation reserved","scripts documentation reserved font","name refers to the","refers to the font","the font software name","font software name as","software name as seen","name as seen by","as seen by users","seen by users and","by users and any","users and any other","and any other names","any other names as","other names as specified","names as specified after","as specified after the","specified after the copyright","the copyright statement standard","copyright statement standard version","statement standard version refers","holder modified version refers","to any derivative font","any derivative font software","derivative font software made","font software made by","software made by adding","components of the standard","the standard version by","standard version by changing","individual components in standard","components in standard or","in standard or modified","by itself 2 standard","itself 2 standard or","2 standard or modified","bundled redistributed and sold","font name s in","name s in part","s in part or","or in whole unless","in whole unless explicit","whole unless explicit written","granted by the copyright","the copyright holder this","holder this restriction applies","this restriction applies to","restriction applies to all","applies to all references","to all references stored","all references stored in","references stored in the","stored in the font","the font software such","font software such as","software such as the","such as the font","as the font menu","the font menu name","font menu name and","menu name and other","name and other font","and other font description","other font description fields","font description fields which","description fields which are","fields which are used","which are used to","are used to differentiate","used to differentiate the","to differentiate the font","differentiate the font from","the font from others","font from others 4","from others 4 the","others 4 the name"]},{"licenseTexts":["Copyright (c) \u003cdates\u003e, \u003cCopyright Holder\u003e (\u003cURL|email\u003e),\n\nwith Reserved Font Name \u003cReserved Font Name\u003e. This Font Software is licensed under the SIL Open Font License, Version 1.1.\n\nThis license is copied below, and is also available with a FAQ at: http://scripts.sil.org/OFL SIL OPEN FONT LICENSE\n\nVersion 1.1 - 26 February 2007\n\nPREAMBLE\n\nThe goals of the Open Font License (OFL) are to stimulate worldwide development of collaborative font projects, to support the font creation efforts of academic and linguistic communities, and to provide a free and open framework in which fonts may be shared and improved in partnership with others.\n\nThe OFL allows the licensed fonts to be used, studied, modified and redistributed freely as long as they are not sold by themselves. The fonts, including any derivative works, can be bundled, embedded, redistributed and/or sold with any software provided that any reserved names are not used by derivative works. The fonts and derivatives, however, cannot be released under any other type of license. The requirement for fonts to remain under this license does not apply to any document created using the fonts or their derivatives.\n\nDEFINITIONS\n\n\"Font Software\" refers to the set of files released by the Copyright Holder(s) under this license and clearly marked as such. This may include source files, build scripts and documentation.\n\n\"Reserved Font Name\" refers to any names specified as such after the copyright statement(s).\n\n\"Original Version\" refers to the collection of Font Software components as distributed by the Copyright Holder(s).\n\n\"Modified Version\" refers to any derivative made by adding to, deleting, or substituting — in part or in whole — any of the components of the Original Version, by changing formats or by porting the Font Software to a new environment.\n\n\"Author\" refers to any designer, engineer, programmer, technical writer or other person who contributed to the Font Software.\n\nPERMISSION \u0026 CONDITIONS\n\nPermission is hereby granted, free of charge, to any person obtaining a copy of the Font Software, to use, study, copy, merge, embed, modify, redistribute, and sell modified and unmodified copies of the Font Software, subject to the following conditions:\n\n   1) Neither the Font Software nor any of its individual components, in Original or Modified Versions, may be sold by itself.\n\n   2) Original or Modified Versions of the Font Software may be bundled, redistributed and/or sold with any software, provided that each copy contains the above copyright notice and this license. These can be included either as stand-alone text files, human-readable headers or in the appropriate machine-readable metadata fields within text or binary files as long as those fields can be easily viewed by the user.\n\n   3) No Modified Version of the Font Software may use the Reserved Font Name(s) unless explicit written permission is granted by the corresponding Copyright Holder. This restriction only applies to the primary font name as presented to the users.\n\n   4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font Software shall not be used to promote, endorse or advertise any Modified Version, except to acknowledge the contribution(s) of the Copyright Holder(s) and the Author(s) or with their explicit written permission.\n\n   5) The Font Software, modified or unmodified, in part or in whole, must be distributed entirely under this license, and must not be distributed under any other license. The requirement for fonts to remain under this license does not apply to any document created using the Font Software.\n\nTERMINATION\n\nThis license becomes null and void if any of the above conditions are not met.\n\nDISCLAIMER\n\nTHE FONT SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER DEALINGS IN THE FONT SOFTWARE."],"licenseIds":["OFL-1.1-RFN","OFL-1.1"],"keywords":["url email with","email with reserved","with reserved font","font name reserved","name reserved font","font name this","name this font","holder url email with","url email with reserved","email with reserved font","with reserved font name","reserved font name reserved","font name reserved font","name reserved font name","reserved font name this","font name this font","name this font software","copyright holder url email with","holder url email with reserved","url email with reserved font","email with reserved font name","with reserved font name reserved","reserved font name reserved font","font name reserved font name","name reserved font name this","reserved font name this font","font name this font software","name this font software is"]},{"licenseTexts":["Copyright (c) \u003cdates\u003e, \u003cCopyright Holder\u003e (\u003cURL|email\u003e). This Font Software is licensed under the SIL Open Font License, Version 1.1.\n\nThis license is copied below, and is also available with a FAQ at: http://scripts.sil.org/OFL SIL OPEN FONT LICENSE\n\nVersion 1.1 - 26 February 2007\n\nPREAMBLE\n\nThe goals of the Open Font License (OFL) are to stimulate worldwide development of collaborative font projects, to support the font creation efforts of academic and linguistic communities, and to provide a free and open framework in which fonts may be shared and improved in partnership with others.\n\nThe OFL allows the licensed fonts to be used, studied, modified and redistributed freely as long as they are not sold by themselves. The fonts, including any derivative works, can be bundled, embedded, redistributed and/or sold with any software provided that any reserved names are not used by derivative works. The fonts and derivatives, however, cannot be released under any other type of license. The requirement for fonts to remain under this license does not apply to any document created using the fonts or their derivatives.\n\nDEFINITIONS\n\n\"Font Software\" refers to the set of files released by the Copyright Holder(s) under this license and clearly marked as such. This may include source files, build scripts and documentation.\n\n\"Reserved Font Name\" refers to any names specified as such after the copyright statement(s).\n\n\"Original Version\" refers to the collection of Font Software components as distributed by the Copyright Holder(s).\n\n\"Modified Version\" refers to any derivative made by adding to, deleting, or substituting — in part or in whole — any of the components of the Original Version, by changing formats or by porting the Font Software to a new environment.\n\n\"Author\" refers to any designer, engineer, programmer, technical writer or other person who contributed to the Font Software.\n\nPERMISSION \u0026 CONDITIONS\n\nPermission is hereby granted, free of charge, to any person obtaining a copy of the Font Software, to use, study, copy, merge, embed, modify, redistribute, and sell modified and unmodified copies of the Font Software, subject to the following conditions:\n\n   1) Neither the Font Software nor any of its individual components, in Original or Modified Versions, may be sold by itself.\n\n   2) Original or Modified Versions of the Font Software may be bundled, redistributed and/or sold with any software, provided that each copy contains the above copyright notice and this license. These can be included either as stand-alone text files, human-readable headers or in the appropriate machine-readable metadata fields within text or binary files as long as those fields can be easily viewed by the user.\n\n   3) No Modified Version of the Font Software may use the Reserved Font Name(s) unless explicit written permission is granted by the corresponding Copyright Holder. This restriction only applies to the primary font name as presented to the users.\n\n   4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font Software shall not be used to promote, endorse or advertise any Modified Version, except to acknowledge the contribution(s) of the Copyright Holder(s) and the Author(s) or with their explicit written permission.\n\n   5) The Font Software, modified or unmodified, in part or in whole, must be distributed entirely under this license, and must not be distributed under any other license. The requirement for fonts to remain under this license does not apply to any document created using the Font Software.\n\nTERMINATION\n\nThis license becomes null and void if any of the above conditions are not met.\n\nDISCLAIMER\n\nTHE FONT SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER DEALINGS IN THE FONT SOFTWARE."],"licenseIds":["OFL-1.1-no-RFN"],"keywords":["url email this","email this font","holder url email this","url email this font","email this font software","copyright holder url email this","holder url email this font","url email this font software","email this font software is"]},{"licenseTexts":["OGC Software License, Version 1.0\n\nThis OGC work (including software, documents, or other related items) is being provided by the copyright holders under the following license. By obtaining, using and/or copying this work, you (the licensee) agree that you have read, understood, and will comply with the following terms and conditions:\n\nPermission to use, copy, and modify this software and its documentation, with or without modification, for any purpose and without fee or royalty is hereby granted, provided that you include the following on ALL copies of the software and documentation or portions thereof, including modifications, that you make:\n\n   1. The full text of this NOTICE in a location viewable to users of the redistributed or derivative work.\n\n   2. Any pre-existing intellectual property disclaimers, notices, or terms and conditions. If none exist, a short notice of the following form (hypertext is preferred, text is permitted) should be used within the body of any redistributed or derivative code: \"Copyright © [$date-of-document] Open Geospatial Consortium, Inc. All Rights Reserved. http://www. ogc .org/ogc/legal (Hypertext is preferred, but a textual representation is permitted.)\n\n   3. Notice of any changes or modifications to the OGC files, including the date changes were made. (We recommend you provide URIs to the location from which the code is derived.)\n\nTHIS SOFTWARE AND DOCUMENTATION IS PROVIDED \"AS IS,\" AND COPYRIGHT HOLDERS MAKE NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE OR DOCUMENTATION WILL NOT INFRINGE ANY THIRD PARTY PATENTS, COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS.\n\nCOPYRIGHT HOLDERS WILL NOT BE LIABLE FOR ANY DIRECT, INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF ANY USE OF THE SOFTWARE OR DOCUMENTATION.\n\nThe name and trademarks of copyright holders may NOT be used in advertising or publicity pertaining to the software without specific, written prior permission. Title to copyright in this software and any associated documentation will at all times remain with copyright holders."],"licenseIds":["OGC-1.0"],"keywords":["ogc software license","0 this ogc","this ogc work","ogc work including","date of document","of document open","document open geospatial","open geospatial consortium","geospatial consortium inc","consortium inc all","http www ogc","www ogc org","ogc org ogc","org ogc legal","ogc legal hypertext","legal hypertext is","is preferred but","preferred but a","but a textual","a textual representation","textual representation is","representation is permitted","is permitted 3","permitted 3 notice","to the ogc","the ogc files","ogc files including","ogc software license version","1 0 this ogc","0 this ogc work","this ogc work including","ogc work including software","use copy and modify","copyright date of document","date of document open","of document open geospatial","document open geospatial consortium","open geospatial consortium inc","geospatial consortium inc all","consortium inc all rights","reserved http www ogc","http www ogc org","www ogc org ogc","ogc org ogc legal","org ogc legal hypertext","ogc legal hypertext is","legal hypertext is preferred","hypertext is preferred but","is preferred but a","preferred but a textual","but a textual representation","a textual representation is","textual representation is permitted","representation is permitted 3","is permitted 3 notice","permitted 3 notice of","modifications to the ogc","to the ogc files","the ogc files including","ogc files including the","ogc software license version 1","version 1 0 this ogc","1 0 this ogc work","0 this ogc work including","this ogc work including software","ogc work including software documents","to use copy and modify","use copy and modify this","code copyright date of document","copyright date of document open","date of document open geospatial","of document open geospatial consortium","document open geospatial consortium inc","open geospatial consortium inc all","geospatial consortium inc all rights","consortium inc all rights reserved","inc all rights reserved http","rights reserved http www ogc","reserved http www ogc org","http www ogc org ogc","www ogc org ogc legal","ogc org ogc legal hypertext","org ogc legal hypertext is","ogc legal hypertext is preferred","legal hypertext is preferred but","hypertext is preferred but a","is preferred but a textual","preferred but a textual representation","but a textual representation is","a textual representation is permitted","textual representation is permitted 3","representation is permitted 3 notice","is permitted 3 notice of","permitted 3 notice of any","or modifications to the ogc","modifications to the ogc files","to the ogc files including","the ogc files including the","ogc files including the date"]},{"licenseTexts":["Open Government Licence - Canada\n\nYou are encouraged to use the Information that is available under this licence with only a few conditions.\n\nUsing Information under this licence\n\n   * Use of any Information indicates your acceptance of the terms below.\n\n   * The Information Provider grants you a worldwide, royalty-free, perpetual, non-exclusive licence to use the Information, including for commercial purposes, subject to the terms below.\n\nYou are free to:\n\n   * Copy, modify, publish, translate, adapt, distribute or otherwise use the Information in any medium, mode or format for any lawful purpose.\n\nYou must, where you do any of the above:\n\n   * Acknowledge the source of the Information by including any attribution statement specified by the Information Provider(s) and, where possible, provide a link to this licence.\n\n   * If the Information Provider does not provide a specific attribution statement, or if you are using Information from several information providers and multiple attributions are not practical for your product or application, you must use the following attribution statement:\n\n   Contains information licensed under the Open Government Licence – Canada.\n\nThe terms of this licence are important, and if you fail to comply with any of them, the rights granted to you under this licence, or any similar licence granted by the Information Provider, will end automatically.\n\nExemptions\n\nThis licence does not grant you any right to use:\n\n   * Personal Information;\n\n   * third party rights the Information Provider is not authorized to license;\n\n   * the names, crests, logos, or other official symbols of the Information Provider; and\n\n   * Information subject to other intellectual property rights, including patents, trade-marks and official marks.\n\nNon-endorsement\n\nThis licence does not grant you any right to use the Information in a way that suggests any official status or that the Information Provider endorses you or your use of the Information.\n\nNo Warranty\n\nThe Information is licensed \"as is\", and the Information Provider excludes all representations, warranties, obligations, and liabilities, whether express or implied, to the maximum extent permitted by law.\n\nThe Information Provider is not liable for any errors or omissions in the Information, and will not under any circumstances be liable for any direct, indirect, special, incidental, consequential, or other loss, injury or damage caused by its use or otherwise arising in connection with this licence or the Information, even if specifically advised of the possibility of such loss, injury or damage.\n\nGoverning Law\n\nThis licence is governed by the laws of the province of Ontario and the applicable laws of Canada.\n\nLegal proceedings related to this licence may only be brought in the courts of Ontario or the Federal Court of Canada.\n\nDefinitions\n\nIn this licence, the terms below have the following meanings:\n\n\"Information\"\n\nmeans information resources protected by copyright or other information that is offered for use under the terms of this licence.\n\n\"Information Provider\"\n\nmeans Her Majesty the Queen in right of Canada.\n\n\"Personal Information\"\n\nmeans \"personal information\" as defined in section 3 of the Privacy Act, R.S.C. 1985, c. P-21.\n\n\"You\"\n\nmeans the natural or legal person, or body of persons corporate or incorporate, acquiring rights under this licence.\n\nVersioning\n\nThis is version 2.0 of the Open Government Licence – Canada. The Information Provider may make changes to the terms of this licence from time to time and issue a new version of the licence. Your use of the Information will be governed by the terms of the licence in force as of the date you accessed the information."],"licenseIds":["OGL-Canada-2.0"],"keywords":["licence canada you","canada you are","this licence with","licence with only","any information indicates","terms below the","below the information","information provider grants","provider grants you","information including for","including for commercial","for commercial purposes","commercial purposes subject","purposes subject to","terms below you","below you are","modify publish translate","publish translate adapt","translate adapt distribute","adapt distribute or","information in any","any medium mode","medium mode or","or format for","format for any","for any lawful","any lawful purpose","lawful purpose you","purpose you must","not practical for","practical for your","following attribution statement","attribution statement contains","statement contains information","canada the terms","licence are important","are important and","important and if","any of them","of them the","information provider will","provider will end","to use personal","use personal information","personal information third","information third party","is not authorized","authorized to license","license the names","the names crests","names crests logos","crests logos or","logos or other","or other official","other official symbols","official symbols of","symbols of the","provider and information","marks and official","and official marks","official marks non","marks non endorsement","and liabilities whether","liabilities whether express","whether express or","information and will","will not under","circumstances be liable","incidental consequential or","or other loss","other loss injury","or damage caused","damage caused by","its use or","the information even","information even if","even if specifically","if specifically advised","specifically advised of","of such loss","such loss injury","or damage governing","damage governing law","of the province","province of ontario","of ontario and","ontario and the","and the applicable","the applicable laws","applicable laws of","laws of canada","of canada legal","canada legal proceedings","legal proceedings related","proceedings related to","licence may only","only be brought","courts of ontario","of ontario or","ontario or the","or the federal","the federal court","federal court of","court of canada","of canada definitions","canada definitions in","means information resources","information resources protected","resources protected by","other information that","that is offered","provider means her","means her majesty","her majesty the","majesty the queen","the queen in","queen in right","in right of","right of canada","of canada personal","canada personal information","personal information means","information means personal","means personal information","personal information as","of the privacy","the privacy act","privacy act r","act r s","r s c","s c 1985","c 1985 c","1985 c p","c p 21","p 21 you","21 you means","this licence versioning","licence versioning this","versioning this is","canada the information","information provider may","provider may make","may make changes","this licence from","licence from time","to time and","time and issue","and issue a","issue a new","the licence your","licence your use","the licence in","licence in force","in force as","force as of","date you accessed","you accessed the","accessed the information","government licence canada you","licence canada you are","canada you are encouraged","under this licence with","this licence with only","licence with only a","licence use of any","use of any information","of any information indicates","any information indicates your","of the terms below","the terms below the","terms below the information","below the information provider","the information provider grants","information provider grants you","provider grants you a","use the information including","the information including for","information including for commercial","including for commercial purposes","for commercial purposes subject","commercial purposes subject to","purposes subject to the","to the terms below","the terms below you","terms below you are","below you are free","copy modify publish translate","modify publish translate adapt","publish translate adapt distribute","translate adapt distribute or","adapt distribute or otherwise","distribute or otherwise use","or otherwise use the","otherwise use the information","the information in any","information in any medium","in any medium mode","any medium mode or","medium mode or format","mode or format for"]},{"licenseTexts":["Open Government Licence v1.0\n\nYou are encouraged to use and re-use the Information that is available under this licence, the Open Government Licence, freely and flexibly, with only a few conditions.\n\nUsing Information under this licence\n\nUse of copyright and database right material expressly made available under this licence (the 'Information') indicates your acceptance of the terms and conditions below.\n\nThe Licensor grants you a worldwide, royalty-free, perpetual, non-exclusive licence to use the Information subject to the conditions below.\n\nThis licence does not affect your freedom under fair dealing or fair use or any other copyright or database right exceptions and limitations.\n\nYou are free to:\n\n   copy, publish, distribute and transmit the Information;\n\n   adapt the Information;\n\n   exploit the Information commercially for example, by combining it with other Information, or by including it in your own product or application.\n\nYou must, where you do any of the above:\n\n   acknowledge the source of the Information by including any attribution statement specified by the Information Provider(s) and, where possible, provide a link to this licence;\n\n   If the Information Provider does not provide a specific attribution statement, or if you are using Information from several Information Providers and multiple attributions are not practical in your product or application, you may consider using the following:\n\n   Contains public sector information licensed under the Open Government Licence v1.0.\n\n   ensure that you do not use the Information in a way that suggests any official status or that the Information Provider endorses you or your use of the Information;\n\n   ensure that you do not mislead others or misrepresent the Information or its source;\n\n   ensure that your use of the Information does not breach the Data Protection Act 1998 or the Privacy and Electronic Communications (EC Directive) Regulations 2003.\n\nThese are important conditions of this licence and if you fail to comply with them the rights granted to you under this licence, or any similar licence granted by the Licensor, will end automatically.\n\nExemptions\n\nThis licence does not cover the use of:\n\n   - personal data in the Information;\n\n   - Information that has neither been published nor disclosed under information access legislation (including the Freedom of Information Acts for the UK and Scotland) by or with the consent of the Information Provider;\n\n   - departmental or public sector organisation logos, crests and the Royal Arms except where they form an integral part of a document or dataset;\n\n   - military insignia;\n\n   - third party rights the Information Provider is not authorised to license;\n\n   - Information subject to other intellectual property rights, including patents, trademarks, and design rights; and\n\n   - identity documents such as the British Passport.\n\nNo warranty\n\nThe Information is licensed 'as is' and the Information Provider excludes all representations, warranties, obligations and liabilities in relation to the Information to the maximum extent permitted by law.\n\nThe Information Provider is not liable for any errors or omissions in the Information and shall not be liable for any loss, injury or damage of any kind caused by its use. The Information Provider does not guarantee the continued supply of the Information.\n\nGoverning Law\n\nThis licence is governed by the laws of the jurisdiction in which the Information Provider has its principal place of business, unless otherwise specified by the Information Provider.\n\nDefinitions\n\nIn this licence, the terms below have the following meanings:\n\n   'Information' means information protected by copyright or by database right (for example, literary and artistic works, content, data and source code) offered for use under the terms of this licence.\n\n   'Information Provider' means the person or organisation providing the Information under this licence.\n\n   'Licensor' means any Information Provider which has the authority to offer Information under the terms of this licence or the Controller of Her Majesty's Stationery Office, who has the authority to offer Information subject to Crown copyright and Crown database rights and Information subject to copyright and database right that has been assigned to or acquired by the Crown, under the terms of this licence.\n\n   'Use' as a verb, means doing any act which is restricted by copyright or database right, whether in the original medium or in any other medium, and includes without limitation distributing, copying, adapting, modifying as may be technically necessary to use it in a different mode or format.\n\n   'You' means the natural or legal person, or body of persons corporate or incorporate, acquiring rights under this licence.\n\nAbout the Open Government Licence\n\nThe Controller of Her Majesty's Stationery Office (HMSO) has developed this licence as a tool to enable Information Providers in the public sector to license the use and re-use of their Information under a common open licence. The Controller invites public sector bodies owning their own copyright and database rights to permit the use of their Information under this licence.\n\nThe Controller of HMSO has authority to license Information subject to copyright and database right owned by the Crown. The extent of the Controller's offer to license this Information under the terms of this licence is set out in the UK Government Licensing Framework.\n\nThis is version 1.0 of the Open Government Licence. The Controller of HMSO may, from time to time, issue new versions of the Open Government Licence. However, you may continue to use Information licensed under this version should you wish to do so.\n\nThese terms have been aligned to be interoperable with any Creative Commons Attribution Licence, which covers copyright, and Open Data Commons Attribution License, which covers database rights and applicable copyrights.\n\nFurther context, best practice and guidance can be found in the UK Government Licensing Framework section on The National Archives website."],"licenseIds":["OGL-UK-1.0"],"keywords":["v1 0 you","licence the open","government licence freely","information commercially for","may consider using","consider using the","v1 0 ensure","0 ensure that","the information ensure","information ensure that","do not mislead","not mislead others","mislead others or","others or misrepresent","or misrepresent the","misrepresent the information","or its source","its source ensure","source ensure that","the information does","does not breach","not breach the","breach the data","the data protection","data protection act","protection act 1998","act 1998 or","1998 or the","or the privacy","the privacy and","privacy and electronic","and electronic communications","electronic communications ec","communications ec directive","ec directive regulations","directive regulations 2003","regulations 2003 these","2003 these are","including patents trademarks","patents trademarks and","trademarks and design","british passport no","passport no warranty","or the controller","licence use as","is version 1","government licence however","licence however you","use information licensed","this version should","version should you","should you wish","do so these","so these terms","these terms have","terms have been","have been aligned","been aligned to","aligned to be","to be interoperable","be interoperable with","interoperable with any","with any creative","any creative commons","attribution licence which","licence which covers","which covers copyright","covers copyright and","copyright and open","and open data","attribution license which","license which covers","which covers database","covers database rights","rights and applicable","and applicable copyrights","applicable copyrights further","copyrights further context","licence v1 0 you","v1 0 you are","this licence the open","licence the open government","open government licence freely","government licence freely and","the information commercially for","information commercially for example","application you may consider","you may consider using","may consider using the","consider using the following","using the following contains","licence v1 0 ensure","v1 0 ensure that","0 ensure that you","you do not use","of the information ensure","the information ensure that","information ensure that you","you do not mislead","do not mislead others","not mislead others or","mislead others or misrepresent","others or misrepresent the","or misrepresent the information","misrepresent the information or","the information or its","information or its source","or its source ensure","its source ensure that","source ensure that your","ensure that your use","of the information does","the information does not","information does not breach","does not breach the","not breach the data","breach the data protection","the data protection act","data protection act 1998","protection act 1998 or","act 1998 or the","1998 or the privacy","or the privacy and","the privacy and electronic","privacy and electronic communications","and electronic communications ec","electronic communications ec directive","communications ec directive regulations","ec directive regulations 2003","directive regulations 2003 these","regulations 2003 these are","2003 these are important","authorised to license information","rights including patents trademarks","including patents trademarks and","patents trademarks and design","trademarks and design rights","the british passport no","british passport no warranty","passport no warranty the","licence or the controller","or the controller of","this licence use as","licence use as a","this is version 1","is version 1 0","open government licence however","government licence however you","licence however you may","however you may continue","continue to use information","to use information licensed","use information licensed under","information licensed under this","licensed under this version","under this version should","this version should you","version should you wish","should you wish to","you wish to do","to do so these","do so these terms","so these terms have","these terms have been","terms have been aligned","have been aligned to","been aligned to be","aligned to be interoperable","to be interoperable with","be interoperable with any","interoperable with any creative","with any creative commons","any creative commons attribution","commons attribution licence which","attribution licence which covers","licence which covers copyright","which covers copyright and","covers copyright and open","copyright and open data","and open data commons","commons attribution license which","attribution license which covers","license which covers database","which covers database rights","covers database rights and","database rights and applicable","rights and applicable copyrights","and applicable copyrights further","applicable copyrights further context","copyrights further context best","government licence v1 0 you","licence v1 0 you are","v1 0 you are encouraged","under this licence the open","this licence the open government","licence the open government licence","the open government licence freely","open government licence freely and","government licence freely and flexibly","exploit the information commercially for"]},{"licenseTexts":["Open Government Licence v2.0\n\nYou are encouraged to use and re-use the Information that is available under this licence freely and flexibly, with only a few conditions.\n\nUsing Information under this licence\n\nUse of copyright and database right material expressly made available under this licence (the 'Information') indicates your acceptance of the terms and conditions below.\n\nThe Licensor grants you a worldwide, royalty-free, perpetual, non-exclusive licence to use the Information subject to the conditions below.\n\nThis licence does not affect your freedom under fair dealing or fair use or any other copyright or database right exceptions and limitations.\n\nYou are free to:\n\n   copy, publish, distribute and transmit the Information;\n\n   adapt the Information;\n\n   exploit the Information commercially and non-commercially for example, by combining it with other Information, or by including it in your own product or application.\n\nYou must, where you do any of the above:\n\n   acknowledge the source of the Information by including any attribution statement specified by the Information Provider(s) and, where possible, provide a link to this licence;\n\n   If the Information Provider does not provide a specific attribution statement, or if you are using Information from several Information Providers and multiple attributions are not practical in your product or application, you may use the following:\n\n   Contains public sector information licensed under the Open Government Licence v2.0.\n\n   These are important conditions of this licence and if you fail to comply with them the rights granted to you under this licence, or any similar licence granted by the Licensor, will end automatically.\n\nExemptions\n\nThis licence does not cover:\n\n   personal data in the Information;\n\n   information that has neither been published nor disclosed under information access legislation (including the Freedom of Information Acts for the UK and Scotland) by or with the consent of the Information Provider;\n\n   departmental or public sector organisation logos, crests and the Royal Arms except where they form an integral part of a document or dataset;\n\n   military insignia;\n\n   third party rights the Information Provider is not authorised to license;\n\n   other intellectual property rights, including patents, trade marks, and design rights; and\n\n   identity documents such as the British Passport\n\nNon-endorsement\n\nThis licence does not grant you any right to use the Information in a way that suggests any official status or that the Information Provider endorses you or your use of the Information.\n\nNon warranty\n\nThe Information is licensed 'as is' and the Information Provider excludes all representations, warranties, obligations and liabilities in relation to the Information to the maximum extent permitted by law.\n\nThe Information Provider is not liable for any errors or omissions in the Information and shall not be liable for any loss, injury or damage of any kind caused by its use. The Information Provider does not guarantee the continued supply of the Information.\n\nGoverning Law\n\nThis licence is governed by the laws of the jurisdiction in which the Information Provider has its principal place of business, unless otherwise specified by the Information Provider.\n\nDefinitions\n\nIn this licence, the terms below have the following meanings:\n\n   'Information' means information protected by copyright or by database right (for example, literary and artistic works, content, data and source code) offered for use under the terms of this licence.\n\n   'Information Provider' means the person or organisation providing the Information under this licence.\n\n   'Licensor' means any Information Provider who has the authority to offer Information under the terms of this licence. It includes the Controller of Her Majesty's Stationery Office, who has the authority to offer Information subject to Crown copyright and Crown database rights, and Information subject to copyright and database rights which have been assigned to or acquired by the Crown, under the terms of this licence.\n\n   'Use' means doing any act which is restricted by copyright or database right, whether in the original medium or in any other medium, and includes without limitation distributing, copying, adapting, modifying as may be technically necessary to use it in a different mode or format.\n\n   'You' means the natural or legal person, or body of persons corporate or incorporate, acquiring rights under this licence.\n\nAbout the Open Government Licence\n\nThe Controller of Her Majesty's Stationery Office (HMSO) has developed this licence as a tool to enable Information Providers in the public sector to license the use and re-use of their Information under a common open licence. The Controller invites public sector bodies owning their own copyright and database rights to permit the use of their Information under this licence.\n\nThe Controller of HMSO has authority to license Information subject to copyright and database right owned by the Crown. The extent of the Controller's offer to license this Information under the terms of this licence is set out on The National Archives website.\n\nThis is version 2.0 of the Open Government Licence. The Controller of HMSO may, from time to time, issue new versions of the Open Government Licence. If you are already using Information under a previous version of the Open Government Licence, the terms of that licence will continue to apply.\n\nThese terms are compatible with the Creative Commons Attribution License 4.0 and the Open Data Commons Attribution License, both of which license copyright and database rights. This means that when the Information is adapted and licensed under either of those licences, you automatically satisfy the conditions of the OGL when you comply with the other licence. The OGLv2.0 is Open Definition compliant.\n\nFurther context, best practice and guidance can be found in the UK Government Licensing Framework section on The National Archives website."],"licenseIds":["OGL-UK-2.0"],"keywords":["v2 0 you","v2 0 these","0 these are","the information non","information non warranty","non warranty the","information provider who","provider who has","this licence it","licence it includes","it includes the","includes the controller","database rights which","rights which have","have been assigned","set out on","out on the","archives website this","website this is","licence the oglv2","the oglv2 0","oglv2 0 is","licence v2 0 you","v2 0 you are","application you may use","may use the following","licence v2 0 these","v2 0 these are","0 these are important","of the information non","the information non warranty","information non warranty the","non warranty the information","any information provider who","information provider who has","provider who has the","of this licence it","this licence it includes","licence it includes the","it includes the controller","includes the controller of","and database rights which","database rights which have","rights which have been","which have been assigned","have been assigned to","is set out on","set out on the","out on the national","national archives website this","archives website this is","website this is version","other licence the oglv2","licence the oglv2 0","the oglv2 0 is","oglv2 0 is open","government licence v2 0 you","licence v2 0 you are","v2 0 you are encouraged","or application you may use","application you may use the","you may use the following","may use the following contains","the open government licence v2","government licence v2 0 these","licence v2 0 these are","v2 0 these are important","0 these are important conditions","use of the information non","of the information non warranty","the information non warranty the","information non warranty the information","non warranty the information is","means any information provider who","any information provider who has","information provider who has the","provider who has the authority","terms of this licence it","of this licence it includes","this licence it includes the","licence it includes the controller","it includes the controller of","includes the controller of her","to copyright and database rights","copyright and database rights which","and database rights which have","database rights which have been","rights which have been assigned","which have been assigned to","have been assigned to or","licence is set out on","is set out on the","set out on the national","out on the national archives","the national archives website this","national archives website this is","archives website this is version","website this is version 2","the other licence the oglv2","other licence the oglv2 0","licence the oglv2 0 is","the oglv2 0 is open","oglv2 0 is open definition"]},{"licenseTexts":["Open Government Licence v3.0\n\nYou are encouraged to use and re-use the Information that is available under this licence freely and flexibly, with only a few conditions.\n\nUsing Information under this licence\n\nUse of copyright and database right material expressly made available under this licence (the 'Information') indicates your acceptance of the terms and conditions below.\n\nThe Licensor grants you a worldwide, royalty-free, perpetual, non-exclusive licence to use the Information subject to the conditions below.\n\nThis licence does not affect your freedom under fair dealing or fair use or any other copyright or database right exceptions and limitations.\n\nYou are free to:\n\n   copy, publish, distribute and transmit the Information;\n\n   adapt the Information;\n\n   exploit the Information commercially and non-commercially for example, by combining it with other Information, or by including it in your own product or application.\n\nYou must (where you do any of the above):\n\n   acknowledge the source of the Information in your product or application by including or linking to any attribution statement specified by the Information Provider(s) and, where possible, provide a link to this licence;\n\n   If the Information Provider does not provide a specific attribution statement, you must use the following:\n\n   Contains public sector information licensed under the Open Government Licence v3.0.\n\n   If you are using Information from several Information Providers and listing multiple attributions is not practical in your product or application, you may include a URI or hyperlink to a resource that contains the required attribution statements.\n\n   These are important conditions of this licence and if you fail to comply with them the rights granted to you under this licence, or any similar licence granted by the Licensor, will end automatically.\n\nExemptions\n\nThis licence does not cover:\n\n   personal data in the Information;\n\n   Information that has not been accessed by way of publication or disclosure under information access legislation (including the Freedom of Information Acts for the UK and Scotland) by or with the consent of the Information Provider;\n\n   departmental or public sector organisation logos, crests and the Royal Arms except where they form an integral part of a document or dataset;\n\n   military insignia;\n\n   third party rights the Information Provider is not authorised to license;\n\n   other intellectual property rights, including patents, trade marks, and design rights; and\n\n   identity documents such as the British Passport\n\nNon-endorsement\n\nThis licence does not grant you any right to use the Information in a way that suggests any official status or that the Information Provider and/or Licensor endorse you or your use of the Information.\n\nNo warranty\n\nThe Information is licensed 'as is' and the Information Provider and/or Licensor excludes all representations, warranties, obligations and liabilities in relation to the Information to the maximum extent permitted by law.\n\nThe Information Provider and/or Licensor are not liable for any errors or omissions in the Information and shall not be liable for any loss, injury or damage of any kind caused by its use. The Information Provider does not guarantee the continued supply of the Information.\n\nGoverning Law\n\nThis licence is governed by the laws of the jurisdiction in which the Information Provider has its principal place of business, unless otherwise specified by the Information Provider.\n\nDefinitions\n\nIn this licence, the terms below have the following meanings:\n\n   'Information' means information protected by copyright or by database right (for example, literary and artistic works, content, data and source code) offered for use under the terms of this licence.\n\n   'Information Provider' means the person or organisation providing the Information under this licence.\n\n   'Licensor' means any Information Provider which has the authority to offer Information under the terms of this licence or the Keeper of Public Records, who has the authority to offer Information subject to Crown copyright and Crown database rights and Information subject to copyright and database right that has been assigned to or acquired by the Crown, under the terms of this licence.\n\n   'Use' means doing any act which is restricted by copyright or database right, whether in the original medium or in any other medium, and includes without limitation distributing, copying, adapting, modifying as may be technically necessary to use it in a different mode or format.\n\n   'You', 'you' and 'your' means the natural or legal person, or body of persons corporate or incorporate, acquiring rights in the Information (whether the Information is obtained directly from the Licensor or otherwise) under this licence.\n\nAbout the Open Government Licence\n\nThe National Archives has developed this licence as a tool to enable Information Providers in the public sector to license the use and re-use of their Information under a common open licence. The National Archives invites public sector bodies owning their own copyright and database rights to permit the use of their Information under this licence.\n\nThe Keeper of the Public Records has authority to license Information subject to copyright and database right owned by the Crown. The extent of the offer to license this Information under the terms of this licence is set out in the UK Government Licensing Framework.\n\nThis is version 3.0 of the Open Government Licence. The National Archives may, from time to time, issue new versions of the Open Government Licence. If you are already using Information under a previous version of the Open Government Licence, the terms of that licence will continue to apply.\n\nThese terms are compatible with the Creative Commons Attribution License 4.0 and the Open Data Commons Attribution License, both of which license copyright and database rights. This means that when the Information is adapted and licensed under either of those licences, you automatically satisfy the conditions of the OGL when you comply with the other licence. The OGLv3.0 is Open Definition compliant.\n\nFurther context, best practice and guidance can be found in the UK Government Licensing Framework section on The National Archives website."],"licenseIds":["OGL-UK-3.0"],"keywords":["v3 0 you","or application by","application by including","by including or","including or linking","or linking to","linking to any","to any attribution","v3 0 if","attribution statements these","statements these are","or licensor excludes","licensor excludes all","or licensor are","licensor are not","are not liable","keeper of public","of public records","format you you","you you and","your means the","acquiring rights in","the information whether","information whether the","whether the information","information is obtained","is obtained directly","obtained directly from","licensor or otherwise","otherwise under this","national archives has","archives has developed","national archives invites","archives invites public","licence the keeper","public records has","records has authority","of the offer","is version 3","3 0 of","national archives may","archives may from","licence the oglv3","the oglv3 0","oglv3 0 is","licence v3 0 you","v3 0 you are","the information in your","information in your product","product or application by","or application by including","application by including or","by including or linking","including or linking to","or linking to any","linking to any attribution","to any attribution statement","licence v3 0 if","v3 0 if you","required attribution statements these","attribution statements these are","statements these are important","and or licensor excludes","or licensor excludes all","licensor excludes all representations","and or licensor are","or licensor are not","licensor are not liable","are not liable for","the keeper of public","keeper of public records","of public records who","or format you you","format you you and","you you and your","and your means the","your means the natural","incorporate acquiring rights in","acquiring rights in the","rights in the information","in the information whether","the information whether the","information whether the information","whether the information is","the information is obtained","information is obtained directly","is obtained directly from","obtained directly from the","directly from the licensor","from the licensor or","the licensor or otherwise","licensor or otherwise under","or otherwise under this","otherwise under this licence","the national archives has","national archives has developed","archives has developed this","open licence the national","the national archives invites","national archives invites public","archives invites public sector","this licence the keeper","licence the keeper of","the public records has","public records has authority","records has authority to","extent of the offer","of the offer to","the offer to license","this is version 3","is version 3 0","version 3 0 of","3 0 of the","the national archives may","national archives may from","archives may from time","other licence the oglv3","licence the oglv3 0","the oglv3 0 is","oglv3 0 is open","government licence v3 0 you","licence v3 0 you are","v3 0 you are encouraged","source of the information in","of the information in your","the information in your product","information in your product or","your product or application by","product or application by including","or application by including or","application by including or linking","by including or linking to","including or linking to any","or linking to any attribution","linking to any attribution statement","to any attribution statement specified","the open government licence v3","government licence v3 0 if","licence v3 0 if you","v3 0 if you are","the required attribution statements these","required attribution statements these are","attribution statements these are important","statements these are important conditions","and the information provider and","provider and or licensor excludes","and or licensor excludes all","or licensor excludes all representations","licensor excludes all representations warranties","law the information provider and","provider and or licensor are","and or licensor are not","or licensor are not liable","licensor are not liable for","are not liable for any","or the keeper of public","the keeper of public records","keeper of public records who","of public records who has","mode or format you you","or format you you and","format you you and your","you you and your means","you and your means the","and your means the natural","your means the natural or","or incorporate acquiring rights in","incorporate acquiring rights in the","acquiring rights in the information","rights in the information whether","in the information whether the","the information whether the information","information whether the information is","whether the information is obtained","the information is obtained directly","information is obtained directly from","is obtained directly from the","obtained directly from the licensor","directly from the licensor or","from the licensor or otherwise","the licensor or otherwise under","licensor or otherwise under this","or otherwise under this licence","otherwise under this licence about","licence the national archives has","the national archives has developed","national archives has developed this","archives has developed this licence","common open licence the national","open licence the national archives","licence the national archives invites","the national archives invites public","national archives invites public sector","archives invites public sector bodies","under this licence the keeper","this licence the keeper of","licence the keeper of the","of the public records has","the public records has authority","public records has authority to"]},{"licenseTexts":["The Open Group Test Suite License Preamble\n\nThe intent of this document is to state the conditions under which a Package may be copied, such that the Copyright Holder maintains some semblance of artistic control over the development of the package, while giving the users of the package the right to use and distribute the Package in a more-or-less customary fashion, plus the right to make reasonable modifications.\n\nTesting is essential for proper development and maintenance of standards-based products.\n\nFor buyers: adequate conformance testing leads to reduced integration costs and protection of investments in applications, software and people.\n\nFor software developers: conformance testing of platforms and middleware greatly reduces the cost of developing and maintaining multi-platform application software.\n\nFor suppliers: In-depth testing increases customer satisfaction and keeps development and support costs in check. API conformance is highly measurable and suppliers who claim it must be able to substantiate that claim.\n\nAs such, since these are benchmark measures of conformance, we feel the integrity of test tools is of importance. In order to preserve the integrity of the existing conformance modes of this test package and to permit recipients of modified versions of this package to run the original test modes, this license requires that the original test modes be preserved.\n\nIf you find a bug in one of the standards mode test cases, please let us know so we can feed this back into the original, and also raise any specification issues with the appropriate bodies (for example the POSIX committees).\n\nDefinitions:\n\n\"Package\" refers to the collection of files distributed by the Copyright Holder, and derivatives of that collection of files created through textual modification.\n\n\"Standard Version\" refers to such a Package if it has not been modified, or has been modified in accordance with the wishes of the Copyright Holder.\n\n\"Copyright Holder\" is whoever is named in the copyright or copyrights for the package.\n\n\"You\" is you, if you're thinking about copying or distributing this Package.\n\n\"Reasonable copying fee\" is whatever you can justify on the basis of media cost, duplication charges, time of people involved, and so on. (You will not be required to justify it to the Copyright Holder, but only to the computing community at large as a market that must bear the fee.)\n\n\"Freely Available\" means that no fee is charged for the item itself, though there may be fees involved in handling the item. It also means that recipients of the item may redistribute it under the same conditions they received it.\n\n   1. You may make and give away verbatim copies of the source form of the Standard Version of this Package without restriction, provided that you duplicate all of the original copyright notices and associated disclaimers.\n\n   2. You may apply bug fixes, portability fixes and other modifications derived from the Public Domain or from the Copyright Holder. A Package modified in such a way shall still be considered the Standard Version.\n\n   3. You may otherwise modify your copy of this Package in any way, provided that you insert a prominent notice in each changed file stating how and when you changed that file, and provided that you do at least the following:\n\n   rename any non-standard executables and testcases so the names do not conflict with standard executables and testcases, which must also be provided, and provide a separate manual page for each non-standard executable and testcase that clearly documents how it differs from the Standard Version.\n\n   4. You may distribute the programs of this Package in object code or executable form, provided that you do at least the following:\n\n   accompany any non-standard executables and testcases with their corresponding Standard Version executables and testcases, giving the non-standard executables and testcases non-standard names, and clearly documenting the differences in manual pages (or equivalent), together with instructions on where to get the Standard Version.\n\n   5. You may charge a reasonable copying fee for any distribution of this Package. You may charge any fee you choose for support of this Package. You may not charge a fee for this Package itself. However, you may distribute this Package in aggregate with other (possibly commercial) programs as part of a larger (possibly commercial) software distribution provided that you do not advertise this Package as a product of your own.\n\n   6. The scripts and library files supplied as input to or produced as output from the programs of this Package do not automatically fall under the copyright of this Package, but belong to whomever generated them, and may be sold commercially, and may be aggregated with this Package.\n\n   7.Subroutines supplied by you and linked into this Package shall not be considered part of this Package.\n\n   8. The name of the Copyright Holder may not be used to endorse or promote products derived from this software without specific prior written permission.\n\n   9. THIS PACKAGE IS PROVIDED \"AS IS\" AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. The End"],"licenseIds":["OGTSL"],"keywords":["the open group","suite license preamble","reasonable modifications testing","modifications testing is","testing is essential","is essential for","essential for proper","for proper development","proper development and","development and maintenance","and maintenance of","maintenance of standards","of standards based","standards based products","based products for","products for buyers","for buyers adequate","buyers adequate conformance","adequate conformance testing","conformance testing leads","testing leads to","leads to reduced","to reduced integration","reduced integration costs","integration costs and","costs and protection","and protection of","protection of investments","of investments in","investments in applications","in applications software","applications software and","software and people","and people for","people for software","for software developers","software developers conformance","developers conformance testing","conformance testing of","testing of platforms","of platforms and","platforms and middleware","and middleware greatly","middleware greatly reduces","greatly reduces the","reduces the cost","cost of developing","of developing and","developing and maintaining","and maintaining multi","maintaining multi platform","multi platform application","platform application software","application software for","software for suppliers","for suppliers in","suppliers in depth","in depth testing","depth testing increases","testing increases customer","increases customer satisfaction","customer satisfaction and","satisfaction and keeps","and keeps development","keeps development and","development and support","and support costs","support costs in","costs in check","in check api","check api conformance","api conformance is","conformance is highly","is highly measurable","highly measurable and","measurable and suppliers","and suppliers who","suppliers who claim","who claim it","claim it must","able to substantiate","to substantiate that","substantiate that claim","that claim as","claim as such","as such since","such since these","these are benchmark","are benchmark measures","benchmark measures of","measures of conformance","of conformance we","conformance we feel","we feel the","feel the integrity","integrity of test","of test tools","test tools is","tools is of","is of importance","of importance in","importance in order","order to preserve","preserve the integrity","of the existing","the existing conformance","existing conformance modes","conformance modes of","modes of this","of this test","this test package","test package and","package and to","to permit recipients","permit recipients of","recipients of modified","package to run","run the original","test modes this","modes this license","test modes be","modes be preserved","be preserved if","preserved if you","you find a","find a bug","a bug in","bug in one","the standards mode","standards mode test","mode test cases","test cases please","cases please let","we can feed","can feed this","feed this back","this back into","into the original","original and also","and also raise","also raise any","raise any specification","any specification issues","specification issues with","issues with the","the appropriate bodies","appropriate bodies for","bodies for example","example the posix","the posix committees","posix committees definitions","committees definitions package","the following rename","following rename any","and testcases so","testcases so the","and testcases which","testcases which must","standard executable and","executable and testcase","and testcase that","testcase that clearly","standard version 4","version 4 you","the following accompany","following accompany any","and testcases with","testcases with their","version executables and","and testcases giving","testcases giving the","and testcases non","testcases non standard","standard version 5","version 5 you","package 7 subroutines","7 subroutines supplied","the open group test","test suite license preamble","suite license preamble the","make reasonable modifications testing","reasonable modifications testing is","modifications testing is essential","testing is essential for","is essential for proper","essential for proper development","for proper development and","proper development and maintenance","development and maintenance of","and maintenance of standards","maintenance of standards based","of standards based products","standards based products for","based products for buyers","products for buyers adequate","for buyers adequate conformance","buyers adequate conformance testing","adequate conformance testing leads","conformance testing leads to","testing leads to reduced"]},{"licenseTexts":["The OpenLDAP Public License\n\nVersion 1.1, 25 August 1998 Copyright 1998, The OpenLDAP Foundation. All Rights Reserved. Note: This license is derived from the \"Artistic License\" as distributed with the Perl Programming Language. Its terms are different from those of the \"Artistic License.\"\n\nPREAMBLE\n\nThe intent of this document is to state the conditions under which a Package may be copied, such that the Copyright Holder maintains some semblance of artistic control over the development of the package, while giving the users of the package the right to use and distribute the Package in a more-or-less customary fashion, plus the right to make reasonable modifications.\n\nDefinitions:\n\n\"Package\" refers to the collection of files distributed by the Copyright Holder, and derivatives of that collection of files created through textual modification.\n\n\"Standard Version\" refers to such a Package if it has not been modified, or has been modified in accordance with the wishes of the Copyright Holder.\n\n\"Copyright Holder\" is whoever is named in the copyright or copyrights for the package.\n\n\"You\" is you, if you're thinking about copying or distributing this Package.\n\n\"Reasonable copying fee\" is whatever you can justify on the basis of media cost, duplication charges, time of people involved, and so on. (You will not be required to justify it to the Copyright Holder, but only to the computing community at large as a market that must bear the fee.)\n\n\"Freely Available\" means that no fee is charged for the item itself, though there may be fees involved in handling the item. It also means that recipients of the item may redistribute it under the same conditions they received it.\n\n   1. You may make and give away verbatim copies of the source form of the Standard Version of this Package without restriction, provided that you duplicate all of the original copyright notices and associated disclaimers.\n\n   2. You may apply bug fixes, portability fixes and other modifications derived from the Public Domain or from the Copyright Holder. A Package modified in such a way shall still be considered the Standard Version.\n\n   3. You may otherwise modify your copy of this Package in any way, provided that you insert a prominent notice in each changed file stating how and when you changed that file, and provided that you do at least ONE of the following:\n\n      a) place your modifications in the Public Domain or otherwise make them Freely Available, such as by posting said modifications to Usenet or an equivalent medium, or placing the modifications on a major archive site such as uunet.uu.net, or by allowing the Copyright Holder to include your modifications in the Standard Version of the Package.\n\n      b) use the modified Package only within your corporation or organization.\n\n      c) rename any non-standard executables so the names do not conflict with standard executables, which must also be provided, and provide a separate manual page for each non-standard executable that clearly documents how it differs from the Standard Version.\n\n      d) make other distribution arrangements with the Copyright Holder.\n\n   4. You may distribute the programs of this Package in object code or executable form, provided that you do at least ONE of the following:\n\n      a) distribute a Standard Version of the executables and library files, together with instructions (in the manual page or equivalent) on where to get the Standard Version.\n\n      b) accompany the distribution with the machine-readable source of the Package with your modifications.\n\n      c) accompany any non-standard executables with their corresponding Standard Version executables, giving the non-standard executables non-standard names, and clearly documenting the differences in manual pages (or equivalent), together with instructions on where to get the Standard Version.\n\n      d) make other distribution arrangements with the Copyright Holder.\n\n   5. You may charge a reasonable copying fee for any distribution of this Package. You may charge any fee you choose for support of this Package. You may not charge a fee for this Package itself. However, you may distribute this Package in aggregate with other (possibly commercial) programs as part of a larger (possibly commercial) software distribution provided that you do not advertise this Package as a product of your own.\n\n   6. The scripts and library files supplied as input to or produced as output from the programs of this Package do not automatically fall under the copyright of this Package, but belong to whomever generated them, and may be sold commercially, and may be aggregated with this Package.\n\n   7. C subroutines supplied by you and linked into this Package in order to emulate subroutines and variables of the language defined by this Package shall not be considered part of this Package, but are the equivalent of input as in Paragraph 6, provided these subroutines do not change the language in any way that would cause it to fail the regression tests for the language.\n\n   8. The name of the Copyright Holder may not be used to endorse or promote products derived from this software without specific prior written permission.\n\n   9. THIS PACKAGE IS PROVIDED \"AS IS\" AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. The End"],"licenseIds":["OLDAP-1.1"],"keywords":["1 1 25","1 25 august","25 august 1998","version 1 1 25","1 1 25 august","1 25 august 1998","25 august 1998 copyright","license version 1 1 25","version 1 1 25 august","1 1 25 august 1998","1 25 august 1998 copyright","25 august 1998 copyright 1998","august 1998 copyright 1998 the"]},{"licenseTexts":["The OpenLDAP Public License\n\nVersion 1.2, 1 September 1998 Copyright 1998, The OpenLDAP Foundation. All Rights Reserved. Note: This license is derived from the \"Artistic License\" as distributed with the Perl Programming Language. As differences may exist, the complete license should be read.\n\nPREAMBLE\n\nThe intent of this document is to state the conditions under which a Package may be copied, such that the Copyright Holder maintains some semblance of artistic control over the development of the package, while giving the users of the package the right to use and distribute the Package in a more-or-less customary fashion, plus the right to make reasonable modifications.\n\nDefinitions:\n\n\"Package\" refers to the collection of files distributed by the Copyright Holder, and derivatives of that collection of files created through textual modification.\n\n\"Standard Version\" refers to such a Package if it has not been modified, or has been modified in accordance with the wishes of the Copyright Holder.\n\n\"Copyright Holder\" is whoever is named in the copyright or copyrights for the package.\n\n\"You\" is you, if you're thinking about copying or distributing this Package.\n\n\"Reasonable copying fee\" is whatever you can justify on the basis of media cost, duplication charges, time of people involved, and so on. (You will not be required to justify it to the Copyright Holder, but only to the computing community at large as a market that must bear the fee.)\n\n\"Freely Available\" means that no fee is charged for the item itself, though there may be fees involved in handling the item. It also means that recipients of the item may redistribute it under the same conditions they received it.\n\n   1. You may make and give away verbatim copies of the source form of the Standard Version of this Package without restriction, provided that you duplicate all of the original copyright notices and associated disclaimers.\n\n   2. You may apply bug fixes, portability fixes and other modifications derived from the Public Domain or from the Copyright Holder. A Package modified in such a way shall still be considered the Standard Version.\n\n   3. You may otherwise modify your copy of this Package in any way, provided that you insert a prominent notice in each changed file stating how and when you changed that file, and provided that you do at least ONE of the following:\n\n      a) place your modifications in the Public Domain or otherwise make them Freely Available, such as by posting said modifications to Usenet or an equivalent medium, or placing the modifications on a major archive site such as uunet.uu.net, or by allowing the Copyright Holder to include your modifications in the Standard Version of the Package.\n\n      b) use the modified Package only within your corporation or organization.\n\n      c) rename any non-standard executables so the names do not conflict with standard executables, which must also be provided, and provide a separate manual page for each non-standard executable that clearly documents how it differs from the Standard Version.\n\n      d) make other distribution arrangements with the Copyright Holder.\n\n   4. You may distribute the programs of this Package in object code or executable form, provided that you do at least ONE of the following:\n\n      a) distribute a Standard Version of the executables and library files, together with instructions (in the manual page or equivalent) on where to get the Standard Version.\n\n      b) accompany the distribution with the machine-readable source of the Package with your modifications.\n\n      c) accompany any non-standard executables with their corresponding Standard Version executables, giving the non-standard executables non-standard names, and clearly documenting the differences in manual pages (or equivalent), together with instructions on where to get the Standard Version.\n\n      d) make other distribution arrangements with the Copyright Holder.\n\n   5. You may charge a reasonable copying fee for any distribution of this Package. You may charge any fee you choose for support of this Package. You may not charge a fee for this Package itself. However, you may distribute this Package in aggregate with other (possibly commercial) programs as part of a larger (possibly commercial) software distribution provided that you do not advertise this Package as a product of your own.\n\n   6. The scripts and library files supplied as input to or produced as output from the programs of this Package do not automatically fall under the copyright of this Package, but belong to whomever generated them, and may be sold commercially, and may be aggregated with this Package.\n\n   7. C subroutines supplied by you and linked into this Package in order to emulate subroutines and variables of the language defined by this Package shall not be considered part of this Package, but are the equivalent of input as in Paragraph 6, provided these subroutines do not change the language in any way that would cause it to fail the regression tests for the language.\n\n   8. The name of the Copyright Holder may not be used to endorse or promote products derived from this software without specific prior written permission.\n\n   9. THIS PACKAGE IS PROVIDED \"AS IS\" AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. The End"],"licenseIds":["OLDAP-1.2"],"keywords":["2 1 september","1 september 1998","september 1998 copyright","language as differences","as differences may","differences may exist","may exist the","1 2 1 september","2 1 september 1998","1 september 1998 copyright","september 1998 copyright 1998","programming language as differences","language as differences may","as differences may exist","differences may exist the","may exist the complete","public license version 1 2","version 1 2 1 september","1 2 1 september 1998","2 1 september 1998 copyright","1 september 1998 copyright 1998","september 1998 copyright 1998 the","perl programming language as differences","programming language as differences may","language as differences may exist","as differences may exist the","differences may exist the complete","may exist the complete license"]},{"licenseTexts":["The OpenLDAP Public License\n\nVersion 1.3, 17 January 1999 Copyright 1998-1999, The OpenLDAP Foundation. All Rights Reserved. Note: This license is derived from the \"Artistic License\" as distributed with the Perl Programming Language. As significant differences exist, the complete license should be read.\n\nPREAMBLE\n\nThe intent of this document is to state the conditions under which a Package may be copied, such that the Copyright Holder maintains some semblance of artistic control over the development of the package, while giving the users of the package the right to use and distribute the Package in a more-or-less customary fashion, plus the right to make reasonable modifications.\n\nDefinitions:\n\n\"Package\" refers to the collection of files distributed by the Copyright Holder, and derivatives of that collection of files created through textual modification.\n\n\"Standard Version\" refers to such a Package if it has not been modified, or has been modified in accordance with the wishes of the Copyright Holder.\n\n\"Copyright Holder\" is whoever is named in the copyright or copyrights for the package.\n\n\"You\" is you, if you're thinking about copying or distributing this Package.\n\n\"Reasonable copying fee\" is whatever you can justify on the basis of media cost, duplication charges, time of people involved, and so on. (You will not be required to justify it to the Copyright Holder, but only to the computing community at large as a market that must bear the fee.)\n\n\"Freely Available\" means that no fee is charged for the item itself, though there may be fees involved in handling the item. It also means that recipients of the item may redistribute it under the same conditions they received it.\n\n   1. You may make and give away verbatim copies of the source form of the Standard Version of this Package without restriction, provided that you duplicate all of the original copyright notices and associated disclaimers.\n\n   2. You may apply bug fixes, portability fixes and other modifications derived from the Public Domain or from the Copyright Holder. A Package modified in such a way shall still be considered the Standard Version.\n\n   3. You may otherwise modify your copy of this Package in any way, provided that you insert a prominent notice in each changed file stating how and when you changed that file, and provided that you do at least ONE of the following:\n\n      a) place your modifications in the Public Domain or otherwise make them Freely Available, such as by posting said modifications to Usenet or an equivalent medium, or placing the modifications on a major archive site such as uunet.uu.net, or by allowing the Copyright Holder to include your modifications in the Standard Version of the Package.\n\n      b) use the modified Package only within your corporation or organization.\n\n      c) rename any non-standard executables so the names do not conflict with standard executables, which must also be provided, and provide a separate manual page for each non-standard executable that clearly documents how it differs from the Standard Version.\n\n      d) make other distribution arrangements with the Copyright Holder.\n\n   4. You may distribute the programs of this Package in object code or executable form, provided that you do at least ONE of the following:\n\n      a) distribute a Standard Version of the executables and library files, together with instructions (in the manual page or equivalent) on where to get the Standard Version.\n\n      b) accompany the distribution with the machine-readable source of the Package with your modifications.\n\n      c) accompany any non-standard executables with their corresponding Standard Version executables, giving the non-standard executables non-standard names, and clearly documenting the differences in manual pages (or equivalent), together with instructions on where to get the Standard Version.\n\n      d) make other distribution arrangements with the Copyright Holder.\n\n   5. You may charge a reasonable copying fee for any distribution of this Package. You may charge any fee you choose for support of this Package. You may not charge a fee for this Package itself. However, you may distribute this Package in aggregate with other (possibly commercial) programs as part of a larger (possibly commercial) software distribution provided that you do not advertise this Package as a product of your own.\n\n   6. The scripts and library files supplied as input to or produced as output from the programs of this Package do not automatically fall under the copyright of this Package, but belong to whomever generated them, and may be sold commercially, and may be aggregated with this Package.\n\n   7. C subroutines supplied by you and linked into this Package in order to emulate subroutines and variables defined by this Package shall not be considered part of this Package, but are the equivalent of input as in Paragraph 6, provided these subroutines do not change the behavior of the Package in any way that would cause it to fail the regression tests for the Package.\n\n   8. Software supplied by you and linked with this Package in order to use subroutines and variables defined by this Package shall not be considered part of this Package and do not automatically fall under the copyright of this Package, and the executables produced by linking your software with this Package may be used and redistributed without restriction and may be sold commercially.\n\n   9. The name of the Copyright Holder may not be used to endorse or promote products derived from this software without specific prior written permission.\n\n   10. THIS PACKAGE IS PROVIDED \"AS IS\" AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. The End"],"licenseIds":["OLDAP-1.3"],"keywords":["1 3 17","3 17 january","17 january 1999","package and the","and the executables","the executables produced","sold commercially 9","commercially 9 the","version 1 3 17","1 3 17 january","3 17 january 1999","17 january 1999 copyright","this package and the","package and the executables","and the executables produced","the executables produced by","be sold commercially 9","sold commercially 9 the","commercially 9 the name","license version 1 3 17","version 1 3 17 january","1 3 17 january 1999","3 17 january 1999 copyright","17 january 1999 copyright 1998","copyright of this package and","of this package and the","this package and the executables","package and the executables produced","and the executables produced by","the executables produced by linking","may be sold commercially 9","be sold commercially 9 the","sold commercially 9 the name","commercially 9 the name of"]},{"licenseTexts":["The OpenLDAP Public License\n\nVersion 1.4, 18 January 1999 Copyright 1998-1999, The OpenLDAP Foundation. All Rights Reserved. Note: This license is derived from the \"Artistic License\" as distributed with the Perl Programming Language. As significant differences exist, the complete license should be read.\n\nPREAMBLE\n\nThe intent of this document is to state the conditions under which a Package may be copied, such that the Copyright Holder maintains some semblance of artistic control over the development of the package, while giving the users of the package the right to use and distribute the Package in a more-or-less customary fashion, plus the right to make reasonable modifications.\n\nDefinitions:\n\n\"Package\" refers to the collection of files distributed by the Copyright Holder, and derivatives of that collection of files created through textual modification.\n\n\"Standard Version\" refers to such a Package if it has not been modified, or has been modified in accordance with the wishes of the Copyright Holder.\n\n\"Copyright Holder\" is whoever is named in the copyright or copyrights for the package.\n\n\"You\" is you, if you're thinking about copying or distributing this Package.\n\n\"Reasonable copying fee\" is whatever you can justify on the basis of media cost, duplication charges, time of people involved, and so on. (You will not be required to justify it to the Copyright Holder, but only to the computing community at large as a market that must bear the fee.)\n\n\"Freely Available\" means that no fee is charged for the item itself, though there may be fees involved in handling the item. It also means that recipients of the item may redistribute it under the same conditions they received it.\n\n   1. You may make and give away verbatim copies of the source form of the Standard Version of this Package without restriction, provided that you duplicate all of the original copyright notices and associated disclaimers.\n\n   2. You may apply bug fixes, portability fixes and other modifications derived from the Public Domain or from the Copyright Holder. A Package modified in such a way shall still be considered the Standard Version.\n\n   3. You may otherwise modify your copy of this Package in any way, provided that you insert a prominent notice in each changed file stating how and when you changed that file, and provided that you do at least ONE of the following:\n\n      a) place your modifications in the Public Domain or otherwise make them Freely Available, such as by posting said modifications to Usenet or an equivalent medium, or placing the modifications on a major archive site such as uunet.uu.net, or by allowing the Copyright Holder to include your modifications in the Standard Version of the Package.\n\n      b) use the modified Package only within your corporation or organization.\n\n      c) rename any non-standard executables so the names do not conflict with standard executables, which must also be provided, and provide a separate manual page for each non-standard executable that clearly documents how it differs from the Standard Version.\n\n      d) make other distribution arrangements with the Copyright Holder.\n\n   4. You may distribute the programs of this Package in object code or executable form, provided that you do at least ONE of the following:\n\n      a) distribute a Standard Version of the executables and library files, together with instructions (in the manual page or equivalent) on where to get the Standard Version.\n\n      b) accompany the distribution with the machine-readable source of the Package with your modifications.\n\n      c) accompany any non-standard executables with their corresponding Standard Version executables, giving the non-standard executables non-standard names, and clearly documenting the differences in manual pages (or equivalent), together with instructions on where to get the Standard Version.\n\n      d) make other distribution arrangements with the Copyright Holder.\n\n   5. You may charge a reasonable copying fee for any distribution of this Package. You may charge any fee you choose for support of this Package. You may not charge a fee for this Package itself. However, you may distribute this Package in aggregate with other (possibly commercial) programs as part of a larger (possibly commercial) software distribution provided that you do not advertise this Package as a product of your own.\n\n   6. The scripts and library files supplied as input to or produced as output from the programs of this Package do not automatically fall under the copyright of this Package, but belong to whomever generated them, and may be sold commercially, and may be aggregated with this Package.\n\n   7. C subroutines supplied by you and linked into this Package in order to emulate subroutines and variables defined by this Package shall not be considered part of this Package, but are the equivalent of input as in Paragraph 6, provided these subroutines do not change the behavior of the Package in any way that would cause it to fail the regression tests for the Package.\n\n   8. Software supplied by you and linked with this Package in order to use subroutines and variables defined by this Package shall not be considered part of this Package and do not automatically fall under the copyright of this Package. Executables produced by linking your software with this Package may be used and redistributed without restriction and may be sold commercially so long as the primary function of your software is different than the package itself.\n\n   9. The name of the Copyright Holder may not be used to endorse or promote products derived from this software without specific prior written permission.\n\n   10. THIS PACKAGE IS PROVIDED \"AS IS\" AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. The End"],"licenseIds":["OLDAP-1.4"],"keywords":["1 4 18","4 18 january","18 january 1999","this package executables","package executables produced","sold commercially so","commercially so long","the primary function","primary function of","function of your","software is different","is different than","different than the","than the package","package itself 9","itself 9 the","version 1 4 18","1 4 18 january","4 18 january 1999","18 january 1999 copyright","of this package executables","this package executables produced","package executables produced by","be sold commercially so","sold commercially so long","commercially so long as","long as the primary","as the primary function","the primary function of","primary function of your","function of your software","of your software is","your software is different","software is different than","is different than the","different than the package","than the package itself","the package itself 9","package itself 9 the","itself 9 the name","license version 1 4 18","version 1 4 18 january","1 4 18 january 1999","4 18 january 1999 copyright","18 january 1999 copyright 1998","copyright of this package executables","of this package executables produced","this package executables produced by","package executables produced by linking","may be sold commercially so","be sold commercially so long","sold commercially so long as","commercially so long as the","so long as the primary","long as the primary function","as the primary function of","the primary function of your","primary function of your software","function of your software is","of your software is different","your software is different than","software is different than the","is different than the package","different than the package itself","than the package itself 9","the package itself 9 the","package itself 9 the name","itself 9 the name of"]},{"licenseTexts":["The OpenLDAP Public License\n\nVersion 2.0.1, 21 December 1999 Copyright 1999, The OpenLDAP Foundation, Redwood City, California, USA. All Rights Reserved.\n\nRedistribution and use of this software and associated documentation (\"Software\"), with or without modification, are permitted provided that the following conditions are met:\n\n   1. Redistributions of source code must retain copyright statements and notices. Redistributions must also contain a copy of this document.\n\n   2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   3. The name \"OpenLDAP\" must not be used to endorse or promote products derived from this Software without prior written permission of the OpenLDAP Foundation. For written permission, please contact foundation@openldap.org.\n\n   4. Products derived from this Software may not be called \"OpenLDAP\" nor may \"OpenLDAP\" appear in their names without prior written permission of the OpenLDAP Foundation. OpenLDAP is a trademark of the OpenLDAP Foundation.\n\n   5. Due credit should be given to the OpenLDAP Project (http://www.openldap.org/).\n\nTHIS SOFTWARE IS PROVIDED BY THE OPENLDAP FOUNDATION AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OPENLDAP FOUNDATION OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."],"licenseIds":["OLDAP-2.0.1"],"keywords":["0 1 21","1 21 december","21 december 1999","december 1999 copyright","2 0 1 21","0 1 21 december","1 21 december 1999","21 december 1999 copyright","december 1999 copyright 1999","version 2 0 1 21","2 0 1 21 december","0 1 21 december 1999","1 21 december 1999 copyright","21 december 1999 copyright 1999","december 1999 copyright 1999 the"]},{"licenseTexts":["The OpenLDAP Public License\n\nVersion 2.0, 7 June 1999 Copyright 1999, The OpenLDAP Foundation, Redwood City, California, USA. All Rights Reserved.\n\nRedistribution and use of this software and associated documentation (\"Software\"), with or without modification, are permitted provided that the following conditions are met:\n\n   1. Redistributions of source code must retain copyright statements and notices. Redistributions must also contain a copy of this document.\n\n   2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   3. The name \"OpenLDAP\" must not be used to endorse or promote products derived from this Software without prior written permission of the OpenLDAP Foundation. For written permission, please contact foundation@openldap.org.\n\n   4. Products derived from this Software may not be called \"OpenLDAP\" nor may \"OpenLDAP\" appear in their names without prior written permission of the OpenLDAP Foundation. OpenLDAP is a registered trademark of the OpenLDAP Foundation.\n\n   5. Due credit should be given to the OpenLDAP Project (http://www.openldap.org/).\n\nTHIS SOFTWARE IS PROVIDED BY THE OPENLDAP FOUNDATION AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OPENLDAP FOUNDATION OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."],"licenseIds":["OLDAP-2.0"],"keywords":["2 0 7","0 7 june","7 june 1999","june 1999 copyright","version 2 0 7","2 0 7 june","0 7 june 1999","7 june 1999 copyright","june 1999 copyright 1999","license version 2 0 7","version 2 0 7 june","2 0 7 june 1999","0 7 june 1999 copyright","7 june 1999 copyright 1999","june 1999 copyright 1999 the","foundation openldap is a registered"]},{"licenseTexts":["The OpenLDAP Public License\n\nVersion 2.1, 29 February 2000 Copyright 1999-2000, The OpenLDAP Foundation, Redwood City, California, USA. All Rights Reserved.\n\nRedistribution and use of this software and associated documentation (\"Software\"), with or without modification, are permitted provided that the following conditions are met:\n\n   1. Redistributions of source code must retain copyright statements and notices. Redistributions must also contain a copy of this document.\n\n   2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   3. The name \"OpenLDAP\" must not be used to endorse or promote products derived from this Software without prior written permission of the OpenLDAP Foundation. For written permission, please contact foundation@openldap.org.\n\n   4. Products derived from this Software may not be called \"OpenLDAP\" nor may \"OpenLDAP\" appear in their names without prior written permission of the OpenLDAP Foundation. OpenLDAP is a trademark of the OpenLDAP Foundation.\n\n   5. Due credit should be given to the OpenLDAP Project (http://www.openldap.org/).\n\n   6. The OpenLDAP Foundation may revise this license from time to time. Each revision is distinguished by a version number. You may use the Software under terms of this license revision or under the terms of any subsequent license revision.\n\nTHIS SOFTWARE IS PROVIDED BY THE OPENLDAP FOUNDATION AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OPENLDAP FOUNDATION OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."],"licenseIds":["OLDAP-2.1"],"keywords":["2 1 29","1 29 february","29 february 2000","february 2000 copyright","2000 copyright 1999","any subsequent license","subsequent license revision","license revision this","revision this software","version 2 1 29","2 1 29 february","1 29 february 2000","29 february 2000 copyright","february 2000 copyright 1999","2000 copyright 1999 2000","of any subsequent license","any subsequent license revision","subsequent license revision this","license revision this software","revision this software is","license version 2 1 29","version 2 1 29 february","2 1 29 february 2000","1 29 february 2000 copyright","29 february 2000 copyright 1999","february 2000 copyright 1999 2000","2000 copyright 1999 2000 the","terms of any subsequent license","of any subsequent license revision","any subsequent license revision this","subsequent license revision this software","license revision this software is","revision this software is provided"]},{"licenseTexts":["The OpenLDAP Public License\n\nVersion 2.2.1, 1 March 2000\n\nRedistribution and use of this software and associated documentation (\"Software\"), with or without modification, are permitted provided that the following conditions are met:\n\n   1. Redistributions of source code must retain copyright statements and notices. Redistributions must also contain a copy of this document.\n\n   2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   3. The name \"OpenLDAP\" must not be used to endorse or promote products derived from this Software without prior written permission of the OpenLDAP Foundation.\n\n   4. Products derived from this Software may not be called \"OpenLDAP\" nor may \"OpenLDAP\" appear in their names without prior written permission of the OpenLDAP Foundation.\n\n   5. Due credit should be given to the OpenLDAP Project (http://www.openldap.org/).\n\n   6. The OpenLDAP Foundation may revise this license from time to time. Each revision is distinguished by a version number. You may use the Software under terms of this license revision or under the terms of any subsequent revision of the license.\n\nTHIS SOFTWARE IS PROVIDED BY THE OPENLDAP FOUNDATION AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OPENLDAP FOUNDATION OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\nOpenLDAP is a trademark of the OpenLDAP Foundation.\n\nCopyright 1999-2000 The OpenLDAP Foundation, Redwood City, California, USA. All Rights Reserved. Permission to copy and distributed verbatim copies of this document is granted."],"licenseIds":["OLDAP-2.2.1"],"keywords":["2 2 1 1","2 1 1 march","version 2 2 1 1","2 2 1 1 march","2 1 1 march 2000","1 1 march 2000 redistribution"]},{"licenseTexts":["The OpenLDAP Public License\n\nVersion 2.2.2, 28 July 2000\n\nRedistribution and use of this software and associated documentation (\"Software\"), with or without modification, are permitted provided that the following conditions are met:\n\n   1. Redistributions of source code must retain copyright statements and notices.\n\n   2. Redistributions in binary form must reproduce applicable copyright statements and notices, this list of conditions, and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   3. Redistributions must contain a verbatim copy of this document.\n\n   4. The name \"OpenLDAP\" must not be used to endorse or promote products derived from this Software without prior written permission of the OpenLDAP Foundation.\n\n   5. Products derived from this Software may not be called \"OpenLDAP\" nor may \"OpenLDAP\" appear in their names without prior written permission of the OpenLDAP Foundation.\n\n   6. Due credit should be given to the OpenLDAP Project (http://www.openldap.org/).\n\n   7. The OpenLDAP Foundation may revise this license from time to time. Each revision is distinguished by a version number. You may use the Software under terms of this license revision or under the terms of any subsequent revision of the license.\n\nTHIS SOFTWARE IS PROVIDED BY THE OPENLDAP FOUNDATION AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OPENLDAP FOUNDATION OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\nOpenLDAP is a trademark of the OpenLDAP Foundation.\n\nCopyright 1999-2000 The OpenLDAP Foundation, Redwood City, California, USA. All Rights Reserved. Permission to copy and distributed verbatim copies of this document is granted."],"licenseIds":["OLDAP-2.2.2"],"keywords":["2 2 2","2 2 28","2 28 july","version 2 2 2","2 2 2 28","2 2 28 july","2 28 july 2000","license version 2 2 2","version 2 2 2 28","2 2 2 28 july","2 2 28 july 2000","2 28 july 2000 redistribution"]},{"licenseTexts":["The OpenLDAP Public License\n\nVersion 2.2, 1 March 2000\n\nRedistribution and use of this software and associated documentation (\"Software\"), with or without modification, are permitted provided that the following conditions are met:\n\n   1. Redistributions of source code must retain copyright statements and notices. Redistributions must also contain a copy of this document.\n\n   2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   3. The name \"OpenLDAP\" must not be used to endorse or promote products derived from this Software without prior written permission of the OpenLDAP Foundation.\n\n   4. Products derived from this Software may not be called \"OpenLDAP\" nor may \"OpenLDAP\" appear in their names without prior written permission of the OpenLDAP Foundation.\n\n   5. Due credit should be given to the OpenLDAP Project (http://www.openldap.org/).\n\n   6. The OpenLDAP Foundation may revise this license from time to time. Each revision is distinguished by a version number. You may use the Software under terms of this license revision or under the terms of any subsequent the license.\n\nTHIS SOFTWARE IS PROVIDED BY THE OPENLDAP FOUNDATION AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OPENLDAP FOUNDATION OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\nOpenLDAP is a trademark of the OpenLDAP Foundation.\n\nCopyright 1999-2000, The OpenLDAP Foundation, Redwood City, California, USA. All Rights Reserved. Permission to copy and distributed verbatim copies of this document is granted."],"licenseIds":["OLDAP-2.2"],"keywords":["2 1 march","any subsequent the","subsequent the license","2 2 1 march","2 1 march 2000","of any subsequent the","any subsequent the license","subsequent the license this","version 2 2 1 march","2 2 1 march 2000","2 1 march 2000 redistribution","terms of any subsequent the","of any subsequent the license","any subsequent the license this","subsequent the license this software"]},{"licenseTexts":["The OpenLDAP Public License\n\nVersion 2.3, 28 July 2000\n\nRedistribution and use of this software and associated documentation (\"Software\"), with or without modification, are permitted provided that the following conditions are met:\n\n   1. Redistributions of source code must retain copyright statements and notices.\n\n   2. Redistributions in binary form must reproduce applicable copyright statements and notices, this list of conditions, and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   3. Redistributions must contain a verbatim copy of this document.\n\n   4. The name \"OpenLDAP\" must not be used to endorse or promote products derived from this Software without prior written permission of the OpenLDAP Foundation.\n\n   5. Products derived from this Software may not be called \"OpenLDAP\" nor may \"OpenLDAP\" appear in their names without prior written permission of the OpenLDAP Foundation.\n\n   6. Due credit should be given to the OpenLDAP Project (http://www.openldap.org/).\n\n   7. The OpenLDAP Foundation may revise this license from time to time. Each revision is distinguished by a version number. You may use the Software under terms of this license revision or under the terms of any subsequent revision of the license.\n\nTHIS SOFTWARE IS PROVIDED BY THE OPENLDAP FOUNDATION AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OPENLDAP FOUNDATION OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\nOpenLDAP is a trademark of the OpenLDAP Foundation.\n\nCopyright 1999-2000 The OpenLDAP Foundation, Redwood City, California, USA. All Rights Reserved. Permission to copy and distributed verbatim copies of this document is granted."],"licenseIds":["OLDAP-2.3"],"keywords":["version 2 3","2 3 28","3 28 july","license version 2 3","version 2 3 28","2 3 28 july","3 28 july 2000","public license version 2 3","license version 2 3 28","version 2 3 28 july","2 3 28 july 2000","3 28 july 2000 redistribution"]},{"licenseTexts":["The OpenLDAP Public License\n\nVersion 2.4, 8 December 2000\n\nRedistribution and use of this software and associated documentation (\"Software\"), with or without modification, are permitted provided that the following conditions are met:\n\n   1. Redistributions of source code must retain copyright statements and notices.\n\n   2. Redistributions in binary form must reproduce applicable copyright statements and notices, this list of conditions, and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   3. Redistributions must contain a verbatim copy of this document.\n\n   4. The names and trademarks of the authors and copyright holders must not be used in advertising or otherwise to promote the sale, use or other dealing in this Software without specific, written prior permission.\n\n   5. Due credit should be given to the OpenLDAP Project.\n\n   6. The OpenLDAP Foundation may revise this license from time to time. Each revision is distinguished by a version number. You may use the Software under terms of this license revision or under the terms of any subsequent revision of the license.\n\nTHIS SOFTWARE IS PROVIDED BY THE OPENLDAP FOUNDATION AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OPENLDAP FOUNDATION OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\nOpenLDAP is a trademark of the OpenLDAP Foundation.\n\nCopyright 1999-2000 The OpenLDAP Foundation, Redwood City, California, USA. All Rights Reserved. Permission to copy and distributed verbatim copies of this document is granted."],"licenseIds":["OLDAP-2.4"],"keywords":["version 2 4","2 4 8","4 8 december","8 december 2000","december 2000 redistribution","openldap project 6","project 6 the","license version 2 4","version 2 4 8","2 4 8 december","4 8 december 2000","8 december 2000 redistribution","december 2000 redistribution and","the openldap project 6","openldap project 6 the","project 6 the openldap","public license version 2 4","license version 2 4 8","version 2 4 8 december","2 4 8 december 2000","4 8 december 2000 redistribution","8 december 2000 redistribution and","december 2000 redistribution and use","to the openldap project 6","the openldap project 6 the","openldap project 6 the openldap","project 6 the openldap foundation"]},{"licenseTexts":["The OpenLDAP Public License\n\nVersion 2.5, 11 May 2001\n\nRedistribution and use of this software and associated documentation (\"Software\"), with or without modification, are permitted provided that the following conditions are met:\n\n   1. Redistributions of source code must retain copyright statements and notices.\n\n   2. Redistributions in binary form must reproduce applicable copyright statements and notices, this list of conditions, and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   3. Redistributions must contain a verbatim copy of this document.\n\n   4. The names and trademarks of the authors and copyright holders must not be used in advertising or otherwise to promote the sale, use or other dealing in this Software without specific, written prior permission.\n\n   5. Due credit should be given to the authors of the Software.\n\n   6. The OpenLDAP Foundation may revise this license from time to time. Each revision is distinguished by a version number. You may use the Software under terms of this license revision or under the terms of any subsequent revision of the license.\n\nTHIS SOFTWARE IS PROVIDED BY THE OPENLDAP FOUNDATION AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OPENLDAP FOUNDATION, ITS CONTRIBUTORS, OR THE AUTHOR(S) OR OWNER(S) OF THE SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\nOpenLDAP is a trademark of the OpenLDAP Foundation.\n\nCopyright 1999-2001 The OpenLDAP Foundation, Redwood City, California, USA. All Rights Reserved. Permission to copy and distributed verbatim copies of this document is granted."],"licenseIds":["OLDAP-2.5"],"keywords":["version 2 5","2 5 11","5 11 may","11 may 2001","may 2001 redistribution","software 6 the","license version 2 5","version 2 5 11","2 5 11 may","5 11 may 2001","11 may 2001 redistribution","may 2001 redistribution and","given to the authors","the software 6 the","software 6 the openldap","public license version 2 5","license version 2 5 11","version 2 5 11 may","2 5 11 may 2001","5 11 may 2001 redistribution","11 may 2001 redistribution and","may 2001 redistribution and use","be given to the authors","given to the authors of","the authors of the software","authors of the software 6","of the software 6 the","the software 6 the openldap","software 6 the openldap foundation"]},{"licenseTexts":["The OpenLDAP Public License\n\nVersion 2.6, 14 June 2001\n\nRedistribution and use of this software and associated documentation (\"Software\"), with or without modification, are permitted provided that the following conditions are met:\n\n   1. Redistributions of source code must retain copyright statements and notices.\n\n   2. Redistributions in binary form must reproduce applicable copyright statements and notices, this list of conditions, and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   3. Redistributions must contain a verbatim copy of this document.\n\n   4. The names and trademarks of the authors and copyright holders must not be used in advertising or otherwise to promote the sale, use or other dealing in this Software without specific, written prior permission.\n\n   5. The OpenLDAP Foundation may revise this license from time to time. Each revision is distinguished by a version number. You may use the Software under terms of this license revision or under the terms of any subsequent revision of the license.\n\nTHIS SOFTWARE IS PROVIDED BY THE OPENLDAP FOUNDATION AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OPENLDAP FOUNDATION, ITS CONTRIBUTORS, OR THE AUTHOR(S) OR OWNER(S) OF THE SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\nOpenLDAP is a trademark of the OpenLDAP Foundation.\n\nCopyright 1999-2001 The OpenLDAP Foundation, Redwood City, California, USA. All Rights Reserved. Permission to copy and distributed verbatim copies of this document is granted."],"licenseIds":["OLDAP-2.6"],"keywords":["version 2 6","2 6 14","6 14 june","14 june 2001","june 2001 redistribution","5 the openldap","license version 2 6","version 2 6 14","2 6 14 june","6 14 june 2001","14 june 2001 redistribution","june 2001 redistribution and","prior permission 5 the","permission 5 the openldap","5 the openldap foundation","public license version 2 6","license version 2 6 14","version 2 6 14 june","2 6 14 june 2001","6 14 june 2001 redistribution","14 june 2001 redistribution and","june 2001 redistribution and use","written prior permission 5 the","prior permission 5 the openldap","permission 5 the openldap foundation","5 the openldap foundation may"]},{"licenseTexts":["The OpenLDAP Public License\n\nVersion 2.7, 7 September 2001\n\nRedistribution and use of this software and associated documentation (\"Software\"), with or without modification, are permitted provided that the following conditions are met:\n\n   1. Redistributions of source code must retain copyright statements and notices,\n\n   2. Redistributions in binary form must reproduce applicable copyright statements and notices, this list of conditions, and the following disclaimer in the documentation and/or other materials provided with the distribution, and\n\n   3. Redistributions must contain a verbatim copy of this document.\n\nThe OpenLDAP Foundation may revise this license from time to time. Each revision is distinguished by a version number. You may use this Software under terms of this license revision or under the terms of any subsequent revision of the license.\n\nTHIS SOFTWARE IS PROVIDED BY THE OPENLDAP FOUNDATION AND ITS CONTRIBUTORS ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OPENLDAP FOUNDATION, ITS CONTRIBUTORS, OR THE AUTHOR(S) OR OWNER(S) OF THE SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\nThe names of the authors and copyright holders must not be used in advertising or otherwise to promote the sale, use or other dealing in this Software without specific, written prior permission. Title to copyright in this Software shall at all times remain with copyright holders.\n\nOpenLDAP is a registered trademark of the OpenLDAP Foundation.\n\nCopyright 1999-2001 The OpenLDAP Foundation, Redwood City, California, USA. All Rights Reserved. Permission to copy and distribute verbatim copies of this document is granted."],"licenseIds":["OLDAP-2.7"],"keywords":["version 2 7","2 7 7","7 7 september","7 september 2001","september 2001 redistribution","license version 2 7","version 2 7 7","2 7 7 september","7 7 september 2001","7 september 2001 redistribution","september 2001 redistribution and","public license version 2 7","license version 2 7 7","version 2 7 7 september","2 7 7 september 2001","7 7 september 2001 redistribution","7 september 2001 redistribution and","september 2001 redistribution and use"]},{"licenseTexts":["The OpenLDAP Public License\n\nVersion 2.8, 17 August 2003\n\nRedistribution and use of this software and associated documentation (\"Software\"), with or without modification, are permitted provided that the following conditions are met:\n\n   1. Redistributions in source form must retain copyright statements and notices,\n\n   2. Redistributions in binary form must reproduce applicable copyright statements and notices, this list of conditions, and the following disclaimer in the documentation and/or other materials provided with the distribution, and\n\n   3. Redistributions must contain a verbatim copy of this document.\n\nThe OpenLDAP Foundation may revise this license from time to time. Each revision is distinguished by a version number. You may use this Software under terms of this license revision or under the terms of any subsequent revision of the license.\n\nTHIS SOFTWARE IS PROVIDED BY THE OPENLDAP FOUNDATION AND ITS CONTRIBUTORS ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OPENLDAP FOUNDATION, ITS CONTRIBUTORS, OR THE AUTHOR(S) OR OWNER(S) OF THE SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\nThe names of the authors and copyright holders must not be used in advertising or otherwise to promote the sale, use or other dealing in this Software without specific, written prior permission. Title to copyright in this Software shall at all times remain with copyright holders.\n\nOpenLDAP is a registered trademark of the OpenLDAP Foundation.\n\nCopyright 1999-2003 The OpenLDAP Foundation, Redwood City, California, USA. All Rights Reserved. Permission to copy and distribute verbatim copies of this document is granted."],"licenseIds":["OLDAP-2.8"],"keywords":["version 2 8","2 8 17","8 17 august","17 august 2003","august 2003 redistribution","2003 redistribution and","source form must","form must retain","copyright 1999 2003","1999 2003 the","2003 the openldap","license version 2 8","version 2 8 17","2 8 17 august","8 17 august 2003","17 august 2003 redistribution","august 2003 redistribution and","2003 redistribution and use","in source form must","source form must retain","form must retain copyright","foundation copyright 1999 2003","copyright 1999 2003 the","1999 2003 the openldap","2003 the openldap foundation","public license version 2 8","license version 2 8 17","version 2 8 17 august","2 8 17 august 2003","8 17 august 2003 redistribution","17 august 2003 redistribution and","august 2003 redistribution and use","2003 redistribution and use of","1 redistributions in source form","redistributions in source form must","in source form must retain","source form must retain copyright","form must retain copyright statements","openldap foundation copyright 1999 2003","foundation copyright 1999 2003 the","copyright 1999 2003 the openldap","1999 2003 the openldap foundation","2003 the openldap foundation redwood"]},{"licenseTexts":["This FastCGI application library source and object code (the \"Software\") and its documentation (the \"Documentation\") are copyrighted by Open Market, Inc (\"Open Market\"). The following terms apply to all files associated with the Software and Documentation unless explicitly disclaimed in individual files.\n\nOpen Market permits you to use, copy, modify, distribute, and license this Software and the Documentation for any purpose, provided that existing copyright notices are retained in all copies and that this notice is included verbatim in any distributions. No written agreement, license, or royalty fee is required for any of the authorized uses. Modifications to this Software and Documentation may be copyrighted by their authors and need not follow the licensing terms described here. If modifications to this Software and Documentation have new licensing terms, the new terms must be clearly indicated on the first page of each file where they apply.\n\nOPEN MARKET MAKES NO EXPRESS OR IMPLIED WARRANTY WITH RESPECT TO THE SOFTWARE OR THE DOCUMENTATION, INCLUDING WITHOUT LIMITATION ANY WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL OPEN MARKET BE LIABLE TO YOU OR ANY THIRD PARTY FOR ANY DAMAGES ARISING FROM OR RELATING TO THIS SOFTWARE OR THE DOCUMENTATION, INCLUDING, WITHOUT LIMITATION, ANY INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES OR SIMILAR DAMAGES, INCLUDING LOST PROFITS OR LOST DATA, EVEN IF OPEN MARKET HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. THE SOFTWARE AND DOCUMENTATION ARE PROVIDED \"AS IS\". OPEN MARKET HAS NO LIABILITY IN CONTRACT, TORT, NEGLIGENCE OR OTHERWISE ARISING OUT OF THIS SOFTWARE OR THE DOCUMENTATION."],"licenseIds":["OML"],"keywords":["this fastcgi application","fastcgi application library","application library source","library source and","code the software","its documentation the","documentation the documentation","the documentation are","documentation are copyrighted","copyrighted by open","by open market","open market inc","market inc open","inc open market","open market the","market the following","documentation unless explicitly","individual files open","files open market","open market permits","market permits you","and the documentation","and documentation may","described here if","here if modifications","if modifications to","and documentation have","documentation have new","have new licensing","new licensing terms","licensing terms the","terms the new","new terms must","terms must be","they apply open","apply open market","open market makes","market makes no","makes no express","implied warranty with","warranty with respect","event shall open","shall open market","open market be","market be liable","limitation any indirect","damages or similar","or similar damages","similar damages including","lost profits or","profits or lost","or lost data","lost data even","even if open","if open market","market has been","damages the software","as is open","is open market","market has no","has no liability","liability in contract","contract tort negligence","tort negligence or","this fastcgi application library","fastcgi application library source","application library source and","library source and object","and object code the","object code the software","code the software and","and its documentation the","its documentation the documentation","documentation the documentation are","the documentation are copyrighted","documentation are copyrighted by","are copyrighted by open","copyrighted by open market","by open market inc","open market inc open","market inc open market","inc open market the","open market the following","market the following terms","with the software and","software and documentation unless","and documentation unless explicitly","documentation unless explicitly disclaimed","in individual files open","individual files open market","files open market permits","open market permits you","market permits you to","permits you to use","you to use copy","this software and the","software and the documentation","and the documentation for","the documentation for any","software and documentation may","and documentation may be","documentation may be copyrighted","terms described here if","described here if modifications","here if modifications to","if modifications to this","software and documentation have","and documentation have new","documentation have new licensing","have new licensing terms","new licensing terms the","licensing terms the new","terms the new terms","the new terms must","new terms must be","terms must be clearly","be clearly indicated on","where they apply open","they apply open market","apply open market makes","open market makes no","market makes no express","makes no express or","or implied warranty with","implied warranty with respect","warranty with respect to","no event shall open","event shall open market","shall open market be","open market be liable","market be liable to","party for any damages","damages arising from or","without limitation any indirect","limitation any indirect special","consequential damages or similar","damages or similar damages","or similar damages including","similar damages including lost","including lost profits or","lost profits or lost","profits or lost data","or lost data even","lost data even if","data even if open","even if open market","if open market has","open market has been","market has been advised","such damages the software","damages the software and","and documentation are provided","provided as is open","as is open market","is open market has","open market has no","market has no liability","has no liability in","no liability in contract","liability in contract tort","in contract tort negligence","contract tort negligence or","tort negligence or otherwise","out of this software","this fastcgi application library source","fastcgi application library source and","application library source and object","library source and object code","source and object code the","and object code the software","object code the software and","code the software and its","software and its documentation the","and its documentation the documentation","its documentation the documentation are","documentation the documentation are copyrighted","the documentation are copyrighted by","documentation are copyrighted by open","are copyrighted by open market","copyrighted by open market inc","by open market inc open","open market inc open market","market inc open market the","inc open market the following","open market the following terms","market the following terms apply","associated with the software and","with the software and documentation","the software and documentation unless","software and documentation unless explicitly","and documentation unless explicitly disclaimed","documentation unless explicitly disclaimed in","disclaimed in individual files open","in individual files open market","individual files open market permits","files open market permits you","open market permits you to","market permits you to use","permits you to use copy","you to use copy modify"]},{"licenseTexts":["OPEN PUBLIC LICENSE\n\nVersion 1.0\n\n   1. Definitions.\n\n      1.1. \"Contributor\" means each entity that creates or contributes to the creation of Modifications.\n\n      1.2. \"Contributor Version\" means the combination of the Original Code, prior Modifications used by a Contributor, and the Modifications made by that particular Contributor.\n\n      1.3. \"Covered Code\" means the Original Code or Modifications or the combination of the Original Code and Modifications, in each case including portions thereof.\n\n      1.4. \"Electronic Distribution Mechanism\" means a mechanism generally accepted in the software development community for the electronic transfer of data.\n\n      1.5. \"Executable\" means Covered Code in any form other than Source Code.\n\n      1.6. \"Initial Developer\" means the individual or entity identified as the Initial Developer in the Source Code notice required by Exhibit A.\n\n      1.7. \"Larger Work\" means a work, which combines Covered Code or portions thereof with code not governed by the terms of this License.\n\n      1.8. \"License\" means this document and the corresponding addendum described in section 6.4 below.\n\n      1.9. \"Modifications\" means any addition to or deletion from the substance or structure of either the Original Code or any previous Modifications. When Covered Code is released as a series of files, a Modification is:\n\n         A. Any addition to or deletion from the contents of a file containing Original Code or previous Modifications.\n\n         B. Any new file that contains any part of the Original Code or previous Modifications.\n\n      1.10. \"Original Code\" means Source Code of computer software code which is described in the Source Code notice required by Exhibit A as Original Code, and which, at the time of its release under this License is not already Covered Code governed by this License.\n\n      1.11. \"Source Code\" means the preferred form of the Covered Code for making modifications to it, including all modules it contains, plus any associated interface definition files, scripts used to control compilation and installation of an Executable, or a list of source code differential comparisons against either the Original Code or another well known, available Covered Code of the Contributor's choice. The Source Code can be in a compressed or archival form, provided the appropriate decompression or de-archiving software is widely available for no charge.\n\n      1.12. \"You\" means an individual or a legal entity exercising rights under, and complying with all of the terms of, this License or a future version of this License issued under Section 6.1. For legal entities, \"You'' includes any entity which controls, is controlled by, or is under common control with You. For purposes of this definition, \"control'' means (a) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (b) ownership of fifty percent (50%) or more of the outstanding shares or beneficial ownership of such entity.\n\n      1.13 \"License Author\" means Lutris Technologies, Inc.\n\n   2. Source Code License.\n\n      2.1. The Initial Developer Grant. The Initial Developer hereby grants You a worldwide, royalty-free, non-exclusive license, subject to third party intellectual property claims:\n\n         (a) under intellectual property rights (other than patent or trademark) to use, reproduce, modify, display, perform, sublicense and distribute the Original Code (or portions thereof) with or without Modifications, or as part of a Larger Work; and\n\n         (b) under patents now or hereafter owned or controlled by Initial Developer, to make, have made, use and sell (``offer to sell and import'') the Original Code (or portions thereof), but solely to the extent that any such patent is reasonably necessary to enable You to Utilize the Original Code (or portions thereof) and not to any greater extent that may be necessary to Utilize further Modifications or combinations.\n\n      2.2. Contributor Grant. Each Contributor hereby grants You a worldwide, royalty-free, non-exclusive license, subject to third party intellectual property claims:\n\n         (a) under intellectual property rights (other than patent or trademark) to use, reproduce, modify, display, perform, sublicense and distribute the Modifications created by such Contributor (or portions thereof) either on an unmodified basis, with other Modifications, as Covered Code or as part of a Larger Work; and\n\n         (b) under patents now or hereafter owned or controlled by Contributor, to to make, have made, use and sell (``offer to sell and import'') the Contributor Version (or portions thereof), but solely to the extent that any such patent is reasonably necessary to enable You to Utilize the Contributor Version (or portions thereof), and not to any greater extent that may be necessary to Utilize further Modifications or combinations\n\n   3. Distribution Obligations.\n\n      3.1. Application of License. The Modifications which You create or to which You contribute are governed by the terms of this License, including without limitation Section 2.2. The Source Code version of Covered Code may be distributed only under the terms of this License or a future version of this License released under Section 6.1, and You must include a copy of this License with every copy of the Source Code You distribute. You may not offer or impose any terms on any Source Code version that alters or restricts the applicable version of this License or the recipients' rights hereunder. However, You may include an additional document offering the additional rights described in Section 3.5.\n\n      3.2. Availability of Source Code. Any Modification which You create or to which You contribute must be made available, prior to any use, except for internal development and practice, in Source Code form under the terms of this License either on the same media as an Executable version or via an accepted Electronic Distribution Mechanism to anyone to whom you made an Executable version available; and if made available via Electronic Distribution Mechanism, must remain available for at least twelve (12) months after the date it initially became available, or at least six (6) months after a subsequent version of that particular Modification has been made available to such recipients. You shall notify the Initial Developer of the Modification and the location of the Source Code via the contact means provided for in the Developer Specific license. Initial Developer will be acting as maintainer of the Source Code and may provide an Electronic Distribution mechanism for the Modification to be made available.\n\n      3.3. Description of Modifications. You must cause all Covered Code to which you contribute to contain a file documenting the changes You made to create that Covered Code and the date of any change. You must include a prominent statement that the Modification is derived, directly or indirectly, from Original Code provided by the Initial Developer and including the name of the Initial Developer in (a) the Source Code, and (b) in any notice in an Executable version or related documentation in which You describe the origin or ownership of the Covered Code.\n\n      3.4. Intellectual Property Matters\n\n         (a) Third Party Claims. If You have knowledge that a party claims an intellectual property right in particular functionality or code (or its utilization under this License), you must include a text file with the source code distribution titled \"LEGAL\" which describes the claim and the party making the claim in sufficient detail that a recipient will know whom to contact. If you obtain such knowledge after You make Your Modification available as described in Section 3.2, You shall promptly modify the LEGAL file in all copies You make available thereafter and shall take other steps (such as notifying appropriate mailing lists or newsgroups) reasonably calculated to inform those who received the Covered Code that new knowledge has been obtained.\n\n         (b) Representations. Contributor represents that, except as disclosed pursuant to Section 3.4(a) above, Contributor believes that Contributor's Modifications are Contributor's original creation(s) and/or Contributor has sufficient rights to grant the rights conveyed by this License.\n\n      3.5. Required Notices. You must duplicate the notice in Exhibit A in each file of the Source Code, and this License in any documentation for the Source Code, where You describe recipients' rights relating to Covered Code. If You created one or more Modification(s), You may add your name as a Contributor to the notice described in Exhibit A. If it is not possible to put such notice in a particular Source Code file due to its structure, then you must include such notice in a location (such as a relevant directory file) where a user would be likely to look for such a notice. You may choose to offer, and to charge a fee for, warranty, support, indemnity or liability obligations to one or more recipients of Covered Code. However, You may do so only on Your own behalf, and not on behalf of the Initial Developer or any Contributor. You must make it absolutely clear that any such warranty, support, indemnity or liability obligation is offered by You alone, and You hereby agree to indemnify the Initial Developer and every Contributor for any liability incurred by the Initial Developer or such Contributor as a result of warranty, support, indemnity or liability terms You offer.\n\n      3.6. Distribution of Executable Versions. You may distribute Covered Code in Executable form only if the requirements of Section 3.1-3.5 have been met for that Covered Code, and if You include a notice stating that the Source Code version of the Covered Code is available under the terms of this License, including a description of how and where You have fulfilled the obligations of Section 3.2. The notice must be conspicuously included in any notice in an Executable version, related documentation or collateral in which You describe recipients' rights relating to the Covered Code. You may distribute the Executable version of Covered Code under a license of Your choice, which may contain terms different from this License, provided that You are in compliance with the terms of this License and that the license for the Executable version does not attempt to limit or alter the recipient's rights in the Source Code version from the rights set forth in this License. If You distribute the Executable version under a different license You must make it absolutely clear that any terms which differ from this License are offered by You alone, not by the Initial Developer or any Contributor. You hereby agree to indemnify the Initial Developer and every Contributor for any liability incurred by the Initial Developer or such Contributor as a result of any such terms You offer. If you distribute executable versions containing Covered Code, you must reproduce the notice in Exhibit B in the documentation and/or other materials provided with the product.\n\n      3.7. Larger Works. You may create a Larger Work by combining Covered Code with other code not governed by the terms of this License and distribute the Larger Work as a single product. In such a case, You must make sure the requirements of this License are fulfilled for the Covered Code.\n\n   4. Inability to Comply Due to Statute or Regulation.\n\n   If it is impossible for You to comply with any of the terms of this License with respect to some or all of the Covered Code due to statute or regulation then You must: (a) comply with the terms of this License to the maximum extent possible; and (b) Cite all of the statutes or regulations that prohibit you from complying fully with this license. (c) describe the limitations and the code they affect. Such description must be included in the LEGAL file described in Section 3.4 and must be included with all distributions of the Source Code. Except to the extent prohibited by statute or regulation, such description must be sufficiently detailed for a recipient of ordinary skill to be able to understand it.\n\n   5. Application of this License.\n\n   This License applies to code to which the Initial Developer has attached the notice in Exhibit A, and to related Covered Code.\n\n   6. Versions of the License.\n\n      6.1. New Versions. License Author may publish revised and/or new versions of the License from time to time. Each version will be given a distinguishing version number and shall be submitted to opensource.org for certification.\n\n      6.2. Effect of New Versions. Once Covered Code has been published under a particular version of the License, You may always continue to use it under the terms of that version. You may also choose to use such Covered Code under the terms of any subsequent version of the License published by Initial Developer. No one other than Initial Developer has the right to modify the terms applicable to Covered Code created under this License.\n\n      6.3. Derivative Works. If you create or use a modified version of this License, except in association with the required Developer Specific License described in section 6.4, (which you may only do in order to apply it to code which is not already Covered Code governed by this License), you must (a) rename Your license so that the phrases ``Open'', ``OpenPL'', ``OPL'' or any confusingly similar phrase do not appear anywhere in your license and (b) otherwise make it clear that your version of the license contains terms which differ from the Open Public License. (Filling in the name of the Initial Developer, Original Code or Contributor in the notice described in Exhibit A shall not of themselves be deemed to be modifications of this License.)\n\n      6.4. Required Additional Developer Specific License\n\n      This license is a union of the following two parts that should be found as text files in the same place (directory), in the order of preeminence:\n\n         [1] A Developer specific license.\n\n         [2] The contents of this file OPL_1_0.TXT, stating the general licensing policy of the software.\n\n      In case of conflicting dispositions in the parts of this license, the terms of the lower-numbered part will always be superseded by the terms of the higher numbered part.\n\n   7. DISCLAIMER OF WARRANTY.\n\n   COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN \"AS IS\" BASIS, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER.\n\n   8. TERMINATION.\n\n      8.1 Termination upon Breach\n\n      This License and the rights granted hereunder will terminate automatically if You fail to comply with terms herein and fail to cure such breach within 30 days of becoming aware of the breach. All sublicenses to the Covered Code, which are properly granted, shall survive any termination of this License. Provisions that, by their nature, must remain in effect beyond the termination of this License shall survive.\n\n      8.2. Termination Upon Litigation. If You initiate litigation by asserting a patent infringement claim (excluding declatory judgment actions) against Initial Developer or a Contributor (the Initial Developer or Contributor against whom You file such action is referred to as \"Participant\") alleging that:\n\n         (a) such Participant's Contributor Version directly or indirectly infringes any patent, then any and all rights granted by such Participant to You under Sections 2.1 and/or 2.2 of this License shall, upon 60 days notice from Participant terminate prospectively, unless if within 60 days after receipt of notice You either: (i) agree in writing to pay Participant a mutually agreeable reasonable royalty for Your past and future use of Modifications made by such Participant, or (ii) withdraw Your litigation claim with respect to the Contributor Version against such Participant. If within 60 days of notice, a reasonable royalty and payment arrangement are not mutually agreed upon in writing by the parties or the litigation claim is not withdrawn, the rights granted by Participant to You under Sections 2.1 and/or 2.2 automatically terminate at the expiration of the 60 day notice period specified above.\n\n         (b) any software, hardware, or device, other than such Participant's Contributor Version, directly or indirectly infringes any patent, then any rights granted to You by such Participant under Sections 2.1(b) and 2.2(b) are revoked effective as of the date You first made, used, sold, distributed, or had made, Modifications made by that Participant.\n\n      8.3. If You assert a patent infringement claim against Participant alleging that such Participant's Contributor Version directly or indirectly infringes any patent where such claim is resolved (such as by license or settlement) prior to the initiation of patent infringement litigation, then the reasonable value of the licenses granted by such Participant under Sections 2.1 or 2.2 shall be taken into account in determining the amount or value of any payment or license.\n\n      8.4. In the event of termination under Sections 8.1 or 8.2 above, all end user license agreements (excluding distributors and resellers) which have been validly granted by You or any distributor hereunder prior to termination shall survive termination.\n\n   9. LIMITATION OF LIABILITY.\n\n   UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER TORT (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL THE INITIAL DEVELOPER, ANY OTHER CONTRIBUTOR, OR ANY DISTRIBUTOR OF COVERED CODE, OR ANY SUPPLIER OF ANY OF SUCH PARTIES, BE LIABLE TO YOU OR ANY OTHER PERSON FOR ANY INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, COMPUTER FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER COMMERCIAL DAMAGES OR LOSSES, EVEN IF SUCH PARTY SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF LIABILITY SHALL NOT APPLY TO LIABILITY FOR DEATH OR PERSONAL INJURY RESULTING FROM SUCH PARTY'S NEGLIGENCE TO THE EXTENT APPLICABLE LAW PROHIBITS SUCH LIMITATION. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OR LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THAT EXCLUSION AND LIMITATION MAY NOT APPLY TO YOU.\n\n   10. U.S. GOVERNMENT END USERS.\n\n   The Covered Code is a ``commercial item,'' as that term is defined in 48 C.F.R. 2.101 (Oct. 1995), consisting of ``commercial computer software'' and ``commercial computer software documentation,'' as such terms are used in 48 C.F.R. 12.212 (Sept. 1995). Consistent with 48 C.F.R. 12.212 and 48 C.F.R. 227.7202-1 through 227.7202-4 (June 1995), all U.S. Government End Users acquire Covered Code with only those rights set forth herein.\n\n   11. MISCELLANEOUS.\n\n   his section was intentionally left blank. The contents of this section are found in the corresponding addendum described above.\n\n   12. RESPONSIBILITY FOR CLAIMS.\n\nExcept in cases where another Contributor has failed to comply with Section 3.4, You are responsible for damages arising, directly or indirectly, out of Your utilization of rights under this License, based on the number of copies of Covered Code you made available, the revenues you received from utilizing such rights, and other relevant factors. You agree to work with affected parties to distribute with Initial Developer responsibility on an equitable basis. EXHIBIT A.\n\nText for this Exhibit A is found in the corresponding addendum, described in section 6.4 above, text file provided by the Initial Developer. This license is not valid or complete with out that file.\n\nEXHIBIT B.\n\nText for this Exhibit B is found in the corresponding addendum, described in section 6.4 above, text file provided by the Initial Developer. This license is not valid or complete with out that file."],"licenseIds":["OPL-1.0"],"keywords":["document and the","6 4 below","4 below 1","below 1 9","1 13 license","13 license author","license author means","author means lutris","means lutris technologies","lutris technologies inc","technologies inc 2","inc 2 source","contributor to to","to to make","made available prior","available prior to","prior to any","any use except","use except for","except for internal","for internal development","internal development and","development and practice","and practice in","practice in source","recipients you shall","you shall notify","shall notify the","source code via","code via the","via the contact","the contact means","contact means provided","means provided for","for in the","in the developer","the developer specific","specific license initial","initial developer will","developer will be","code and may","made available 3","available 3 3","obtained b representations","b representations contributor","and b cite","b cite all","cite all of","of the statutes","the statutes or","statutes or regulations","or regulations that","regulations that prohibit","that prohibit you","prohibit you from","you from complying","from complying fully","complying fully with","fully with this","license c describe","new versions license","versions license author","license author may","author may publish","number and shall","submitted to opensource","to opensource org","opensource org for","org for certification","for certification 6","certification 6 2","initial developer no","developer no one","other than initial","than initial developer","developer has the","license except in","except in association","in association with","association with the","with the required","the required developer","required developer specific","specific license described","license described in","6 4 which","4 which you","the phrases open","phrases open openpl","open openpl opl","openpl opl or","opl or any","from the open","the open public","4 required additional","required additional developer","additional developer specific","specific license this","is a union","a union of","following two parts","two parts that","parts that should","that should be","should be found","be found as","found as text","as text files","text files in","same place directory","place directory in","directory in the","in the order","the order of","order of preeminence","of preeminence 1","preeminence 1 a","1 a developer","a developer specific","specific license 2","license 2 the","2 the contents","this file opl","file opl 1","opl 1 0","1 0 txt","0 txt stating","txt stating the","stating the general","the general licensing","general licensing policy","licensing policy of","policy of the","software in case","case of conflicting","of conflicting dispositions","conflicting dispositions in","dispositions in the","in the parts","of the lower","the lower numbered","lower numbered part","numbered part will","part will always","will always be","always be superseded","be superseded by","superseded by the","of the higher","the higher numbered","higher numbered part","numbered part 7","part 7 disclaimer","8 1 termination","1 termination upon","8 2 termination","termination upon litigation","upon litigation if","11 miscellaneous his","miscellaneous his section","his section was","section was intentionally","was intentionally left","intentionally left blank","blank the contents","this section are","section are found","are found in","addendum described above","described above 12","above 12 responsibility","to distribute with","distribute with initial","initial developer responsibility","developer responsibility on","exhibit a text","a text for","a is found","that file exhibit","file exhibit b","exhibit b text","b text for","this exhibit b","exhibit b is","b is found","open public license version","means this document and","this document and the","document and the corresponding","and the corresponding addendum","section 6 4 below","6 4 below 1","4 below 1 9","below 1 9 modifications","entity 1 13 license","1 13 license author","13 license author means","license author means lutris","author means lutris technologies","means lutris technologies inc"]},{"licenseTexts":["OSET Public License (c) 2015 ALL RIGHTS RESERVED VERSION 2.1 THIS LICENSE DEFINES THE RIGHTS OF USE, REPRODUCTION, DISTRIBUTION, MODIFICATION, AND REDISTRIBUTION OF CERTAIN COVERED SOFTWARE (AS DEFINED BELOW) ORIGINALLY RELEASED BY THE OPEN SOURCE ELECTION TECHNOLOGY FOUNDATION (FORMERLY \"THE OSDV FOUNDATION\").\n\nANYONE WHO USES, REPRODUCES, DISTRIBUTES, MODIFIES, OR REDISTRIBUTES THE COVERED SOFTWARE, OR ANY PART THEREOF, IS BY THAT ACTION, ACCEPTING IN FULL THE TERMS CONTAINED IN THIS AGREEMENT. IF YOU DO NOT AGREE TO SUCH TERMS, YOU ARE NOT PERMITTED TO USE THE COVERED SOFTWARE. This license was prepared based on the Mozilla Public License (\"MPL\"), version 2.0. For annotation of the differences between this license and MPL 2.0, please see the OSET Foundation web site at www.OSETFoundation.org/public-license.\n\nThe text of the license begins here:\n\n   1. Definitions\n\n      1.1 \"Contributor\" means each individual or legal entity that creates, contributes to the creation of, or owns Covered Software.\n\n      1.2 \"Contributor Version\" means the combination of the Contributions of others (if any) used by a Contributor and that particular Contributor's Contribution.\n\n      1.3 \"Contribution\" means Covered Software of a particular Contributor.\n\n      1.4 \"Covered Software\" means Source Code Form to which the initial Contributor has attached the notice in Exhibit A, the Executable Form of such Source Code Form, and Modifications of such Source Code Form, in each case including portions thereof.\n\n      1.5 \"Incompatible With Secondary Licenses\" means:\n\n         a. That the initial Contributor has attached the notice described in Exhibit B to the Covered Software; or\n\n         b. that the Covered Software was made available under the terms of version 1.x or earlier of the License, but not also under the terms of a Secondary License.\n\n      1.6 \"Executable Form\" means any form of the work other than Source Code Form.\n\n      1.7 \"Larger Work\" means a work that combines Covered Software with other material, in a separate file (or files) that is not Covered Software.\n\n      1.8 \"License\" means this document.\n\n      1.9 \"Licensable\" means having the right to grant, to the maximum extent possible, whether at the time of the initial grant or subsequently, any and all of the rights conveyed by this License.\n\n      1.10 \"Modifications\" means any of the following:\n\n         a. any file in Source Code Form that results from an addition to, deletion from, or modification of the contents of Covered Software; or\n\n         b. any new file in Source Code Form that contains any Covered Software.\n\n      1.11 \"Patent Claims\" of a Contributor means any patent claim(s), including without limitation, method, process, and apparatus claims, in any patent Licensable by such Contributor that would be infringed, but for the grant of the License, by the making, using, selling, offering for sale, having made, import, or transfer of either its Contributions or its Contributor Version.\n\n      1.12 \"Secondary License\" means one of: the GNU General Public License, Version 2.0, the GNU Lesser General Public License, Version 2.1, the GNU Affero General Public License, Version 3.0, or any later versions of those licenses.\n\n      1.13 \"Source Code Form\" means the form of the work preferred for making modifications.\n\n      1.14 \"You\" (or \"Your\") means an individual or a legal entity exercising rights under this License. For legal entities, \"You\" includes any entity that controls, is controlled by, or is under common control with You. For purposes of this definition, \"control\" means:\n\n         (a) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or\n\n         (b) ownership of more than fifty percent (50%) of the outstanding shares or beneficial ownership of such entity.\n\n   2. License Grants and Conditions\n\n      2.1 Grants\n\n      Each Contributor hereby grants You a world-wide, royalty-free, non-exclusive license:\n\n         a. under intellectual property rights (other than patent or trademark) Licensable by such Contributor to use, reproduce, make available, modify, display, perform, distribute, and otherwise exploit its Contributions, either on an unmodified basis, with Modifications, or as part of a Larger Work; and\n\n         b. under Patent Claims of such Contributor to make, use, sell, offer for sale, have made, import, and otherwise transfer either its Contributions or its Contributor Version.\n\n      2.2 Effective Date\n\n      The licenses granted in Section 2.1 with respect to any Contribution become effective for each Contribution on the date the Contributor first distributes such Contribution.\n\n      2.3 Limitations on Grant Scope\n\n      The licenses granted in this Section 2 are the only rights granted under this License. No additional rights or licenses will be implied from the distribution or licensing of Covered Software under this License. Notwithstanding Section 2.1(b) above, no patent license is granted by a Contributor:\n\n         a. for any code that a Contributor has removed from Covered Software; or\n\n         b. for infringements caused by: (i) Your and any other third party's modifications of Covered Software, or (ii) the combination of its Contributions with other software (except as part of its Contributor Version); or\n\n         c. under Patent Claims infringed by Covered Software in the absence of its Contributions.\n\n      This License does not grant any rights in the trademarks, service marks, or logos of any Contributor (except as may be necessary to comply with the notice requirements in Section 3.4).\n\n      2.4 Subsequent Licenses\n\n      No Contributor makes additional grants as a result of Your choice to distribute the Covered Software under a subsequent version of this License (see Section 10.2) or under the terms of a Secondary License (if permitted under the terms of Section 3.3).\n\n      2.5 Representation\n\n      Each Contributor represents that the Contributor believes its Contributions are its original creation(s) or it has sufficient rights to grant the rights to its Contributions conveyed by this License.\n\n      2.6 Fair Use\n\n      This License is not intended to limit any rights You have under applicable copyright doctrines of fair use, fair dealing, or other equivalents.\n\n      2.7 Conditions\n\n      Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted in Section 2.1.\n\n   3. Responsibilities\n\n      3.1 Distribution of Source Form\n\n      All distribution of Covered Software in Source Code Form, including any Modifications that You create or to which You contribute, must be under the terms of this License. You must inform recipients that the Source Code Form of the Covered Software is governed by the terms of this License, and how they can obtain a copy of this License. You must cause any of Your Modifications to carry prominent notices stating that You changed the files. You may not attempt to alter or restrict the recipients' rights in the Source Code Form.\n\n      3.2 Distribution of Executable Form\n\n      If You distribute Covered Software in Executable Form then:\n\n         a. such Covered Software must also be made available in Source Code Form, as described in Section 3.1, and You must inform recipients of the Executable Form how they can obtain a copy of such Source Code Form by reasonable means in a timely manner, at a charge no more than the cost of distribution to the recipient; and\n\n         b. You may distribute such Executable Form under the terms of this License, or sublicense it under different terms, provided that the license for the Executable Form does not attempt to limit or alter the recipients' rights in the Source Code Form under this License.\n\n      3.3 Distribution of a Larger Work\n\n      You may create and distribute a Larger Work under terms of Your choice, provided that You also comply with the requirements of this License for the Covered Software. If the Larger Work is a combination of Covered Software with a work governed by one or more Secondary Licenses, and the Covered Software is not Incompatible With Secondary Licenses, this License permits You to additionally distribute such Covered Software under the terms of such Secondary License(s), so that the recipient of the Larger Work may, at their option, further distribute the Covered Software under the terms of either this License or such Secondary License(s).\n\n      3.4 Notices\n\n      You may not remove or alter the substance of any license notices (including copyright notices, patent notices, disclaimers of warranty, or limitations of liability) contained within the Source Code Form of the Covered Software, except that You may alter any license notices to the extent required to remedy known factual inaccuracies.\n\n      3.5 Application of Additional Terms\n\n         3.5.1 You may choose to offer, and to charge a fee for, warranty, support, indemnity or liability obligations to one or more recipients of Covered Software. However, You may do so only on Your own behalf, and not on behalf of any Contributor. You must make it absolutely clear that any such warranty, support, indemnity, or liability obligation is offered by You alone, and You hereby agree to indemnify every Contributor for any liability incurred by such Contributor as a result of warranty, support, indemnity or liability terms You offer. You may include additional disclaimers of warranty and limitations of liability specific to any jurisdiction.\n\n         3.5.2 You may place additional conditions upon the rights granted in this License to the extent necessary due to statute, judicial order, regulation (including without limitation state and federal procurement regulation), national security, or public interest. Any such additional conditions must be clearly described in the notice provisions required under Section 3.4. Any alteration of the terms of this License will apply to all copies of the Covered Software distributed by You or by any downstream recipients that receive the Covered Software from You.\n\n   4. Inability to Comply Due to Statute or Regulation\n\n   If it is impossible for You to comply with any of the terms of this License with respect to some or all of the Covered Software due to statute, judicial order, or regulation, then You must: (a) comply with the terms of this License to the maximum extent possible; and (b) describe the limitations and the code they affect. Such description must be included in the notices required under Section 3.4. Except to the extent prohibited by statute or regulation, such description must be sufficiently detailed for a recipient of ordinary skill to be able to understand it.\n\n   5. Termination\n\n      5.1 Failure to Comply\n\n      The rights granted under this License will terminate automatically if You fail to comply with any of its terms. However, if You become compliant, then the rights granted under this License from a particular Contributor are reinstated (a) provisionally, unless and until such Contributor explicitly and finally terminates Your grants, and (b) on an ongoing basis, if such Contributor fails to notify You of the non-compliance by some reasonable means prior to 60-days after You have come back into compliance. Moreover, Your grants from a particular Contributor are reinstated on an ongoing basis if such Contributor notifies You of the non-compliance by some reasonable means, this is the first time You have received notice of non-compliance with this License from such Contributor, and You become compliant prior to 30-days after Your receipt of the notice.\n\n      5.2 Patent Infringement Claims\n\n      If You initiate litigation against any entity by asserting a patent infringement claim (excluding declaratory judgment actions, counter-claims, and cross-claims ) alleging that a Contributor Version directly or indirectly infringes any patent, then the rights granted to You by any and all Contributors for the Covered Software under Section 2.1 of this License shall terminate.\n\n      5.3 Additional Compliance Terms\n\n      Notwithstanding the foregoing in this Section 5, for purposes of this Section, if You breach Section 3.1 (Distribution of Source Form), Section 3.2 (Distribution of Executable Form), Section 3.3 (Distribution of a Larger Work), or Section 3.4 (Notices), then becoming compliant as described in Section 5.1 must also include, no later than 30 days after receipt by You of notice of such violation by a Contributor, making the Covered Software available in Source Code Form as required by this License on a publicly available computer network for a period of no less than three (3) years.\n\n      5.4 Contributor Remedies\n\n      If You fail to comply with the terms of this License and do not thereafter become compliant in accordance with Section 5.1 and, if applicable, Section 5.3, then each Contributor reserves its right, in addition to any other rights it may have in law or in equity, to bring an action seeking injunctive relief, or damages for willful copyright or patent infringement (including without limitation damages for unjust enrichment, where available under law), for all actions in violation of rights that would otherwise have been granted under the terms of this License.\n\n      5.5 End User License Agreements\n\n      In the event of termination under this Section 5, all end user license agreements (excluding distributors and resellers), which have been validly granted by You or Your distributors under this License prior to termination shall survive termination.\n\n   6. Disclaimer of Warranty\n\n   Covered Software is provided under this License on an \"as is\" basis, without warranty of any kind, either expressed, implied, or statutory, including, without limitation, warranties that the Covered Software is free of defects, merchantable, fit for a particular purpose or non-infringing. The entire risk as to the quality and performance of the Covered Software is with You. Should any Covered Software prove defective in any respect, You (not any Contributor) assume the cost of any necessary servicing, repair, or correction. This disclaimer of warranty constitutes an essential part of this License. No use of any Covered Software is authorized under this License except under this disclaimer.\n\n   7. Limitation of Liability\n\n   Under no circumstances and under no legal theory, whether tort (including negligence), contract, or otherwise, shall any Contributor, or anyone who distributes Covered Software as permitted above, be liable to You for any direct, indirect, special, incidental, or consequential damages of any character including, without limitation, damages for lost profits, loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses, even if such party shall have been informed of the possibility of such damages. This limitation of liability shall not apply to liability for death or personal injury resulting from such party's negligence to the extent applicable law prohibits such limitation. Some jurisdictions do not allow the exclusion or limitation of incidental or consequential damages, so this exclusion and limitation may not apply to You.\n\n   8. Litigation\n\n   Any litigation relating to this License may be brought only in the courts of a jurisdiction where the defendant maintains its principal place of business and such litigation shall be governed by laws of that jurisdiction, without reference to its conflict-of-law provisions. Nothing in this Section shall prevent a party's ability to bring cross-claims or counter-claims.\n\n   9. Government Terms\n\n      9.1 Commercial Item\n\n      The Covered Software is a \"commercial item,\" as that term is defined in 48 C.F.R. 2.101 (Oct. 1995), consisting of \"commercial computer software\" and \"commercial computer software documentation,\" as such terms are used in 48 C.F.R. 12.212 (Sept. 1995). Consistent with 48 C.F.R. 12.212 and 48 C.F.R. 227.7202-1 through 227.7202-4 (June 1995), all U.S. Government End Users acquire Covered Software with only those rights set forth herein.\n\n      9.2 No Sovereign Immunity\n\n      The U.S. federal government and states that use or distribute Covered Software hereby waive their sovereign immunity with respect to enforcement of the provisions of this License.\n\n      9.3 Choice of Law and Venue\n\n         9.3.1 If You are a government of a state of the United States, or Your use of the Covered Software is pursuant to a procurement contract with such a state government, this License shall be governed by the law of such state, excluding its conflict-of-law provisions, and the adjudication of disputes relating to this License will be subject to the exclusive jurisdiction of the state and federal courts located in such state.\n\n         9.3.2 If You are an agency of the United States federal government, or Your use of the Covered Software is pursuant to a procurement contract with such an agency, this License shall be governed by federal law for all purposes, and the adjudication of disputes relating to this License will be subject to the exclusive jurisdiction of the federal courts located in Washington, D.C.\n\n         9.3.3 You may alter the terms of this Section 9.3 for this License as described in Section 3.5.2.\n\n      9.4 Supremacy\n\n      This Section 9 is in lieu of, and supersedes, any other Federal Acquisition Regulation, Defense Federal Acquisition Regulation, or other clause or provision that addresses government rights in computer software under this License.\n\n   10. Miscellaneous\n\n   This License represents the complete agreement concerning the subject matter hereof. If any provision of this License is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable. Any law or regulation, which provides that the language of a contract shall be construed against the drafter, shall not be used to construe this License against a Contributor.\n\n   11. Versions of the License\n\n      11.1 New Versions\n\n      The Open Source Election Technology Foundation (\"OSET\") (formerly known as the Open Source Digital Voting Foundation) is the steward of this License. Except as provided in Section 11.3, no one other than the license steward has the right to modify or publish new versions of this License. Each version will be given a distinguishing version number.\n\n      11.2 Effects of New Versions\n\n      You may distribute the Covered Software under the terms of the version of the License under which You originally received the Covered Software, or under the terms of any subsequent version published by the license steward.\n\n      11.3 Modified Versions\n\n      If You create software not governed by this License, and You want to create a new license for such software, You may create and use a modified version of this License if You rename the license and remove any references to the name of the license steward (except to note that such modified license differs from this License).\n\n      11.4 Distributing Source Code Form That is Incompatible With Secondary Licenses\n\n      If You choose to distribute Source Code Form that is Incompatible With Secondary Licenses under the terms of this version of the License, the notice described in Exhibit B of this License must be attached. EXHIBIT A - Source Code Form License Notice\n\nThis Source Code Form is subject to the terms of the OSET Public License, v.2.1 (\"OPL\"). If a copy of the OPL was not distributed with this file, You can obtain one at: www.OSETFoundation.org/public-license.\n\nIf it is not possible or desirable to put the Notice in a particular file, then You may include the Notice in a location (e.g., such as a LICENSE file in a relevant directory) where a recipient would be likely to look for such a notice. You may add additional accurate notices of copyright ownership. EXHIBIT B - \"Incompatible With Secondary License\" Notice\n\nThis Source Code Form is \"Incompatible With Secondary Licenses\", as defined by the OSET Public License, v.2.1."],"licenseIds":["OSET-PL-2.1"],"keywords":["license c 2015","c 2015 all","2015 all rights","rights reserved version","reserved version 2","this license defines","license defines the","of certain covered","certain covered software","defined below originally","below originally released","technology foundation formerly","foundation formerly the","formerly the osdv","the osdv foundation","osdv foundation anyone","foundation anyone who","redistributes the covered","full the terms","the terms contained","terms contained in","agree to such","to such terms","terms you are","covered software this","license was prepared","was prepared based","prepared based on","public license mpl","license mpl version","mpl version 2","0 for annotation","for annotation of","annotation of the","of the differences","differences between this","between this license","license and mpl","and mpl 2","2 0 please","0 please see","see the oset","the oset foundation","oset foundation web","foundation web site","web site at","site at www","the license begins","license begins here","begins here 1","here 1 definitions","version 1 x","1 x or","x or earlier","license means one","means one of","cause any of","modifications to carry","the files you","files you may","additional terms 3","terms 3 5","3 5 1","any jurisdiction 3","jurisdiction 3 5","place additional conditions","additional conditions upon","conditions upon the","upon the rights","extent necessary due","necessary due to","judicial order regulation","order regulation including","regulation including without","without limitation state","limitation state and","and federal procurement","federal procurement regulation","procurement regulation national","regulation national security","national security or","security or public","or public interest","public interest any","interest any such","additional conditions must","be clearly described","clearly described in","the notice provisions","notice provisions required","provisions required under","3 4 any","4 any alteration","covered software distributed","software distributed by","by any downstream","any downstream recipients","downstream recipients that","that receive the","covered software from","from you 4","you 4 inability","in the notices","the notices required","notices required under","3 4 except","4 except to","5 1 failure","1 failure to","to comply the","comply the rights","5 2 patent","2 patent infringement","patent infringement claims","infringement claims if","5 3 additional","3 additional compliance","additional compliance terms","compliance terms notwithstanding","terms notwithstanding the","foregoing in this","section 5 for","5 for purposes","this section if","section if you","you breach section","breach section 3","source form section","executable form section","work or section","or section 3","4 notices then","notices then becoming","then becoming compliant","becoming compliant as","compliant as described","5 1 must","1 must also","also include no","include no later","later than 30","than 30 days","after receipt by","receipt by you","you of notice","of notice of","such violation by","violation by a","a contributor making","contributor making the","software available in","form as required","publicly available computer","available computer network","computer network for","network for a","period of no","of no less","less than three","than three 3","three 3 years","3 years 5","years 5 4","5 4 contributor","4 contributor remedies","contributor remedies if","remedies if you","license and do","do not thereafter","not thereafter become","thereafter become compliant","become compliant in","compliant in accordance","with section 5","5 1 and","1 and if","if applicable section","applicable section 5","section 5 3","5 3 then","3 then each","then each contributor","each contributor reserves","contributor reserves its","reserves its right","its right in","right in addition","other rights it","rights it may","have in law","in law or","law or in","or in equity","in equity to","equity to bring","to bring an","bring an action","an action seeking","action seeking injunctive","seeking injunctive relief"]},{"licenseTexts":["The Open Software License v. 1.0\n\nThis Open Software License (the \"License\") applies to any original work of authorship (the \"Original Work\") whose owner (the \"Licensor\") has placed the following notice immediately following the copyright notice for the Original Work:\n\n\"Licensed under the Open Software License version 1.0\"\n\nLicense Terms\n\n   1) Grant of Copyright License. Licensor hereby grants You a world-wide, royalty-free, non-exclusive, perpetual, non-sublicenseable license to do the following:\n\n      a) to reproduce the Original Work in copies;\n\n      b) to prepare derivative works (\"Derivative Works\") based upon the Original Work;\n\n      c) to distribute copies of the Original Work and Derivative Works to the public, with the proviso that copies of Original Work or Derivative Works that You distribute shall be licensed under the Open Software License;\n\n      d) to perform the Original Work publicly; and\n\n      e) to display the Original Work publicly.\n\n   2) Grant of Patent License. Licensor hereby grants You a world-wide, royalty-free, non-exclusive, perpetual, non-sublicenseable license, under patent claims owned or controlled by the Licensor that are embodied in the Original Work as furnished by the Licensor (\"Licensed Claims\") to make, use, sell and offer for sale the Original Work. Licensor hereby grants You a world-wide, royalty-free, non-exclusive, perpetual, non-sublicenseable license under the Licensed Claims to make, use, sell and offer for sale Derivative Works.\n\n   3) Grant of Source Code License. The term \"Source Code\" means the preferred form of the Original Work for making modifications to it and all available documentation describing how to access and modify the Original Work. Licensor hereby agrees to provide a machine-readable copy of the Source Code of the Original Work along with each copy of the Original Work that Licensor distributes. Licensor reserves the right to satisfy this obligation by placing a machine-readable copy of the Source Code in an information repository reasonably calculated to permit inexpensive and convenient access by You for as long as Licensor continues to distribute the Original Work, and by publishing the address of that information repository in a notice immediately following the copyright notice that applies to the Original Work.\n\n   4) Exclusions From License Grant. Nothing in this License shall be deemed to grant any rights to trademarks, copyrights, patents, trade secrets or any other intellectual property of Licensor except as expressly stated herein. No patent license is granted to make, use, sell or offer to sell embodiments of any patent claims other than the Licensed Claims defined in Section 2. No right is granted to the trademarks of Licensor even if such marks are included in the Original Work. Nothing in this License shall be interpreted to prohibit Licensor from licensing under different terms from this License any Original Work that Licensor otherwise would have a right to license.\n\n   5) External Deployment. The term \"External Deployment\" means the use or distribution of the Original Work or Derivative Works in any way such that the Original Work or Derivative Works may be accessed or used by anyone other than You, whether the Original Work or Derivative Works are distributed to those persons, made available as an application intended for use over a computer network, or used to provide services or otherwise deliver content to anyone other than You. As an express condition for the grants of license hereunder, You agree that any External Deployment by You shall be deemed a distribution and shall be licensed to all under the terms of this License, as prescribed in section 1(c) herein.\n\n   6) Warranty and Disclaimer of Warranty. LICENSOR WARRANTS THAT THE COPYRIGHT IN AND TO THE ORIGINAL WORK IS OWNED BY THE LICENSOR OR THAT THE ORIGINAL WORK IS DISTRIBUTED BY LICENSOR UNDER A VALID CURRENT LICENSE FROM THE COPYRIGHT OWNER. EXCEPT AS EXPRESSLY STATED IN THE IMMEDIATELY PRECEEDING SENTENCE, THE ORIGINAL WORK IS PROVIDED UNDER THIS LICENSE ON AN \"AS IS\" BASIS, WITHOUT WARRANTY, EITHER EXPRESS OR IMPLIED, INCLUDING, WITHOUT LIMITATION, THE WARRANTY OF NON-INFRINGEMENT AND WARRANTIES THAT THE ORIGINAL WORK IS MERCHANTABLE OR FIT FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY OF THE ORIGINAL WORK IS WITH YOU. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. NO LICENSE TO ORIGINAL WORK IS GRANTED HEREUNDER EXCEPT UNDER THIS DISCLAIMER.\n\n   7) Limitation of Liability. UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER TORT (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL THE LICENSOR BE LIABLE TO ANY PERSON FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER ARISING AS A RESULT OF THIS LICENSE OR THE USE OF THE ORIGINAL WORK INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, COMPUTER FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER COMMERCIAL DAMAGES OR LOSSES, EVEN IF SUCH PERSON SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF LIABILITY SHALL NOT APPLY TO LIABILITY FOR DEATH OR PERSONAL INJURY RESULTING FROM SUCH PARTY'S NEGLIGENCE TO THE EXTENT APPLICABLE LAW PROHIBITS SUCH LIMITATION. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OR LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THIS EXCLUSION AND LIMITATION MAY NOT APPLY TO YOU.\n\n   8) Acceptance and Termination. Nothing else but this License (or another written agreement between Licensor and You) grants You permission to create Derivative Works based upon the Original Work, and any attempt to do so except under the terms of this License (or another written agreement between Licensor and You) is expressly prohibited by U.S. copyright law, the equivalent laws of other countries, and by international treaty. Therefore, by exercising any of the rights granted to You in Sections 1 and 2 herein, You indicate Your acceptance of this License and all of its terms and conditions. This license shall terminate immediately and you may no longer exercise any of the rights granted to You by this License upon Your failure to honor the proviso in Section 1(c) herein.\n\n   9) Mutual Termination for Patent Action. This License shall terminate automatically and You may no longer exercise any of the rights granted to You by this License if You file a lawsuit in any court alleging that any OSI Certified open source software that is licensed under any license containing this \"Mutual Termination for Patent Action\" clause infringes any patent claims that are essential to use that software.\n\n   10) Jurisdiction, Venue and Governing Law. You agree that any lawsuit arising under or relating to this License shall be maintained in the courts of the jurisdiction wherein the Licensor resides or in which Licensor conducts its primary business, and under the laws of that jurisdiction excluding its conflict-of-law provisions. The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded. Any use of the Original Work outside the scope of this License or after its termination shall be subject to the requirements and penalties of the U.S. Copyright Act, 17 U.S.C. § 101 et seq., the equivalent laws of other countries, and international treaty. This section shall survive the termination of this License.\n\n   11) Attorneys Fees. In any action to enforce the terms of this License or seeking damages relating thereto, the prevailing party shall be entitled to recover its costs and expenses, including, without limitation, reasonable attorneys' fees and costs incurred in connection with such action, including any appeal of such action. This section shall survive the termination of this License.\n\n   12) Miscellaneous. This License represents the complete agreement concerning the subject matter hereof. If any provision of this License is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable.\n\n   13) Definition of \"You\" in This License. \"You\" throughout this License, whether in upper or lower case, means an individual or a legal entity exercising rights under, and complying with all of the terms of, this License. For legal entities, \"You\" includes any entity that controls, is controlled by, or is under common control with you. For purposes of this definition, \"control\" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.\n\nThis license is Copyright (C) 2002 Lawrence E. Rosen. All rights reserved. Permission is hereby granted to copy and distribute this license without modification. This license may not be modified without the express written permission of its copyright owner."],"licenseIds":["OSL-1.0"],"keywords":["1 0 license","0 license terms","those persons made","persons made available","than you as","herein 6 warranty","6 warranty and","you 8 acceptance","8 acceptance and","and termination nothing","termination nothing else","and 2 herein","2 herein you","c herein 9","herein 9 mutual","9 mutual termination","that software 10","software 10 jurisdiction","10 jurisdiction venue","governing law you","law you agree","that any lawsuit","any lawsuit arising","lawsuit arising under","under or relating","shall be maintained","be maintained in","maintained in the","the jurisdiction wherein","license 11 attorneys","11 attorneys fees","license 12 miscellaneous","12 miscellaneous this","enforceable 13 definition","13 definition of","such entity this","entity this license","1 0 this open","version 1 0 license","1 0 license terms","0 license terms 1","works may be accessed","to those persons made","those persons made available","persons made available as","other than you as","than you as an","you as an express","deployment by you shall","you shall be deemed","c herein 6 warranty","herein 6 warranty and","6 warranty and disclaimer","to you 8 acceptance","you 8 acceptance and","8 acceptance and termination","acceptance and termination nothing","and termination nothing else","termination nothing else but","work and any attempt","in sections 1 and","1 and 2 herein","and 2 herein you","2 herein you indicate","1 c herein 9","c herein 9 mutual","herein 9 mutual termination","9 mutual termination for","use that software 10","that software 10 jurisdiction","software 10 jurisdiction venue","10 jurisdiction venue and","and governing law you","governing law you agree","law you agree that","agree that any lawsuit","that any lawsuit arising","any lawsuit arising under","lawsuit arising under or","arising under or relating","under or relating to","license shall be maintained","shall be maintained in","be maintained in the","maintained in the courts","courts of the jurisdiction","of the jurisdiction wherein","the jurisdiction wherein the","of this license 11","this license 11 attorneys","license 11 attorneys fees","11 attorneys fees in","this license 12 miscellaneous","license 12 miscellaneous this","12 miscellaneous this license","it enforceable 13 definition","enforceable 13 definition of","13 definition of you","of such entity this","such entity this license","entity this license is","v 1 0 this open","1 0 this open software","license version 1 0 license","version 1 0 license terms","1 0 license terms 1","0 license terms 1 grant","terms 1 grant of copyright","derivative works may be accessed","works may be accessed or","distributed to those persons made","to those persons made available","those persons made available as","persons made available as an","anyone other than you as","other than you as an","than you as an express","you as an express condition","external deployment by you shall","deployment by you shall be","by you shall be deemed","you shall be deemed a","1 c herein 6 warranty","c herein 6 warranty and","herein 6 warranty and disclaimer","6 warranty and disclaimer of","apply to you 8 acceptance","to you 8 acceptance and","you 8 acceptance and termination","8 acceptance and termination nothing","acceptance and termination nothing else","and termination nothing else but","termination nothing else but this","original work and any attempt","work and any attempt to","you in sections 1 and","in sections 1 and 2","sections 1 and 2 herein","1 and 2 herein you","and 2 herein you indicate","2 herein you indicate your","section 1 c herein 9","1 c herein 9 mutual","c herein 9 mutual termination","herein 9 mutual termination for","9 mutual termination for patent","to use that software 10","use that software 10 jurisdiction","that software 10 jurisdiction venue","software 10 jurisdiction venue and","10 jurisdiction venue and governing","venue and governing law you","and governing law you agree","governing law you agree that","law you agree that any","you agree that any lawsuit","agree that any lawsuit arising","that any lawsuit arising under","any lawsuit arising under or","lawsuit arising under or relating","arising under or relating to","under or relating to this","this license shall be maintained","license shall be maintained in","shall be maintained in the","be maintained in the courts","maintained in the courts of","in the courts of the","the courts of the jurisdiction","courts of the jurisdiction wherein","of the jurisdiction wherein the","the jurisdiction wherein the licensor","termination of this license 11","of this license 11 attorneys","this license 11 attorneys fees","license 11 attorneys fees in","11 attorneys fees in any","of this license 12 miscellaneous","this license 12 miscellaneous this","license 12 miscellaneous this license","12 miscellaneous this license represents","make it enforceable 13 definition","it enforceable 13 definition of","enforceable 13 definition of you","13 definition of you in","ownership of such entity this","of such entity this license","such entity this license is","entity this license is copyright"]},{"licenseTexts":["The Open Software License v. 1.1\n\nThis Open Software License (the \"License\") applies to any original work of authorship (the \"Original Work\") whose owner (the \"Licensor\") has placed the following notice immediately following the copyright notice for the Original Work:\n\nLicensed under the Open Software License version 1.1\n\n   1) Grant of Copyright License. Licensor hereby grants You a world-wide, royalty-free, non-exclusive, perpetual, non-sublicenseable license to do the following:\n\n      a) to reproduce the Original Work in copies;\n\n      b) to prepare derivative works (\"Derivative Works\") based upon the Original Work;\n\n      c) to distribute copies of the Original Work and Derivative Works to the public, with the proviso that copies of Original Work or Derivative Works that You distribute shall be licensed under the Open Software License;\n\n      d) to perform the Original Work publicly; and\n\n      e) to display the Original Work publicly.\n\n   2) Grant of Patent License. Licensor hereby grants You a world-wide, royalty-free, non-exclusive, perpetual, non-sublicenseable license, under patent claims owned or controlled by the Licensor that are embodied in the Original Work as furnished by the Licensor (\"Licensed Claims\") to make, use, sell and offer for sale the Original Work. Licensor hereby grants You a world-wide, royalty-free, non-exclusive, perpetual, non-sublicenseable license under the Licensed Claims to make, use, sell and offer for sale Derivative Works.\n\n   3) Grant of Source Code License. The term \"Source Code\" means the preferred form of the Original Work for making modifications to it and all available documentation describing how to modify the Original Work. Licensor hereby agrees to provide a machine-readable copy of the Source Code of the Original Work along with each copy of the Original Work that Licensor distributes. Licensor reserves the right to satisfy this obligation by placing a machine-readable copy of the Source Code in an information repository reasonably calculated to permit inexpensive and convenient access by You for as long as Licensor continues to distribute the Original Work, and by publishing the address of that information repository in a notice immediately following the copyright notice that applies to the Original Work.\n\n   4) Exclusions From License Grant. Nothing in this License shall be deemed to grant any rights to trademarks, copyrights, patents, trade secrets or any other intellectual property of Licensor except as expressly stated herein. No patent license is granted to make, use, sell or offer to sell embodiments of any patent claims other than the Licensed Claims defined in Section 2. No right is granted to the trademarks of Licensor even if such marks are included in the Original Work. Nothing in this License shall be interpreted to prohibit Licensor from licensing under different terms from this License any Original Work that Licensor otherwise would have a right to license.\n\n   5) External Deployment. The term \"External Deployment\" means the use or distribution of the Original Work or Derivative Works in any way such that the Original Work or Derivative Works may be used by anyone other than You, whether the Original Work or Derivative Works are distributed to those persons or made available as an application intended for use over a computer network. As an express condition for the grants of license hereunder, You agree that any External Deployment by You of a Derivative Work shall be deemed a distribution and shall be licensed to all under the terms of this License, as prescribed in section 1(c) herein.\n\n   6) Attribution Rights. You must retain, in the Source Code of any Derivative Works that You create, all copyright, patent or trademark notices from the Source Code of the Original Work, as well as any notices of licensing and any descriptive text identified therein as an \"Attribution Notice.\" You must cause the Source Code for any Derivative Works that You create to carry a prominent Attribution Notice reasonably calculated to inform recipients that You have modified the Original Work.\n\n   7) Warranty and Disclaimer of Warranty. Licensor warrants that the copyright in and to the Original Work is owned by the Licensor or that the Original Work is distributed by Licensor under a valid current license from the copyright owner. Except as expressly stated in the immediately proceeding sentence, the Original Work is provided under this License on an \"AS IS\" BASIS and WITHOUT WARRANTY, either express or implied, including, without limitation, the warranties of NON-INFRINGEMENT, MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY OF THE ORIGINAL WORK IS WITH YOU. This DISCLAIMER OF WARRANTY constitutes an essential part of this License. No license to Original Work is granted hereunder except under this disclaimer.\n\n   8) Limitation of Liability. Under no circumstances and under no legal theory, whether in tort (including negligence), contract, or otherwise, shall the Licensor be liable to any person for any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or the use of the Original Work including, without limitation, damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses. This limitation of liability shall not apply to liability for death or personal injury resulting from Licensor's negligence to the extent applicable law prohibits such limitation. Some jurisdictions do not allow the exclusion or limitation of incidental or consequential damages, so this exclusion and limitation may not apply to You.\n\n   9) Acceptance and Termination. If You distribute copies of the Original Work or a Derivative Work, You must make a reasonable effort under the circumstances to obtain the express and volitional assent of recipients to the terms of this License. Nothing else but this License (or another written agreement between Licensor and You) grants You permission to create Derivative Works based upon the Original Work or to exercise any of the rights granted in Sections 1 herein, and any attempt to do so except under the terms of this License (or another written agreement between Licensor and You) is expressly prohibited by U.S. copyright law, the equivalent laws of other countries, and by international treaty. Therefore, by exercising any of the rights granted to You in Sections 1 herein, You indicate Your acceptance of this License and all of its terms and conditions. This License shall terminate immediately and you may no longer exercise any of the rights granted to You by this License upon Your failure to honor the proviso in Section 1(c) herein.\n\n   10) Mutual Termination for Patent Action. This License shall terminate automatically and You may no longer exercise any of the rights granted to You by this License if You file a lawsuit in any court alleging that any OSI Certified open source software that is licensed under any license containing this \"Mutual Termination for Patent Action\" clause infringes any patent claims that are essential to use that software.\n\n   11) Jurisdiction, Venue and Governing Law. Any action or suit relating to this License may be brought only in the courts of a jurisdiction wherein the Licensor resides or in which Licensor conducts its primary business, and under the laws of that jurisdiction excluding its conflict-of-law provisions. The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded. Any use of the Original Work outside the scope of this License or after its termination shall be subject to the requirements and penalties of the U.S. Copyright Act, 17 U.S.C. å¤ 101 et seq., the equivalent laws of other countries, and international treaty. This section shall survive the termination of this License.\n\n   12) Attorneys Fees. In any action to enforce the terms of this License or seeking damages relating thereto, the prevailing party shall be entitled to recover its costs and expenses, including, without limitation, reasonable attorneys' fees and costs incurred in connection with such action, including any appeal of such action. This section shall survive the termination of this License.\n\n   13) Miscellaneous. This License represents the complete agreement concerning the subject matter hereof. If any provision of this License is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable.\n\n   14) Definition of \"You\" in This License. \"You\" throughout this License, whether in upper or lower case, means an individual or a legal entity exercising rights under, and complying with all of the terms of, this License. For legal entities, \"You\" includes any entity that controls, is controlled by, or is under common control with you. For purposes of this definition, \"control\" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.\n\n   15) Right to Use. You may use the Original Work in all ways not otherwise restricted or conditioned by this License or by law, and Licensor promises not to interfere with or be responsible for such uses by You.\n\nThis license is Copyright (C) 2002 Lawrence E. Rosen. All rights reserved. Permission is hereby granted to copy and distribute this license without modification. This license may not be modified without the express written permission of its copyright owner."],"licenseIds":["OSL-1.1"],"keywords":["the express and","express and volitional","and volitional assent","volitional assent of","herein 10 mutual","10 mutual termination","that software 11","software 11 jurisdiction","v 1 1 this","1 1 this open","1 1 1 grant","work 7 warranty and","7 warranty and disclaimer","obtain the express and","the express and volitional","express and volitional assent","and volitional assent of","volitional assent of recipients","rights granted in sections","granted in sections 1","sections 1 herein and","sections 1 herein you","c herein 10 mutual","herein 10 mutual termination","10 mutual termination for","use that software 11","that software 11 jurisdiction","software 11 jurisdiction venue","software license v 1 1","license v 1 1 this","v 1 1 this open","1 1 this open software","software license version 1 1","version 1 1 1 grant","1 1 1 grant of","original work 7 warranty and","work 7 warranty and disclaimer","7 warranty and disclaimer of","to obtain the express and","obtain the express and volitional","the express and volitional assent","express and volitional assent of","and volitional assent of recipients","volitional assent of recipients to","the rights granted in sections","rights granted in sections 1","granted in sections 1 herein","in sections 1 herein and","sections 1 herein and any","you in sections 1 herein","in sections 1 herein you","sections 1 herein you indicate","1 c herein 10 mutual","c herein 10 mutual termination","herein 10 mutual termination for","10 mutual termination for patent","to use that software 11","use that software 11 jurisdiction","that software 11 jurisdiction venue","software 11 jurisdiction venue and"]},{"licenseTexts":["The Open Software License v. 2.0\n\nThis Open Software License (the \"License\") applies to any original work of authorship (the \"Original Work\") whose owner (the \"Licensor\") has placed the following notice immediately following the copyright notice for the Original Work:\n\nLicensed under the Open Software License version 2.0\n\n   1) Grant of Copyright License. Licensor hereby grants You a world-wide, royalty-free, non-exclusive, perpetual, sublicenseable license to do the following:\n\n      a) to reproduce the Original Work in copies;\n\n      b) to prepare derivative works (\"Derivative Works\") based upon the Original Work;\n\n      c) to distribute copies of the Original Work and Derivative Works to the public, with the proviso that copies of Original Work or Derivative Works that You distribute shall be licensed under the Open Software License;\n\n      d) to perform the Original Work publicly; and\n\n      e) to display the Original Work publicly.\n\n   2) Grant of Patent License. Licensor hereby grants You a world-wide, royalty-free, non-exclusive, perpetual, sublicenseable license, under patent claims owned or controlled by the Licensor that are embodied in the Original Work as furnished by the Licensor, to make, use, sell and offer for sale the Original Work and Derivative Works.\n\n   3) Grant of Source Code License. The term \"Source Code\" means the preferred form of the Original Work for making modifications to it and all available documentation describing how to modify the Original Work. Licensor hereby agrees to provide a machine-readable copy of the Source Code of the Original Work along with each copy of the Original Work that Licensor distributes. Licensor reserves the right to satisfy this obligation by placing a machine-readable copy of the Source Code in an information repository reasonably calculated to permit inexpensive and convenient access by You for as long as Licensor continues to distribute the Original Work, and by publishing the address of that information repository in a notice immediately following the copyright notice that applies to the Original Work.\n\n   4) Exclusions From License Grant. Neither the names of Licensor, nor the names of any contributors to the Original Work, nor any of their trademarks or service marks, may be used to endorse or promote products derived from this Original Work without express prior written permission of the Licensor. Nothing in this License shall be deemed to grant any rights to trademarks, copyrights, patents, trade secrets or any other intellectual property of Licensor except as expressly stated herein. No patent license is granted to make, use, sell or offer to sell embodiments of any patent claims other than the licensed claims defined in Section 2. No right is granted to the trademarks of Licensor even if such marks are included in the Original Work. Nothing in this License shall be interpreted to prohibit Licensor from licensing under different terms from this License any Original Work that Licensor otherwise would have a right to license.\n\n   5) External Deployment. The term \"External Deployment\" means the use or distribution of the Original Work or Derivative Works in any way such that the Original Work or Derivative Works may be used by anyone other than You, whether the Original Work or Derivative Works are distributed to those persons or made available as an application intended for use over a computer network. As an express condition for the grants of license hereunder, You agree that any External Deployment by You of a Derivative Work shall be deemed a distribution and shall be licensed to all under the terms of this License, as prescribed in section 1(c) herein.\n\n   6) Attribution Rights. You must retain, in the Source Code of any Derivative Works that You create, all copyright, patent or trademark notices from the Source Code of the Original Work, as well as any notices of licensing and any descriptive text identified therein as an \"Attribution Notice.\" You must cause the Source Code for any Derivative Works that You create to carry a prominent Attribution Notice reasonably calculated to inform recipients that You have modified the Original Work.\n\n   7) Warranty of Provenance and Disclaimer of Warranty. Licensor warrants that the copyright in and to the Original Work and the patent rights granted herein by Licensor are owned by the Licensor or are sublicensed to You under the terms of this License with the permission of the contributor(s) of those copyrights and patent rights. Except as expressly stated in the immediately proceeding sentence, the Original Work is provided under this License on an \"AS IS\" BASIS and WITHOUT WARRANTY, either express or implied, including, without limitation, the warranties of NON-INFRINGEMENT, MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY OF THE ORIGINAL WORK IS WITH YOU. This DISCLAIMER OF WARRANTY constitutes an essential part of this License. No license to Original Work is granted hereunder except under this disclaimer.\n\n   8) Limitation of Liability. Under no circumstances and under no legal theory, whether in tort (including negligence), contract, or otherwise, shall the Licensor be liable to any person for any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or the use of the Original Work including, without limitation, damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses. This limitation of liability shall not apply to liability for death or personal injury resulting from Licensor's negligence to the extent applicable law prohibits such limitation. Some jurisdictions do not allow the exclusion or limitation of incidental or consequential damages, so this exclusion and limitation may not apply to You.\n\n   9) Acceptance and Termination. If You distribute copies of the Original Work or a Derivative Work, You must make a reasonable effort under the circumstances to obtain the express assent of recipients to the terms of this License. Nothing else but this License (or another written agreement between Licensor and You) grants You permission to create Derivative Works based upon the Original Work or to exercise any of the rights granted in Section 1 herein, and any attempt to do so except under the terms of this License (or another written agreement between Licensor and You) is expressly prohibited by U.S. copyright law, the equivalent laws of other countries, and by international treaty. Therefore, by exercising any of the rights granted to You in Section 1 herein, You indicate Your acceptance of this License and all of its terms and conditions. This License shall terminate immediately and you may no longer exercise any of the rights granted to You by this License upon Your failure to honor the proviso in Section 1(c) herein.\n\n   10) Termination for Patent Action. This License shall terminate automatically and You may no longer exercise any of the rights granted to You by this License as of the date You commence an action, including a cross-claim or counterclaim, for patent infringement (i) against Licensor with respect to a patent applicable to software or (ii) against any entity with respect to a patent applicable to the Original Work (but excluding combinations of the Original Work with other software or hardware).\n\n   11) Jurisdiction, Venue and Governing Law. Any action or suit relating to this License may be brought only in the courts of a jurisdiction wherein the Licensor resides or in which Licensor conducts its primary business, and under the laws of that jurisdiction excluding its conflict-of-law provisions. The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded. Any use of the Original Work outside the scope of this License or after its termination shall be subject to the requirements and penalties of the U.S. Copyright Act, 17 U.S.C. 101 et seq., the equivalent laws of other countries, and international treaty. This section shall survive the termination of this License.\n\n   12) Attorneys Fees. In any action to enforce the terms of this License or seeking damages relating thereto, the prevailing party shall be entitled to recover its costs and expenses, including, without limitation, reasonable attorneys' fees and costs incurred in connection with such action, including any appeal of such action. This section shall survive the termination of this License.\n\n   13) Miscellaneous. This License represents the complete agreement concerning the subject matter hereof. If any provision of this License is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable.\n\n   14) Definition of \"You\" in This License. \"You\" throughout this License, whether in upper or lower case, means an individual or a legal entity exercising rights under, and complying with all of the terms of, this License. For legal entities, \"You\" includes any entity that controls, is controlled by, or is under common control with you. For purposes of this definition, \"control\" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.\n\n   15) Right to Use. You may use the Original Work in all ways not otherwise restricted or conditioned by this License or by law, and Licensor promises not to interfere with or be responsible for such uses by You.\n\nThis license is Copyright (C) 2003 Lawrence E. Rosen. All rights reserved. Permission is hereby granted to copy and distribute this license without modification. This license may not be modified without the express written permission of its copyright owner."],"licenseIds":["OSL-2.0"],"keywords":["software license v 2","2 0 this open","open software license v 2","software license v 2 0","v 2 0 this open","2 0 this open software","software license version 2 0"]},{"licenseTexts":["The Open Software Licensev. 2.1\n\nThis Open Software License (the \"License\") applies to any original work of authorship (the \"Original Work\") whose owner (the \"Licensor\") has placed the following notice immediately following the copyright notice for the Original Work:\n\nLicensed under the Open Software License version 2.1\n\n   1) Grant of Copyright License. Licensor hereby grants You a world-wide, royalty-free, non-exclusive, perpetual, sublicenseable license to do the following:\n\n      a) to reproduce the Original Work in copies;\n\n      b) to prepare derivative works (\"Derivative Works\") based upon the Original Work;\n\n      c) to distribute copies of the Original Work and Derivative Works to the public, with the proviso that copies of Original Work or Derivative Works that You distribute shall be licensed under the Open Software License;\n\n      d) to perform the Original Work publicly; and\n\n      e) to display the Original Work publicly.\n\n   2) Grant of Patent License. Licensor hereby grants You a world-wide, royalty-free, non-exclusive, perpetual, sublicenseable license, under patent claims owned or controlled by the Licensor that are embodied in the Original Work as furnished by the Licensor, to make, use, sell and offer for sale the Original Work and Derivative Works.\n\n   3) Grant of Source Code License. The term \"Source Code\" means the preferred form of the Original Work for making modifications to it and all available documentation describing how to modify the Original Work. Licensor hereby agrees to provide a machine-readable copy of the Source Code of the Original Work along with each copy of the Original Work that Licensor distributes. Licensor reserves the right to satisfy this obligation by placing a machine-readable copy of the Source Code in an information repository reasonably calculated to permit inexpensive and convenient access by You for as long as Licensor continues to distribute the Original Work, and by publishing the address of that information repository in a notice immediately following the copyright notice that applies to the Original Work.\n\n   4) Exclusions From License Grant. Neither the names of Licensor, nor the names of any contributors to the Original Work, nor any of their trademarks or service marks, may be used to endorse or promote products derived from this Original Work without express prior written permission of the Licensor. Nothing in this License shall be deemed to grant any rights to trademarks, copyrights, patents, trade secrets or any other intellectual property of Licensor except as expressly stated herein. No patent license is granted to make, use, sell or offer to sell embodiments of any patent claims other than the licensed claims defined in Section 2. No right is granted to the trademarks of Licensor even if such marks are included in the Original Work. Nothing in this License shall be interpreted to prohibit Licensor from licensing under different terms from this License any Original Work that Licensor otherwise would have a right to license.\n\n   5) External Deployment. The term \"External Deployment\" means the use or distribution of the Original Work or Derivative Works in any way such that the Original Work or Derivative Works may be used by anyone other than You, whether the Original Work or Derivative Works are distributed to those persons or made available as an application intended for use over a computer network. As an express condition for the grants of license hereunder, You agree that any External Deployment by You of a Derivative Work shall be deemed a distribution and shall be licensed to all under the terms of this License, as prescribed in section 1(c) herein.\n\n   6) Attribution Rights. You must retain, in the Source Code of any Derivative Works that You create, all copyright, patent or trademark notices from the Source Code of the Original Work, as well as any notices of licensing and any descriptive text identified therein as an \"Attribution Notice.\" You must cause the Source Code for any Derivative Works that You create to carry a prominent Attribution Notice reasonably calculated to inform recipients that You have modified the Original Work.\n\n   7) Warranty of Provenance and Disclaimer of Warranty. Licensor warrants that the copyright in and to the Original Work and the patent rights granted herein by Licensor are owned by the Licensor or are sublicensed to You under the terms of this License with the permission of the contributor(s) of those copyrights and patent rights. Except as expressly stated in the immediately proceeding sentence, the Original Work is provided under this License on an \"AS IS\" BASIS and WITHOUT WARRANTY, either express or implied, including, without limitation, the warranties of NON-INFRINGEMENT, MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY OF THE ORIGINAL WORK IS WITH YOU. This DISCLAIMER OF WARRANTY constitutes an essential part of this License. No license to Original Work is granted hereunder except under this disclaimer.\n\n   8) Limitation of Liability. Under no circumstances and under no legal theory, whether in tort (including negligence), contract, or otherwise, shall the Licensor be liable to any person for any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or the use of the Original Work including, without limitation, damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses. This limitation of liability shall not apply to liability for death or personal injury resulting from Licensor's negligence to the extent applicable law prohibits such limitation. Some jurisdictions do not allow the exclusion or limitation of incidental or consequential damages, so this exclusion and limitation may not apply to You.\n\n   9) Acceptance and Termination. If You distribute copies of the Original Work or a Derivative Work, You must make a reasonable effort under the circumstances to obtain the express assent of recipients to the terms of this License. Nothing else but this License (or another written agreement between Licensor and You) grants You permission to create Derivative Works based upon the Original Work or to exercise any of the rights granted in Section 1 herein, and any attempt to do so except under the terms of this License (or another written agreement between Licensor and You) is expressly prohibited by U.S. copyright law, the equivalent laws of other countries, and by international treaty. Therefore, by exercising any of the rights granted to You in Section 1 herein, You indicate Your acceptance of this License and all of its terms and conditions. This License shall terminate immediately and you may no longer exercise any of the rights granted to You by this License upon Your failure to honor the proviso in Section 1(c) herein.\n\n   10) Termination for Patent Action. This License shall terminate automatically and You may no longer exercise any of the rights granted to You by this License as of the date You commence an action, including a cross-claim or counterclaim, against Licensor or any licensee alleging that the Original Work infringes a patent. This termination provision shall not apply for an action alleging patent infringement by combinations of the Original Work with other software or hardware.\n\n   11) Jurisdiction, Venue and Governing Law. Any action or suit relating to this License may be brought only in the courts of a jurisdiction wherein the Licensor resides or in which Licensor conducts its primary business, and under the laws of that jurisdiction excluding its conflict-of-law provisions. The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded. Any use of the Original Work outside the scope of this License or after its termination shall be subject to the requirements and penalties of the U.S. Copyright Act, 17 U.S.C. § 101 et seq., the equivalent laws of other countries, and international treaty. This section shall survive the termination of this License.\n\n   12) Attorneys Fees. In any action to enforce the terms of this License or seeking damages relating thereto, the prevailing party shall be entitled to recover its costs and expenses, including, without limitation, reasonable attorneys' fees and costs incurred in connection with such action, including any appeal of such action. This section shall survive the termination of this License.\n\n   13) Miscellaneous. This License represents the complete agreement concerning the subject matter hereof. If any provision of this License is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable.\n\n   14) Definition of \"You\" in This License. \"You\" throughout this License, whether in upper or lower case, means an individual or a legal entity exercising rights under, and complying with all of the terms of, this License. For legal entities, \"You\" includes any entity that controls, is controlled by, or is under common control with you. For purposes of this definition, \"control\" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.\n\n   15) Right to Use. You may use the Original Work in all ways not otherwise restricted or conditioned by this License or by law, and Licensor promises not to interfere with or be responsible for such uses by You.\n\nThis license is Copyright (C) 2003-2004 Lawrence E. Rosen. All rights reserved. Permission is hereby granted to copy and distribute this license without modification. This license may not be modified without the express written permission of its copyright owner."],"licenseIds":["OSL-2.1"],"keywords":["open software licensev","software licensev 2","licensev 2 1","the open software licensev","open software licensev 2","software licensev 2 1","licensev 2 1 this","2 1 this open","the open software licensev 2","open software licensev 2 1","software licensev 2 1 this","licensev 2 1 this open","2 1 this open software","software license version 2 1"]},{"licenseTexts":["Open Software License v. 3.0 (OSL-3.0)\n\nThis Open Software License (the \"License\") applies to any original work of authorship (the \"Original Work\") whose owner (the \"Licensor\") has placed the following licensing notice adjacent to the copyright notice for the Original Work:\n\nLicensed under the Open Software License version 3.0\n\n   1) Grant of Copyright License. Licensor grants You a worldwide, royalty-free, non-exclusive, sublicensable license, for the duration of the copyright, to do the following:\n\n      a) to reproduce the Original Work in copies, either alone or as part of a collective work;\n\n      b) to translate, adapt, alter, transform, modify, or arrange the Original Work, thereby creating derivative works (\"Derivative Works\") based upon the Original Work;\n\n      c) to distribute or communicate copies of the Original Work and Derivative Works to the public, with the proviso that copies of Original Work or Derivative Works that You distribute or communicate shall be licensed under this Open Software License;\n\n      d) to perform the Original Work publicly; and\n\n      e) to display the Original Work publicly.\n\n   2) Grant of Patent License. Licensor grants You a worldwide, royalty-free, non-exclusive, sublicensable license, under patent claims owned or controlled by the Licensor that are embodied in the Original Work as furnished by the Licensor, for the duration of the patents, to make, use, sell, offer for sale, have made, and import the Original Work and Derivative Works.\n\n   3) Grant of Source Code License. The term \"Source Code\" means the preferred form of the Original Work for making modifications to it and all available documentation describing how to modify the Original Work. Licensor agrees to provide a machine-readable copy of the Source Code of the Original Work along with each copy of the Original Work that Licensor distributes. Licensor reserves the right to satisfy this obligation by placing a machine-readable copy of the Source Code in an information repository reasonably calculated to permit inexpensive and convenient access by You for as long as Licensor continues to distribute the Original Work.\n\n   4) Exclusions From License Grant. Neither the names of Licensor, nor the names of any contributors to the Original Work, nor any of their trademarks or service marks, may be used to endorse or promote products derived from this Original Work without express prior permission of the Licensor. Except as expressly stated herein, nothing in this License grants any license to Licensor's trademarks, copyrights, patents, trade secrets or any other intellectual property. No patent license is granted to make, use, sell, offer for sale, have made, or import embodiments of any patent claims other than the licensed claims defined in Section 2. No license is granted to the trademarks of Licensor even if such marks are included in the Original Work. Nothing in this License shall be interpreted to prohibit Licensor from licensing under terms different from this License any Original Work that Licensor otherwise would have a right to license.\n\n   5) External Deployment. The term \"External Deployment\" means the use, distribution, or communication of the Original Work or Derivative Works in any way such that the Original Work or Derivative Works may be used by anyone other than You, whether those works are distributed or communicated to those persons or made available as an application intended for use over a network. As an express condition for the grants of license hereunder, You must treat any External Deployment by You of the Original Work or a Derivative Work as a distribution under section 1(c).\n\n   6) Attribution Rights. You must retain, in the Source Code of any Derivative Works that You create, all copyright, patent, or trademark notices from the Source Code of the Original Work, as well as any notices of licensing and any descriptive text identified therein as an \"Attribution Notice.\" You must cause the Source Code for any Derivative Works that You create to carry a prominent Attribution Notice reasonably calculated to inform recipients that You have modified the Original Work.\n\n   7) Warranty of Provenance and Disclaimer of Warranty. Licensor warrants that the copyright in and to the Original Work and the patent rights granted herein by Licensor are owned by the Licensor or are sublicensed to You under the terms of this License with the permission of the contributor(s) of those copyrights and patent rights. Except as expressly stated in the immediately preceding sentence, the Original Work is provided under this License on an \"AS IS\" BASIS and WITHOUT WARRANTY, either express or implied, including, without limitation, the warranties of non-infringement, merchantability or fitness for a particular purpose. THE ENTIRE RISK AS TO THE QUALITY OF THE ORIGINAL WORK IS WITH YOU. This DISCLAIMER OF WARRANTY constitutes an essential part of this License. No license to the Original Work is granted by this License except under this disclaimer.\n\n   8) Limitation of Liability. Under no circumstances and under no legal theory, whether in tort (including negligence), contract, or otherwise, shall the Licensor be liable to anyone for any indirect, special, incidental, or consequential damages of any character arising as a result of this License or the use of the Original Work including, without limitation, damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses. This limitation of liability shall not apply to the extent applicable law prohibits such limitation.\n\n   9) Acceptance and Termination. If, at any time, You expressly assented to this License, that assent indicates your clear and irrevocable acceptance of this License and all of its terms and conditions. If You distribute or communicate copies of the Original Work or a Derivative Work, You must make a reasonable effort under the circumstances to obtain the express assent of recipients to the terms of this License. This License conditions your rights to undertake the activities listed in Section 1, including your right to create Derivative Works based upon the Original Work, and doing so without honoring these terms and conditions is prohibited by copyright law and international treaty. Nothing in this License is intended to affect copyright exceptions and limitations (including \"fair use\" or \"fair dealing\"). This License shall terminate immediately and You may no longer exercise any of the rights granted to You by this License upon your failure to honor the conditions in Section 1(c).\n\n   10) Termination for Patent Action. This License shall terminate automatically and You may no longer exercise any of the rights granted to You by this License as of the date You commence an action, including a cross-claim or counterclaim, against Licensor or any licensee alleging that the Original Work infringes a patent. This termination provision shall not apply for an action alleging patent infringement by combinations of the Original Work with other software or hardware.\n\n   11) Jurisdiction, Venue and Governing Law. Any action or suit relating to this License may be brought only in the courts of a jurisdiction wherein the Licensor resides or in which Licensor conducts its primary business, and under the laws of that jurisdiction excluding its conflict-of-law provisions. The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded. Any use of the Original Work outside the scope of this License or after its termination shall be subject to the requirements and penalties of copyright or patent law in the appropriate jurisdiction. This section shall survive the termination of this License.\n\n   12) Attorneys' Fees. In any action to enforce the terms of this License or seeking damages relating thereto, the prevailing party shall be entitled to recover its costs and expenses, including, without limitation, reasonable attorneys' fees and costs incurred in connection with such action, including any appeal of such action. This section shall survive the termination of this License.\n\n   13) Miscellaneous. If any provision of this License is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable.\n\n   14) Definition of \"You\" in This License. \"You\" throughout this License, whether in upper or lower case, means an individual or a legal entity exercising rights under, and complying with all of the terms of, this License. For legal entities, \"You\" includes any entity that controls, is controlled by, or is under common control with you. For purposes of this definition, \"control\" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.\n\n   15) Right to Use. You may use the Original Work in all ways not otherwise restricted or conditioned by this License or by law, and Licensor promises not to interfere with or be responsible for such uses by You.\n\n   16) Modification of This License. This License is Copyright (c) 2005 Lawrence Rosen. Permission is granted to copy, distribute, or communicate this License without modification. Nothing in this License permits You to modify this License as applied to the Original Work or to Derivative Works. However, You may modify the text of this License and copy, distribute or communicate your modified version (the \"Modified License\") and apply it to other original works of authorship subject to the following conditions: (i) You may not indicate in any way that your Modified License is the \"Open Software License\" or \"OSL\" and you may not use those names in the name of your Modified License; (ii) You must replace the notice specified in the first paragraph above with the notice \"Licensed under \u003cinsert your license name here\u003e\" or with a notice of your own that is not confusingly similar to the notice in this License; and (iii) You may not claim that your original works are open source software unless your Modified License has been approved by Open Source Initiative (OSI) and You comply with its license review and certification process."],"licenseIds":["OSL-3.0"],"keywords":["3 0 osl","0 osl 3","under this open","software license v 3","license v 3 0","v 3 0 osl","3 0 osl 3","0 osl 3 0","osl 3 0 this","3 0 this open","licensed under this open","under this open software","open software license v 3","software license v 3 0","license v 3 0 osl","v 3 0 osl 3","3 0 osl 3 0","0 osl 3 0 this","osl 3 0 this open","3 0 this open software","be licensed under this open","licensed under this open software","under this open software license","this open software license d","c 2005 lawrence rosen permission"]},{"licenseTexts":["OpenSSL License Copyright (c) 1998-2008 The OpenSSL Project. All rights reserved.\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n   2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   3. All advertising materials mentioning features or use of this software must display the following acknowledgment: \"This product includes software developed by the OpenSSL Project for use in the OpenSSL Toolkit. (http://www.openssl.org/)\"\n\n   4. The names \"OpenSSL Toolkit\" and \"OpenSSL Project\" must not be used to endorse or promote products derived from this software without prior written permission. For written permission, please contact openssl-core@openssl.org.\n\n   5. Products derived from this software may not be called \"OpenSSL\" nor may \"OpenSSL\" appear in their names without prior written permission of the OpenSSL Project.\n\n   6. Redistributions of any form whatsoever must retain the following acknowledgment: \"This product includes software developed by the OpenSSL Project for use in the OpenSSL Toolkit (http://www.openssl.org/)\"\n\nTHIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\nThis product includes cryptographic software written by Eric Young (eay@cryptsoft.com). This product includes software written by Tim Hudson (tjh@cryptsoft.com). Original SSLeay License Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)\n\nAll rights reserved.\n\nThis package is an SSL implementation written by Eric Young (eay@cryptsoft.com). The implementation was written so as to conform with Netscapes SSL.\n\nThis library is free for commercial and non-commercial use as long as the following conditions are aheared to. The following conditions apply to all code found in this distribution, be it the RC4, RSA, lhash, DES, etc., code; not just the SSL code. The SSL documentation included with this distribution is covered by the same copyright terms except that the holder is Tim Hudson (tjh@cryptsoft.com).\n\nCopyright remains Eric Young's, and as such any Copyright notices in the code are not to be removed. If this package is used in a product, Eric Young should be given attribution as the author of the parts of the library used. This can be in the form of a textual message at program startup or in documentation (online or textual) provided with the package.\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   1. Redistributions of source code must retain the copyright notice, this list of conditions and the following disclaimer.\n\n   2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   3. All advertising materials mentioning features or use of this software must display the following acknowledgement:\n\n   \"This product includes cryptographic software written by Eric Young (eay@cryptsoft.com)\"\n\n   The word 'cryptographic' can be left out if the rouines from the library being used are not cryptographic related :-).\n\n   4. If you include any Windows specific code (or a derivative thereof) from the apps directory (application code) you must include an acknowledgement: \"This product includes software written by Tim Hudson (tjh@cryptsoft.com)\"\n\nTHIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\nThe licence and distribution terms for any publically available version or derivative of this code cannot be changed. i.e. this code cannot simply be copied and put under another distribution licence [including the GNU Public Licence.]"],"licenseIds":["OpenSSL"],"keywords":["openssl license copyright","c 1998 2008","1998 2008 the","2008 the openssl","openssl project all","openssl org 4","the names openssl","names openssl toolkit","openssl toolkit and","toolkit and openssl","and openssl project","openssl project must","project must not","please contact openssl","contact openssl core","openssl core openssl","core openssl org","openssl org 5","be called openssl","called openssl nor","openssl nor may","nor may openssl","may openssl appear","openssl appear in","of the openssl","openssl project 6","project 6 redistributions","openssl org this","openssl project as","shall the openssl","openssl project or","project or its","damage this product","com this product","cryptsoft com original","com original ssleay","original ssleay license","ssleay license copyright","c 1995 1998","1995 1998 eric","1998 eric young","cryptsoft com all","reserved this package","package is an","is an ssl","an ssl implementation","ssl implementation written","implementation written by","com the implementation","the implementation was","implementation was written","was written so","as to conform","to conform with","conform with netscapes","with netscapes ssl","netscapes ssl this","ssl this library","free for commercial","commercial use as","use as long","conditions are aheared","are aheared to","aheared to the","following conditions apply","to all code","all code found","code found in","found in this","this distribution be","distribution be it","be it the","it the rc4","the rc4 rsa","rc4 rsa lhash","rsa lhash des","lhash des etc","des etc code","etc code not","just the ssl","the ssl code","ssl code the","code the ssl","the ssl documentation","ssl documentation included","with this distribution","distribution is covered","the same copyright","same copyright terms","copyright terms except","terms except that","that the holder","the holder is","holder is tim","is tim hudson","cryptsoft com copyright","com copyright remains","copyright remains eric","remains eric young","eric young s","young s and","s and as","as such any","such any copyright","the code are","code are not","are not to","not to be","to be removed","be removed if","removed if this","if this package","package is used","used in a","a product eric","product eric young","eric young should","young should be","be given attribution","given attribution as","attribution as the","of the parts","the library used","library used this","used this can","this can be","of a textual","a textual message","textual message at","message at program","at program startup","program startup or","startup or in","or in documentation","in documentation online","documentation online or","online or textual","or textual provided","textual provided with","with the package","the package redistribution","package redistribution and","com the word","the word cryptographic","word cryptographic can","cryptographic can be","can be left","be left out","left out if","out if the","if the rouines","the rouines from","rouines from the","the library being","library being used","being used are","used are not","are not cryptographic","not cryptographic related","cryptographic related 4","related 4 if","you include any","include any windows","any windows specific","windows specific code","specific code or","a derivative thereof","derivative thereof from","thereof from the","from the apps","the apps directory","apps directory application","directory application code","application code you","must include an","include an acknowledgement","an acknowledgement this","provided by eric","eric young as","young as is","author or contributors","damage the licence","licence and distribution","and distribution terms","distribution terms for","terms for any","for any publically","any publically available","publically available version","available version or","version or derivative","derivative of this","code cannot be","cannot be changed","be changed i","changed i e","i e this","e this code","code cannot simply","cannot simply be"]},{"licenseTexts":["Open Data Commons - Public Domain Dedication \u0026 License (PDDL)\n\nPreamble\n\nThe Open Data Commons - Public Domain Dedication \u0026 Licence is a document intended to allow you to freely share, modify, and use this work for any purpose and without any restrictions. This licence is intended for use on databases or their contents (\"data\"), either together or individually.\n\nMany databases are covered by copyright. Some jurisdictions, mainly in Europe, have specific special rights that cover databases called the \"sui generis\" database right. Both of these sets of rights, as well as other legal rights used to protect databases and data, can create uncertainty or practical difficulty for those wishing to share databases and their underlying data but retain a limited amount of rights under a \"some rights reserved\" approach to licensing as outlined in the Science Commons Protocol for Implementing Open Access Data. As a result, this waiver and licence tries to the fullest extent possible to eliminate or fully license any rights that cover this database and data. Any Community Norms or similar statements of use of the database or data do not form a part of this document, and do not act as a contract for access or other terms of use for the database or data.\n\nThe position of the recipient of the work\n\nBecause this document places the database and its contents in or as close as possible within the public domain, there are no restrictions or requirements placed on the recipient by this document. Recipients may use this work commercially, use technical protection measures, combine this data or database with other databases or data, and share their changes and additions or keep them secret. It is not a requirement that recipients provide further users with a copy of this licence or attribute the original creator of the data or database as a source. The goal is to eliminate restrictions held by the original creator of the data and database on the use of it by others.\n\nThe position of the dedicator of the work\n\nCopyright law, as with most other law under the banner of \"intellectual property\", is inherently national law. This means that there exists several differences in how copyright and other IP rights can be relinquished, waived or licensed in the many legal jurisdictions of the world. This is despite much harmonisation of minimum levels of protection. The internet and other communication technologies span these many disparate legal jurisdictions and thus pose special difficulties for a document relinquishing and waiving intellectual property rights, including copyright and database rights, for use by the global community. Because of this feature of intellectual property law, this document first relinquishes the rights and waives the relevant rights and claims. It then goes on to license these same rights for jurisdictions or areas of law that may make it difficult to relinquish or waive rights or claims.\n\nThe purpose of this document is to enable rightsholders to place their work into the public domain. Unlike licences for free and open source software, free cultural works, or open content licences, rightsholders will not be able to \"dual license\" their work by releasing the same work under different licences. This is because they have allowed anyone to use the work in whatever way they choose. Rightsholders therefore can't re-license it under copyright or database rights on different terms because they have nothing left to license. Doing so creates truly accessible data to build rich applications and advance the progress of science and the arts.\n\nThis document can cover either or both of the database and its contents (the data). Because databases can have a wide variety of content - not just factual data - rightsholders should use the Open Data Commons - Public Domain Dedication \u0026 Licence for an entire database and its contents only if everything can be placed under the terms of this document. Because even factual data can sometimes have intellectual property rights, rightsholders should use this licence to cover both the database and its factual data when making material available under this document; even if it is likely that the data would not be covered by copyright or database rights.\n\nRightsholders can also use this document to cover any copyright or database rights claims over only a database, and leave the contents to be covered by other licences or documents. They can do this because this document refers to the \"Work\", which can be either - or both - the database and its contents. As a result, rightsholders need to clearly state what they are dedicating under this document when they dedicate it.\n\nJust like any licence or other document dealing with intellectual property, rightsholders should be aware that one can only license what one owns. Please ensure that the rights have been cleared to make this material available under this document.\n\nThis document permanently and irrevocably makes the Work available to the public for any use of any kind, and it should not be used unless the rightsholder is prepared for this to happen.\n\nPart I: Introduction\n\nThe Rightsholder (the Person holding rights or claims over the Work) agrees as follows:\n\n   1.0 Definitions of Capitalised Words\n\n   \"Copyright\" - Includes rights under copyright and under neighbouring rights and similarly related sets of rights under the law of the relevant jurisdiction under Section 6.4.\n\n   \"Data\" - The contents of the Database, which includes the information, independent works, or other material collected into the Database offered under the terms of this Document.\n\n   \"Database\" - A collection of Data arranged in a systematic or methodical way and individually accessible by electronic or other means offered under the terms of this Document.\n\n   \"Database Right\" - Means rights over Data resulting from the Chapter III (\"sui generis\") rights in the Database Directive (Directive 96/9/EC of the European Parliament and of the Council of 11 March 1996 on the legal protection of databases) and any future updates as well as any similar rights available in the relevant jurisdiction under Section 6.4.\n\n   \"Document\" - means this relinquishment and waiver of rights and claims and back up licence agreement.\n\n   \"Person\" - Means a natural or legal person or a body of persons corporate or incorporate.\n\n   \"Use\" - As a verb, means doing any act that is restricted by Copyright or Database Rights whether in the original medium or any other; and includes modifying the Work as may be technically necessary to use it in a different mode or format. This includes the right to sublicense the Work.\n\n   \"Work\" - Means either or both of the Database and Data offered under the terms of this Document.\n\n   \"You\" - the Person acquiring rights under the licence elements of this Document.\n\n   Words in the singular include the plural and vice versa.\n\n   2.0 What this document covers\n\n   2.1. Legal effect of this Document. This Document is:\n\n      a. A dedication to the public domain and waiver of Copyright and Database Rights over the Work; and\n\n      b. A licence of Copyright and Database Rights over the Work in jurisdictions that do not allow for relinquishment or waiver.\n\n   2.2. Legal rights covered.\n\n      a. Copyright. Any copyright or neighbouring rights in the Work. Copyright law varies between jurisdictions, but is likely to cover: the Database model or schema, which is the structure, arrangement, and organisation of the Database, and can also include the Database tables and table indexes; the data entry and output sheets; and the Field names of Data stored in the Database. Copyright may also cover the Data depending on the jurisdiction and type of Data; and\n\n      b. Database Rights. Database Rights only extend to the extraction and re-utilisation of the whole or a substantial part of the Data. Database Rights can apply even when there is no copyright over the Database. Database Rights can also apply when the Data is removed from the Database and is selected and arranged in a way that would not infringe any applicable copyright.\n\n   2.2 Rights not covered.\n\n      a. This Document does not apply to computer programs used in the making or operation of the Database;\n\n      b. This Document does not cover any patents over the Data or the Database. Please see Section 4.2 later in this Document for further details; and\n\n      c. This Document does not cover any trade marks associated with the Database. Please see Section 4.3 later in this Document for further details.\n\n      Users of this Database are cautioned that they may have to clear other rights or consult other licences.\n\n   2.3 Facts are free. The Rightsholder takes the position that factual information is not covered by Copyright. This Document however covers the Work in jurisdictions that may protect the factual information in the Work by Copyright, and to cover any information protected by Copyright that is contained in the Work.\n\nPart II: Dedication to the public domain\n\n   3.0 Dedication, waiver, and licence of Copyright and Database Rights\n\n   3.1 Dedication of Copyright and Database Rights to the public domain. The Rightsholder by using this Document, dedicates the Work to the public domain for the benefit of the public and relinquishes all rights in Copyright and Database Rights over the Work.\n\n      a. The Rightsholder realises that once these rights are relinquished, that the Rightsholder has no further rights in Copyright and Database Rights over the Work, and that the Work is free and open for others to Use.\n\n      b. The Rightsholder intends for their relinquishment to cover all present and future rights in the Work under Copyright and Database Rights, whether they are vested or contingent rights, and that this relinquishment of rights covers all their heirs and successors.\n\n      The above relinquishment of rights applies worldwide and includes media and formats now known or created in the future.\n\n   3.2 Waiver of rights and claims in Copyright and Database Rights when Section 3.1 dedication inapplicable. If the dedication in Section 3.1 does not apply in the relevant jurisdiction under Section 6.4, the Rightsholder waives any rights and claims that the Rightsholder may have or acquire in the future over the Work in:\n\n      a. Copyright; and\n\n      b. Database Rights.\n\n      To the extent possible in the relevant jurisdiction, the above waiver of rights and claims applies worldwide and includes media and formats now known or created in the future. The Rightsholder agrees not to assert the above rights and waives the right to enforce them over the Work.\n\n   3.3 Licence of Copyright and Database Rights when Sections 3.1 and 3.2 inapplicable. If the dedication and waiver in Sections 3.1 and 3.2 does not apply in the relevant jurisdiction under Section 6.4, the Rightsholder and You agree as follows:\n\n      a. The Licensor grants to You a worldwide, royalty-free, non-exclusive, licence to Use the Work for the duration of any applicable Copyright and Database Rights. These rights explicitly include commercial use, and do not exclude any field of endeavour. To the extent possible in the relevant jurisdiction, these rights may be exercised in all media and formats whether now known or created in the future.\n\n   3.4 Moral rights. This section covers moral rights, including the right to be identified as the author of the Work or to object to treatment that would otherwise prejudice the author's honour and reputation, or any other derogatory treatment:\n\n      a. For jurisdictions allowing waiver of moral rights, Licensor waives all moral rights that Licensor may have in the Work to the fullest extent possible by the law of the relevant jurisdiction under Section 6.4;\n\n      b. If waiver of moral rights under Section 3.4 a in the relevant jurisdiction is not possible, Licensor agrees not to assert any moral rights over the Work and waives all claims in moral rights to the fullest extent possible by the law of the relevant jurisdiction under Section 6.4; and\n\n      c. For jurisdictions not allowing waiver or an agreement not to assert moral rights under Section 3.4 a and b, the author may retain their moral rights over the copyrighted aspects of the Work.\n\n      Please note that some jurisdictions do not allow for the waiver of moral rights, and so moral rights may still subsist over the work in some jurisdictions.\n\n   4.0 Relationship to other rights\n\n   4.1 No other contractual conditions. The Rightsholder makes this Work available to You without any other contractual obligations, either express or implied. Any Community Norms statement associated with the Work is not a contract and does not form part of this Document.\n\n   4.2 Relationship to patents. This Document does not grant You a licence for any patents that the Rightsholder may own. Users of this Database are cautioned that they may have to clear other rights or consult other licences.\n\n   4.3 Relationship to trade marks. This Document does not grant You a licence for any trade marks that the Rightsholder may own or that the Rightsholder may use to cover the Work. Users of this Database are cautioned that they may have to clear other rights or consult other licences.\n\nPart III: General provisions\n\n   5.0 Warranties, disclaimer, and limitation of liability\n\n   5.1 The Work is provided by the Rightsholder \"as is\" and without any warranty of any kind, either express or implied, whether of title, of accuracy or completeness, of the presence of absence of errors, of fitness for purpose, or otherwise. Some jurisdictions do not allow the exclusion of implied warranties, so this exclusion may not apply to You.\n\n   5.2 Subject to any liability that may not be excluded or limited by law, the Rightsholder is not liable for, and expressly excludes, all liability for loss or damage however and whenever caused to anyone by any use under this Document, whether by You or by anyone else, and whether caused by any fault on the part of the Rightsholder or not. This exclusion of liability includes, but is not limited to, any special, incidental, consequential, punitive, or exemplary damages. This exclusion applies even if the Rightsholder has been advised of the possibility of such damages.\n\n   5.3 If liability may not be excluded by law, it is limited to actual and direct financial loss to the extent it is caused by proved negligence on the part of the Rightsholder.\n\n   6.0 General\n\n   6.1 If any provision of this Document is held to be invalid or unenforceable, that must not affect the cvalidity or enforceability of the remainder of the terms of this Document.\n\n   6.2 This Document is the entire agreement between the parties with respect to the Work covered here. It replaces any earlier understandings, agreements or representations with respect to the Work not specified here.\n\n   6.3 This Document does not affect any rights that You or anyone else may independently have under any applicable law to make any use of this Work, including (for jurisdictions where this Document is a licence) fair dealing, fair use, database exceptions, or any other legally recognised limitation or exception to infringement of copyright or other applicable laws.\n\n   6.4 This Document takes effect in the relevant jurisdiction in which the Document terms are sought to be enforced. If the rights waived or granted under applicable law in the relevant jurisdiction includes additional rights not waived or granted under this Document, these additional rights are included in this Document in order to meet the intent of this Document."],"licenseIds":["PDDL-1.0"],"keywords":["domain dedication license","dedication license pddl","license pddl preamble","pddl preamble the","dedication licence is","licence is a","is a document","a document intended","document intended to","this work for","work for any","without any restrictions","any restrictions this","restrictions this licence","is intended for","for use on","use on databases","on databases or","databases or their","or their contents","their contents data","contents data either","data either together","either together or","together or individually","or individually many","individually many databases","by copyright some","copyright some jurisdictions","mainly in europe","in europe have","europe have specific","have specific special","specific special rights","special rights that","cover databases called","databases called the","called the sui","the sui generis","generis database right","database right both","right both of","both of these","of these sets","these sets of","of rights as","rights as well","as other legal","other legal rights","legal rights used","rights used to","used to protect","to protect databases","protect databases and","databases and data","and data can","data can create","can create uncertainty","create uncertainty or","uncertainty or practical","or practical difficulty","practical difficulty for","difficulty for those","for those wishing","those wishing to","wishing to share","to share databases","share databases and","databases and their","and their underlying","their underlying data","underlying data but","data but retain","but retain a","retain a limited","a limited amount","limited amount of","amount of rights","under a some","a some rights","some rights reserved","rights reserved approach","reserved approach to","approach to licensing","to licensing as","licensing as outlined","outlined in the","in the science","the science commons","science commons protocol","commons protocol for","protocol for implementing","for implementing open","implementing open access","open access data","access data as","a result this","result this waiver","this waiver and","and licence tries","licence tries to","tries to the","extent possible to","possible to eliminate","to eliminate or","eliminate or fully","or fully license","fully license any","license any rights","that cover this","cover this database","this database and","and data any","data any community","community norms or","norms or similar","or similar statements","similar statements of","statements of use","or data do","data do not","not form a","form a part","document and do","do not act","not act as","act as a","a contract for","contract for access","for access or","access or other","for the database","data the position","the work because","work because this","this document places","document places the","places the database","its contents in","contents in or","or as close","as close as","close as possible","as possible within","possible within the","within the public","domain there are","no restrictions or","restrictions or requirements","or requirements placed","requirements placed on","placed on the","recipient by this","this document recipients","document recipients may","recipients may use","this work commercially","work commercially use","commercially use technical","use technical protection","protection measures combine","measures combine this","combine this data","this data or","or database with","database with other","with other databases","other databases or","databases or data","or data and","data and share","and share their","share their changes","their changes and","and additions or","additions or keep","or keep them","keep them secret","them secret it","secret it is","requirement that recipients","that recipients provide","recipients provide further","provide further users","further users with","users with a","licence or attribute","or attribute the","attribute the original","or database as","as a source","a source the","source the goal","goal is to","is to eliminate","to eliminate restrictions","eliminate restrictions held","restrictions held by","data and database","and database on"]},{"licenseTexts":["The PHP License, version 3.0 Copyright (c) 1999 - 2006 The PHP Group. All rights reserved.\n\nRedistribution and use in source and binary forms, with or without modification, is permitted provided that the following conditions are met:\n\n   1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n   2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   3. The name \"PHP\" must not be used to endorse or promote products derived from this software without prior written permission. For written permission, please contact group@php.net.\n\n   4. Products derived from this software may not be called \"PHP\", nor may \"PHP\" appear in their name, without prior written permission from group@php.net. You may indicate that your software works in conjunction with PHP by saying \"Foo for PHP\" instead of calling it \"PHP Foo\" or \"phpfoo\"\n\n   5. The PHP Group may publish revised and/or new versions of the license from time to time. Each version will be given a distinguishing version number. Once covered code has been published under a particular version of the license, you may always continue to use it under the terms of that version. You may also choose to use such covered code under the terms of any subsequent version of the license published by the PHP Group. No one other than the PHP Group has the right to modify the terms applicable to covered code created under this License.\n\n   6. Redistributions of any form whatsoever must retain the following acknowledgment: \"This product includes PHP, freely available from \u003chttp://www.php.net/\u003e\".\n\nTHIS SOFTWARE IS PROVIDED BY THE PHP DEVELOPMENT TEAM ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE PHP DEVELOPMENT TEAM OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\nThis software consists of voluntary contributions made by many individuals on behalf of the PHP Group.\n\nThe PHP Group can be contacted via Email at group@php.net.\n\nFor more information on the PHP Group and the PHP project, please see \u003chttp://www.php.net\u003e.\n\nThis product includes the Zend Engine, freely available at \u003chttp://www.zend.com\u003e."],"licenseIds":["PHP-3.0"],"keywords":["3 0 copyright","c 1999 2006","1999 2006 the","2006 the php","includes php freely","php freely available","net this software","net this product","version 3 0 copyright","3 0 copyright c","copyright c 1999 2006","c 1999 2006 the","1999 2006 the php","2006 the php group","product includes php freely","includes php freely available","php freely available from","php net this software","net this software is","php net this product","net this product includes","php license version 3 0","license version 3 0 copyright","version 3 0 copyright c","3 0 copyright c 1999","0 copyright c 1999 2006","copyright c 1999 2006 the","c 1999 2006 the php","1999 2006 the php group","2006 the php group all","this product includes php freely","product includes php freely available","includes php freely available from","php freely available from http","www php net this software","php net this software is","net this software is provided","www php net this product","php net this product includes","net this product includes the"]},{"licenseTexts":["The PHP License, version 3.01 Copyright (c) 1999 - 2012 The PHP Group. All rights reserved.\n\nRedistribution and use in source and binary forms, with or without modification, is permitted provided that the following conditions are met:\n\n   1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n   2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   3. The name \"PHP\" must not be used to endorse or promote products derived from this software without prior written permission. For written permission, please contact group@php.net.\n\n   4. Products derived from this software may not be called \"PHP\", nor may \"PHP\" appear in their name, without prior written permission from group@php.net. You may indicate that your software works in conjunction with PHP by saying \"Foo for PHP\" instead of calling it \"PHP Foo\" or \"phpfoo\"\n\n   5. The PHP Group may publish revised and/or new versions of the license from time to time. Each version will be given a distinguishing version number. Once covered code has been published under a particular version of the license, you may always continue to use it under the terms of that version. You may also choose to use such covered code under the terms of any subsequent version of the license published by the PHP Group. No one other than the PHP Group has the right to modify the terms applicable to covered code created under this License.\n\n   6. Redistributions of any form whatsoever must retain the following acknowledgment: \"This product includes PHP software, freely available from \u003chttp://www.php.net/software/\u003e\".\n\nTHIS SOFTWARE IS PROVIDED BY THE PHP DEVELOPMENT TEAM ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE PHP DEVELOPMENT TEAM OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\nThis software consists of voluntary contributions made by many individuals on behalf of the PHP Group.\n\nThe PHP Group can be contacted via Email at group@php.net.\n\nFor more information on the PHP Group and the PHP project, please see \u003chttp://www.php.net\u003e.\n\nPHP includes the Zend Engine, freely available at \u003chttp://www.zend.com\u003e."],"licenseIds":["PHP-3.01"],"keywords":["version 3 01","3 01 copyright","01 copyright c","c 1999 2012","1999 2012 the","2012 the php","includes php software","php software freely","software freely available","php net software","net software this","software this software","php net php","net php includes","php includes the","license version 3 01","version 3 01 copyright","3 01 copyright c","01 copyright c 1999","copyright c 1999 2012","c 1999 2012 the","1999 2012 the php","2012 the php group","product includes php software","includes php software freely","php software freely available","software freely available from","www php net software","php net software this","net software this software","software this software is","www php net php","php net php includes","net php includes the","php includes the zend","php license version 3 01","license version 3 01 copyright","version 3 01 copyright c","3 01 copyright c 1999","01 copyright c 1999 2012","copyright c 1999 2012 the","c 1999 2012 the php","1999 2012 the php group","2012 the php group all","this product includes php software","product includes php software freely","includes php software freely available","php software freely available from","software freely available from http","http www php net software","www php net software this","php net software this software","net software this software is","software this software is provided","http www php net php","www php net php includes","php net php includes the","net php includes the zend","php includes the zend engine"]},{"licenseTexts":["PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2\n\n   1. This LICENSE AGREEMENT is between the Python Software Foundation (\"PSF\"), and the Individual or Organization (\"Licensee\") accessing and otherwise using this software (\"Python\") in source or binary form and its associated documentation.\n\n   2. Subject to the terms and conditions of this License Agreement, PSF hereby grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivative works, distribute, and otherwise use Python alone or in any derivative version, provided, however, that PSF's License Agreement and PSF's notice of copyright, i.e., \"Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006 Python Software Foundation; All Rights Reserved\" are retained in Python alone or in any derivative version prepared by Licensee.\n\n   3. In the event Licensee prepares a derivative work that is based on or incorporates Python or any part thereof, and wants to make the derivative work available to others as provided herein, then Licensee hereby agrees to include in any such work a brief summary of the changes made to Python.\n\n   4. PSF is making Python available to Licensee on an \"AS IS\" basis. PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.\n\n   5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON, OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.\n\n   6. This License Agreement will automatically terminate upon a material breach of its terms and conditions.\n\n   7. Nothing in this License Agreement shall be deemed to create any relationship of agency, partnership, or joint venture between PSF and Licensee. This License Agreement does not grant permission to use PSF trademarks or trade name in a trademark sense to endorse or promote products or services of Licensee, or any third party.\n\n   8. By copying, installing or otherwise using Python, Licensee agrees to be bound by the terms and conditions of this License Agreement."],"licenseIds":["PSF-2.0"],"keywords":null},{"licenseTexts":["The Parity Public License 6.0.0\n\nContributor: contributor name\n\nSource Code: source\n\nThis license lets you use and share this software for free, as long as you contribute software you make with it. Specifically:\n\nIf you follow the rules below, you may do everything with this software that would otherwise infringe either the contributor's copyright in it, any patent claim the contributor can license, or both.\n\n   1. Contribute changes and additions you make to this software.\n\n   2. If you combine this software with other software, contribute that other software.\n\n   3. Contribute software you develop, deploy, monitor, or run with this software.\n\n   4. Ensure everyone who gets a copy of this software from you, in source code or any other form, gets the text of this license and the contributor and source code lines above.\n\n   5. Do not make any legal claim against anyone accusing this software, with or without changes, alone or with other software, of infringing any patent claim.\n\nTo contribute software, publish all its source code, in the preferred form for making changes, through a freely accessible distribution system widely used for similar source code, and license contributions not already licensed to the public on terms as permissive as this license accordingly.\n\nYou are excused for unknowingly breaking 1, 2, or 3 if you contribute as required, or stop doing anything requiring this license, within 30 days of learning you broke the rule.\n\n**As far as the law allows, this software comes as is, without any warranty, and the contributor will not be liable to anyone for any damages related to this software or this license, for any kind of legal claim.**"],"licenseIds":["Parity-6.0.0"],"keywords":["public license 6","license 6 0","6 0 0","0 contributor contributor","contributor contributor name","source code source","code source this","source this license","this license lets","license lets you","lets you use","you use and","for free as","free as long","as you contribute","you contribute software","software you make","you make with","make with it","with it specifically","it specifically if","specifically if you","the rules below","rules below you","may do everything","otherwise infringe either","infringe either the","either the contributor","in it any","it any patent","patent claim the","claim the contributor","contributor can license","license or both","or both 1","both 1 contribute","1 contribute changes","contribute changes and","and additions you","additions you make","make to this","software 2 if","if you combine","you combine this","combine this software","other software contribute","software contribute that","contribute that other","that other software","other software 3","software 3 contribute","3 contribute software","you develop deploy","develop deploy monitor","deploy monitor or","monitor or run","or run with","run with this","this software 4","software 4 ensure","4 ensure everyone","ensure everyone who","you in source","other form gets","form gets the","lines above 5","above 5 do","5 do not","other software of","software of infringing","patent claim to","claim to contribute","to contribute software","contribute software publish","software publish all","publish all its","all its source","code and license","and license contributions","license contributions not","contributions not already","already licensed to","the public on","public on terms","on terms as","terms as permissive","as permissive as","permissive as this","this license accordingly","license accordingly you","accordingly you are","you are excused","are excused for","unknowingly breaking 1","breaking 1 2","2 or 3","or 3 if","you contribute as","license within 30","the rule as","rule as far","the contributor will","contributor will not","parity public license 6","public license 6 0","license 6 0 0","6 0 0 contributor","0 0 contributor contributor","0 contributor contributor name","contributor contributor name source","name source code source","source code source this","code source this license","source this license lets","this license lets you","license lets you use","lets you use and","you use and share","software for free as","for free as long","free as long as","long as you contribute","as you contribute software","you contribute software you","contribute software you make","software you make with","you make with it","make with it specifically","with it specifically if","it specifically if you","specifically if you follow","follow the rules below","the rules below you","rules below you may","below you may do","you may do everything","may do everything with","would otherwise infringe either","otherwise infringe either the","infringe either the contributor","either the contributor s","the contributor s copyright","copyright in it any","in it any patent","it any patent claim","any patent claim the","patent claim the contributor","claim the contributor can","the contributor can license","contributor can license or","can license or both","license or both 1","or both 1 contribute","both 1 contribute changes","1 contribute changes and","contribute changes and additions","changes and additions you","and additions you make","additions you make to","you make to this","make to this software","to this software 2","this software 2 if","software 2 if you","2 if you combine","if you combine this","you combine this software","combine this software with","this software with other","with other software contribute","other software contribute that","software contribute that other","contribute that other software","that other software 3","other software 3 contribute","software 3 contribute software","3 contribute software you","software you develop deploy","you develop deploy monitor","develop deploy monitor or","deploy monitor or run","monitor or run with","or run with this","run with this software","with this software 4","this software 4 ensure","software 4 ensure everyone","4 ensure everyone who","ensure everyone who gets","software from you in","from you in source","you in source code","code or any other","any other form gets","other form gets the","form gets the text","code lines above 5","lines above 5 do","above 5 do not","5 do not make"]},{"licenseTexts":["# The Parity Public License 7.0.0\n\nContributor: name\n\nSource Code: address\n\n## Purpose\n\nThis license allows you to use and share this software for free, but you have to share software that builds on it alike.\n\n## Agreement\n\nIn order to receive this license, you have to agree to its rules. Those rules are both obligations under that agreement and conditions to your license. Don't do anything with this software that triggers a rule you can't or won't follow.\n\n## Notices\n\nMake sure everyone who gets a copy of any part of this software from you, with or without changes, also gets the text of this license and the contributor and source code lines above.\n\n## Copyleft\n\n[Contribute](#contribute) software you develop, operate, or analyze with this software, including changes or additions to this software. When in doubt, [contribute](#contribute) .\n\n## Prototypes\n\nYou don't have to [contribute](#contribute) any change, addition, or other software that meets all these criteria:\n\n   1. You don't use it for more than thirty days.\n\n   2. You don't share it outside the team developing it, other than for non-production user testing.\n\n   3. You don't develop, operate, or analyze other software with it for anyone outside the team developing it.\n\n## Reverse Engineering\n\nYou may use this software to operate and analyze software you can't [contribute](#contribute) in order to develop alternatives you can and do [contribute](#contribute) .\n\n## Contribute\n\nTo [contribute](#contribute) software:\n\n   1. Publish all source code for the software in the preferred form for making changes through a freely accessible distribution system widely used for similar source code so the contributor and others can find and copy it.\n\n   2. Make sure every part of the source code is available under this license or another license that allows everything this license does, such as [the Blue Oak Model License 1.0.0](https://blueoakcouncil.org/license/1.0.0), [the Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0.html), [the MIT license](https://spdx.org/licenses/MIT.html), or [the two-clause BSD license](https://spdx.org/licenses/BSD-2-Clause.html).\n\n   3. Take these steps within thirty days.\n\n   4. Note that this license does _not_ allow you to change the license terms for this software. You must follow [Notices](#notices) .\n\n## Excuse\n\nYou're excused for unknowingly breaking [Copyleft](#copyleft) if you [contribute](#contribute) as required, or stop doing anything requiring this license, within thirty days of learning you broke the rule. You're excused for unknowingly breaking [Notices](#notices) if you take all practical steps to comply within thirty days of learning you broke the rule.\n\n## Defense\n\nDon't make any legal claim against anyone accusing this software, with or without changes, alone or with other technology, of infringing any patent.\n\n## Copyright\n\nThe contributor licenses you to do everything with this software that would otherwise infringe their copyright in it.\n\n## Patent\n\nThe contributor licenses you to do everything with this software that would otherwise infringe any patents they can license or become able to license.\n\n## Reliability\n\nThe contributor can't revoke this license.\n\n## No Liability\n\n***As far as the law allows, this software comes as is, without any warranty or condition, and the contributor won't be liable to anyone for any damages related to this software or this license, under any kind of legal claim.***"],"licenseIds":["Parity-7.0.0"],"keywords":["public license 7","license 7 0","7 0 0","0 contributor name","source code address","code address purpose","address purpose this","this license allows","license allows you","for free but","free but you","but you have","to share software","share software that","software that builds","that builds on","builds on it","on it alike","it alike agreement","alike agreement in","agreement in order","have to agree","to agree to","its rules those","rules those rules","those rules are","rules are both","your license don","license don t","don t do","t do anything","rule you can","can t or","t or won","or won t","won t follow","t follow notices","follow notices make","notices make sure","make sure everyone","sure everyone who","lines above copyleft","above copyleft contribute","copyleft contribute contribute","you develop operate","or analyze with","analyze with this","software including changes","including changes or","this software when","software when in","when in doubt","in doubt contribute","doubt contribute contribute","contribute contribute prototypes","contribute prototypes you","prototypes you don","have to contribute","contribute contribute any","contribute any change","any change addition","change addition or","addition or other","software that meets","that meets all","meets all these","all these criteria","these criteria 1","criteria 1 you","1 you don","don t use","t use it","it for more","for more than","more than thirty","than thirty days","thirty days 2","days 2 you","2 you don","don t share","t share it","share it outside","it outside the","developing it other","for non production","non production user","production user testing","user testing 3","testing 3 you","3 you don","don t develop","t develop operate","or analyze other","analyze other software","other software with","software with it","with it for","it for anyone","for anyone outside","anyone outside the","developing it reverse","it reverse engineering","reverse engineering you","engineering you may","this software to","software to operate","to operate and","operate and analyze","and analyze software","analyze software you","can t contribute","t contribute contribute","contribute contribute in","contribute in order","order to develop","to develop alternatives","develop alternatives you","alternatives you can","you can and","can and do","and do contribute","do contribute contribute","contribute contribute contribute","contribute contribute to","contribute to contribute","contribute software 1","software 1 publish","1 publish all","publish all source","code so the","so the contributor","contributor and others","and others can","others can find","can find and","find and copy","and copy it","copy it 2","it 2 make","2 make sure","make sure every","sure every part","every part of","another license that","license that allows","that allows everything","allows everything this","everything this license","license does such","does such as","as the blue","the blue oak","model license 1","0 https blueoakcouncil","0 0 the","0 the apache","2 0 https","0 https www","https www apache","2 0 html","0 html the","html the mit","mit license https","org licenses mit","licenses mit html","mit html or","html or the","or the two","the two clause","two clause bsd","clause bsd license","bsd license https","org licenses bsd","licenses bsd 2","bsd 2 clause","2 clause html","clause html 3","html 3 take","3 take these","take these steps","these steps within","steps within thirty","thirty days 4","days 4 note","4 note that","you to change","license terms for","terms for this","you must follow","must follow notices","follow notices notices","notices notices excuse","notices excuse you","excuse you re","unknowingly breaking copyleft","breaking copyleft copyleft","copyleft copyleft if","copyleft if you","you contribute contribute","contribute contribute as"]},{"licenseTexts":["Copyright 2002 (C) The Codehaus. All Rights Reserved.\n\nRedistribution and use of this software and associated documentation (\"Software\"), with or without modification, are permitted provided that the following conditions are met:\n\n   1. Redistributions of source code must retain copyright statements and notices. Redistributions must also contain a copy of this document.\n\n   2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   3. The name \"classworlds\" must not be used to endorse or promote products derived from this Software without prior written permission of The Codehaus . For written permission, please contact bob@codehaus.org .\n\n   4. Products derived from this Software may not be called \"classworlds\" nor may \"classworlds\" appear in their names without prior written permission of The Codehaus . \"classworlds\" is a registered trademark of The Codehaus .\n\n   5. Due credit should be given to The Codehaus. (http://classworlds.codehaus.org/) .\n\nTHIS SOFTWARE IS PROVIDED BY THE CODEHAUS AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE CODEHAUS OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."],"licenseIds":["Plexus"],"keywords":["copyright 2002 c","2002 c the","c the codehaus","the codehaus all","codehaus all rights","the name classworlds","name classworlds must","classworlds must not","the codehaus for","codehaus for written","please contact bob","contact bob codehaus","bob codehaus org","codehaus org 4","be called classworlds","called classworlds nor","classworlds nor may","nor may classworlds","may classworlds appear","classworlds appear in","the codehaus classworlds","codehaus classworlds is","classworlds is a","the codehaus 5","codehaus 5 due","to the codehaus","the codehaus http","codehaus http classworlds","http classworlds codehaus","classworlds codehaus org","codehaus org this","by the codehaus","the codehaus and","codehaus and contributors","shall the codehaus","the codehaus or","codehaus or its","copyright 2002 c the","2002 c the codehaus","c the codehaus all","the codehaus all rights","codehaus all rights reserved","3 the name classworlds","the name classworlds must","name classworlds must not","classworlds must not be","of the codehaus for","the codehaus for written","codehaus for written permission","permission please contact bob","please contact bob codehaus","contact bob codehaus org","bob codehaus org 4","codehaus org 4 products","not be called classworlds","be called classworlds nor","called classworlds nor may","classworlds nor may classworlds","nor may classworlds appear","may classworlds appear in","classworlds appear in their","of the codehaus classworlds","the codehaus classworlds is","codehaus classworlds is a","classworlds is a registered","trademark of the codehaus","of the codehaus 5","the codehaus 5 due","codehaus 5 due credit","given to the codehaus","to the codehaus http","the codehaus http classworlds","codehaus http classworlds codehaus","http classworlds codehaus org","classworlds codehaus org this","codehaus org this software","provided by the codehaus","by the codehaus and","the codehaus and contributors","codehaus and contributors as","event shall the codehaus","shall the codehaus or","the codehaus or its","codehaus or its contributors","copyright 2002 c the codehaus","2002 c the codehaus all","c the codehaus all rights","the codehaus all rights reserved","codehaus all rights reserved redistribution","distribution 3 the name classworlds","3 the name classworlds must","the name classworlds must not","name classworlds must not be","classworlds must not be used","permission of the codehaus for","of the codehaus for written","the codehaus for written permission","codehaus for written permission please","written permission please contact bob","permission please contact bob codehaus","please contact bob codehaus org","contact bob codehaus org 4","bob codehaus org 4 products","codehaus org 4 products derived","may not be called classworlds","not be called classworlds nor","be called classworlds nor may","called classworlds nor may classworlds","classworlds nor may classworlds appear","nor may classworlds appear in","may classworlds appear in their","classworlds appear in their names","permission of the codehaus classworlds","of the codehaus classworlds is","the codehaus classworlds is a","codehaus classworlds is a registered","classworlds is a registered trademark","registered trademark of the codehaus","trademark of the codehaus 5","of the codehaus 5 due","the codehaus 5 due credit","codehaus 5 due credit should","be given to the codehaus","given to the codehaus http","to the codehaus http classworlds","the codehaus http classworlds codehaus","codehaus http classworlds codehaus org","http classworlds codehaus org this","classworlds codehaus org this software","codehaus org this software is","is provided by the codehaus","provided by the codehaus and","by the codehaus and contributors","the codehaus and contributors as","codehaus and contributors as is","no event shall the codehaus","event shall the codehaus or","shall the codehaus or its","the codehaus or its contributors","codehaus or its contributors be"]},{"licenseTexts":["# PolyForm Noncommercial License 1.0.0\n\n\u003chttps://polyformproject.org/licenses/noncommercial/1.0.0\u003e\n\n## Acceptance\n\nIn order to get any license under these terms, you must agree to them as both strict obligations and conditions to all your licenses.\n\n## Copyright License\n\nThe licensor grants you a copyright license for the software to do everything you might do with the software that would otherwise infringe the licensor's copyright in it for any permitted purpose. However, you may only distribute the software according to [Distribution License](#distribution-license) and make changes or new works based on the software according to [Changes and New Works License](#changes-and-new-works-license).\n\n## Distribution License\n\nThe licensor grants you an additional copyright license to distribute copies of the software. Your license to distribute covers distributing the software with changes and new works permitted by [Changes and New Works License](#changes-and-new-works-license).\n\n## Notices\n\nYou must ensure that anyone who gets a copy of any part of the software from you also gets a copy of these terms or the URL for them above, as well as copies of any plain-text lines beginning with `Required Notice:` that the licensor provided with the software. For example:\n\n\u003e Required Notice: Copyright Yoyodyne, Inc. (http://example.com)\n\n## Changes and New Works License\n\nThe licensor grants you an additional copyright license to make changes and new works based on the software for any permitted purpose.\n\n## Patent License\n\nThe licensor grants you a patent license for the software that covers patent claims the licensor can license, or becomes able to license, that you would infringe by using the software.\n\n## Noncommercial Purposes\n\nAny noncommercial purpose is a permitted purpose.\n\n## Personal Uses\n\nPersonal use for research, experiment, and testing for the benefit of public knowledge, personal study, private entertainment, hobby projects, amateur pursuits, or religious observance, without any anticipated commercial application, is use for a permitted purpose.\n\n## Noncommercial Organizations\n\nUse by any charitable organization, educational institution, public research organization, public safety or health organization, environmental protection organization, or government institution is use for a permitted purpose regardless of the source of funding or obligations resulting from the funding.\n\n## Fair Use\n\nYou may have \"fair use\" rights for the software under the law. These terms do not limit them.\n\n## No Other Rights\n\nThese terms do not allow you to sublicense or transfer any of your licenses to anyone else, or prevent the licensor from granting licenses to anyone else. These terms do not imply any other licenses.\n\n## Patent Defense\n\nIf you make any written claim that the software infringes or contributes to infringement of any patent, your patent license for the software granted under these terms ends immediately. If your company makes such a claim, your patent license ends immediately for work on behalf of your company.\n\n## Violations\n\nThe first time you are notified in writing that you have violated any of these terms, or done anything with the software not covered by your licenses, your licenses can nonetheless continue if you come into full compliance with these terms, and take practical steps to correct past violations, within 32 days of receiving notice. Otherwise, all your licenses end immediately.\n\n## No Liability\n\n***As far as the law allows, the software comes as is, without any warranty or condition, and the licensor will not be liable to you for any damages arising out of these terms or the use or nature of the software, under any kind of legal claim.***\n\n## Definitions\n\nThe **licensor** is the individual or entity offering these terms, and the **software** is the software the licensor makes available under these terms.\n\n**You** refers to the individual or entity agreeing to these terms.\n\n**Your company** is any legal entity, sole proprietorship, or other kind of organization that you work for, plus all organizations that have control over, are under the control of, or are under common control with that organization. **Control** means ownership of substantially all the assets of an entity, or the power to direct its management and policies by vote, contract, or otherwise. Control can be direct or indirect.\n\n**Your licenses** are all the licenses granted to you for the software under these terms.\n\n**Use** means anything you do with the software requiring one of your licenses."],"licenseIds":["PolyForm-Noncommercial-1.0.0"],"keywords":["polyform noncommercial license","noncommercial license 1","org licenses noncommercial","licenses noncommercial 1","the software noncommercial","software noncommercial purposes","noncommercial purposes any","purposes any noncommercial","any noncommercial purpose","noncommercial purpose is","purpose is a","is a permitted","permitted purpose personal","purpose personal uses","personal uses personal","uses personal use","personal use for","use for research","for research experiment","research experiment and","experiment and testing","and testing for","testing for the","benefit of public","of public knowledge","public knowledge personal","knowledge personal study","personal study private","study private entertainment","private entertainment hobby","entertainment hobby projects","hobby projects amateur","projects amateur pursuits","amateur pursuits or","pursuits or religious","or religious observance","religious observance without","observance without any","without any anticipated","any anticipated commercial","anticipated commercial application","commercial application is","application is use","permitted purpose noncommercial","purpose noncommercial organizations","noncommercial organizations use","organizations use by","by any charitable","any charitable organization","charitable organization educational","organization educational institution","educational institution public","institution public research","public research organization","research organization public","organization public safety","public safety or","safety or health","or health organization","health organization environmental","organization environmental protection","environmental protection organization","protection organization or","organization or government","or government institution","government institution is","institution is use","permitted purpose regardless","purpose regardless of","source of funding","of funding or","funding or obligations","or obligations resulting","obligations resulting from","from the funding","the funding fair","funding fair use","limit them no","them no other","polyform noncommercial license 1","noncommercial license 1 0","polyformproject org licenses noncommercial","org licenses noncommercial 1","licenses noncommercial 1 0","noncommercial 1 0 0","using the software noncommercial","the software noncommercial purposes","software noncommercial purposes any","noncommercial purposes any noncommercial","purposes any noncommercial purpose","any noncommercial purpose is","noncommercial purpose is a","purpose is a permitted","is a permitted purpose","a permitted purpose personal","permitted purpose personal uses","purpose personal uses personal","personal uses personal use","uses personal use for","personal use for research","use for research experiment","for research experiment and","research experiment and testing","experiment and testing for","and testing for the","testing for the benefit","the benefit of public","benefit of public knowledge","of public knowledge personal","public knowledge personal study","knowledge personal study private","personal study private entertainment","study private entertainment hobby","private entertainment hobby projects","entertainment hobby projects amateur","hobby projects amateur pursuits","projects amateur pursuits or","amateur pursuits or religious","pursuits or religious observance","or religious observance without","religious observance without any","observance without any anticipated","without any anticipated commercial","any anticipated commercial application","anticipated commercial application is","commercial application is use","application is use for","a permitted purpose noncommercial","permitted purpose noncommercial organizations","purpose noncommercial organizations use","noncommercial organizations use by","organizations use by any","use by any charitable","by any charitable organization","any charitable organization educational","charitable organization educational institution","organization educational institution public","educational institution public research","institution public research organization","public research organization public","research organization public safety","organization public safety or","public safety or health","safety or health organization","or health organization environmental","health organization environmental protection","organization environmental protection organization","environmental protection organization or","protection organization or government","organization or government institution","or government institution is","government institution is use","institution is use for","a permitted purpose regardless","permitted purpose regardless of","purpose regardless of the","regardless of the source","of the source of","the source of funding","source of funding or","of funding or obligations","funding or obligations resulting","or obligations resulting from","obligations resulting from the","resulting from the funding","from the funding fair","the funding fair use","funding fair use you","not limit them no","limit them no other","them no other rights","polyform noncommercial license 1 0","noncommercial license 1 0 0","https polyformproject org licenses noncommercial","polyformproject org licenses noncommercial 1","org licenses noncommercial 1 0","licenses noncommercial 1 0 0","noncommercial 1 0 0 acceptance","by using the software noncommercial","using the software noncommercial purposes","the software noncommercial purposes any","software noncommercial purposes any noncommercial","noncommercial purposes any noncommercial purpose","purposes any noncommercial purpose is","any noncommercial purpose is a","noncommercial purpose is a permitted","purpose is a permitted purpose","is a permitted purpose personal","a permitted purpose personal uses","permitted purpose personal uses personal","purpose personal uses personal use","personal uses personal use for","uses personal use for research","personal use for research experiment","use for research experiment and","for research experiment and testing","research experiment and testing for","experiment and testing for the","and testing for the benefit","testing for the benefit of"]},{"licenseTexts":["# PolyForm Small Business License 1.0.0\n\n\u003chttps://polyformproject.org/licenses/small-business/1.0.0\u003e\n\n## Acceptance\n\nIn order to get any license under these terms, you must agree to them as both strict obligations and conditions to all your licenses.\n\n## Copyright License\n\nThe licensor grants you a copyright license for the software to do everything you might do with the software that would otherwise infringe the licensor's copyright in it for any permitted purpose. However, you may only distribute the software according to [Distribution License](#distribution-license) and make changes or new works based on the software according to [Changes and New Works License](#changes-and-new-works-license).\n\n## Distribution License\n\nThe licensor grants you an additional copyright license to distribute copies of the software. Your license to distribute covers distributing the software with changes and new works permitted by [Changes and New Works License](#changes-and-new-works-license).\n\n## Notices\n\nYou must ensure that anyone who gets a copy of any part of the software from you also gets a copy of these terms or the URL for them above, as well as copies of any plain-text lines beginning with `Required Notice:` that the licensor provided with the software. For example:\n\n\u003e Required Notice: Copyright Yoyodyne, Inc. (http://example.com)\n\n## Changes and New Works License\n\nThe licensor grants you an additional copyright license to make changes and new works based on the software for any permitted purpose.\n\n## Patent License\n\nThe licensor grants you a patent license for the software that covers patent claims the licensor can license, or becomes able to license, that you would infringe by using the software.\n\n## Fair Use\n\nYou may have \"fair use\" rights for the software under the law. These terms do not limit them.\n\n## Small Business\n\nUse of the software for the benefit of your company is use for a permitted purpose if your company has fewer than 100 total individuals working as employees and independent contractors, and less than 1,000,000 USD (2019) total revenue in the prior tax year. Adjust this revenue threshold for inflation according to the United States Bureau of Labor Statistics' consumer price index for all urban consumers, U.S. city average, for all items, not seasonally adjusted, with 1982–1984=100 reference base.\n\n## No Other Rights\n\nThese terms do not allow you to sublicense or transfer any of your licenses to anyone else, or prevent the licensor from granting licenses to anyone else. These terms do not imply any other licenses.\n\n## Patent Defense\n\nIf you make any written claim that the software infringes or contributes to infringement of any patent, your patent license for the software granted under these terms ends immediately. If your company makes such a claim, your patent license ends immediately for work on behalf of your company.\n\n## Violations\n\nThe first time you are notified in writing that you have violated any of these terms, or done anything with the software not covered by your licenses, your licenses can nonetheless continue if you come into full compliance with these terms, and take practical steps to correct past violations, within 32 days of receiving notice. Otherwise, all your licenses end immediately.\n\n## No Liability\n\n***As far as the law allows, the software comes as is, without any warranty or condition, and the licensor will not be liable to you for any damages arising out of these terms or the use or nature of the software, under any kind of legal claim.***\n\n## Definitions\n\nThe **licensor** is the individual or entity offering these terms, and the **software** is the software the licensor makes available under these terms.\n\n**You** refers to the individual or entity agreeing to these terms.\n\n**Your company** is any legal entity, sole proprietorship, or other kind of organization that you work for, plus all organizations that have control over, are under the control of, or are under common control with that organization. **Control** means ownership of substantially all the assets of an entity, or the power to direct its management and policies by vote, contract, or otherwise. Control can be direct or indirect.\n\n**Your licenses** are all the licenses granted to you for the software under these terms.\n\n**Use** means anything you do with the software requiring one of your licenses."],"licenseIds":["PolyForm-Small-Business-1.0.0"],"keywords":["polyform small business","small business license","business license 1","org licenses small","licenses small business","small business 1","business 1 0","the software fair","software fair use","limit them small","them small business","small business use","business use of","benefit of your","company is use","permitted purpose if","purpose if your","your company has","company has fewer","fewer than 100","than 100 total","100 total individuals","total individuals working","individuals working as","working as employees","as employees and","employees and independent","and independent contractors","contractors and less","and less than","less than 1","than 1 000","1 000 000","000 000 usd","000 usd 2019","usd 2019 total","2019 total revenue","total revenue in","revenue in the","in the prior","the prior tax","prior tax year","tax year adjust","year adjust this","adjust this revenue","this revenue threshold","revenue threshold for","threshold for inflation","for inflation according","inflation according to","united states bureau","states bureau of","bureau of labor","of labor statistics","labor statistics consumer","statistics consumer price","consumer price index","price index for","index for all","for all urban","all urban consumers","urban consumers u","consumers u s","u s city","s city average","city average for","average for all","for all items","all items not","items not seasonally","not seasonally adjusted","seasonally adjusted with","adjusted with 1982","with 1982 1984","1982 1984 100","1984 100 reference","100 reference base","reference base no","base no other","polyform small business license","small business license 1","business license 1 0","polyformproject org licenses small","org licenses small business","licenses small business 1","small business 1 0","business 1 0 0","using the software fair","the software fair use","software fair use you","not limit them small","limit them small business","them small business use","small business use of","business use of the","software for the benefit","the benefit of your","benefit of your company","of your company is","your company is use","company is use for","a permitted purpose if","permitted purpose if your","purpose if your company","if your company has","your company has fewer","company has fewer than","has fewer than 100","fewer than 100 total","than 100 total individuals","100 total individuals working","total individuals working as","individuals working as employees","working as employees and","as employees and independent","employees and independent contractors","and independent contractors and","independent contractors and less","contractors and less than","and less than 1","less than 1 000","than 1 000 000","1 000 000 usd","000 000 usd 2019","000 usd 2019 total","usd 2019 total revenue","2019 total revenue in","total revenue in the","revenue in the prior","in the prior tax","the prior tax year","prior tax year adjust","tax year adjust this","year adjust this revenue","adjust this revenue threshold","this revenue threshold for","revenue threshold for inflation","threshold for inflation according","for inflation according to","inflation according to the","according to the united","the united states bureau","united states bureau of","states bureau of labor","bureau of labor statistics","of labor statistics consumer","labor statistics consumer price","statistics consumer price index","consumer price index for","price index for all","index for all urban","for all urban consumers","all urban consumers u","urban consumers u s","consumers u s city","u s city average","s city average for","city average for all","average for all items","for all items not","all items not seasonally","items not seasonally adjusted","not seasonally adjusted with","seasonally adjusted with 1982","adjusted with 1982 1984","with 1982 1984 100","1982 1984 100 reference","1984 100 reference base","100 reference base no","reference base no other","base no other rights","polyform small business license 1","small business license 1 0","business license 1 0 0","https polyformproject org licenses small","polyformproject org licenses small business","org licenses small business 1","licenses small business 1 0","small business 1 0 0","business 1 0 0 acceptance","by using the software fair","using the software fair use","the software fair use you","software fair use you may","do not limit them small","not limit them small business","limit them small business use","them small business use of","small business use of the","business use of the software","use of the software for","of the software for the","the software for the benefit","software for the benefit of","for the benefit of your","the benefit of your company","benefit of your company is","of your company is use","your company is use for","company is use for a"]},{"licenseTexts":["PostgreSQL Database Management System\n\n(formerly known as Postgres, then as Postgres95) Portions Copyright (c) 1996-2010, The PostgreSQL Global Development Group\n\nPortions Copyright (c) 1994, The Regents of the University of California\n\nPermission to use, copy, modify, and distribute this software and its documentation for any purpose, without fee, and without a written agreement is hereby granted, provided that the above copyright notice and this paragraph and the following two paragraphs appear in all copies.\n\nIN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\nTHE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN \"AS IS\" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATIONS TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS."],"licenseIds":["PostgreSQL"],"keywords":["postgresql database management","database management system","management system formerly","system formerly known","known as postgres","as postgres then","postgres then as","then as postgres95","as postgres95 portions","postgres95 portions copyright","1996 2010 the","2010 the postgresql","the postgresql global","postgresql global development","global development group","development group portions","group portions copyright","c 1994 the","1994 the regents","california permission to","fee and without","without a written","written agreement is","agreement is hereby","following two paragraphs","two paragraphs appear","paragraphs appear in","all copies in","copies in no","shall the university","lost profits arising","profits arising out","its documentation even","if the university","california has been","damage the university","of california specifically","california specifically disclaims","disclaims any warranties","purpose the software","software provided hereunder","provided hereunder is","hereunder is on","is on an","california has no","has no obligations","no obligations to","obligations to provide","postgresql database management system","database management system formerly","management system formerly known","system formerly known as","formerly known as postgres","known as postgres then","as postgres then as","postgres then as postgres95","then as postgres95 portions","as postgres95 portions copyright","postgres95 portions copyright c","portions copyright c 1996","c 1996 2010 the","1996 2010 the postgresql","2010 the postgresql global","the postgresql global development","postgresql global development group","global development group portions","development group portions copyright","group portions copyright c","portions copyright c 1994","copyright c 1994 the","c 1994 the regents","1994 the regents of","of california permission to","california permission to use","purpose without fee and","without fee and without","fee and without a","and without a written","without a written agreement","a written agreement is","written agreement is hereby","agreement is hereby granted","notice and this paragraph","and this paragraph and","paragraph and the following","and the following two","the following two paragraphs","following two paragraphs appear","two paragraphs appear in","paragraphs appear in all","in all copies in","all copies in no","copies in no event","event shall the university","shall the university of","california be liable to","consequential damages including lost","including lost profits arising","lost profits arising out","profits arising out of","and its documentation even","its documentation even if","even if the university","if the university of","of california has been","california has been advised","such damage the university","damage the university of","university of california specifically","of california specifically disclaims","california specifically disclaims any","specifically disclaims any warranties","disclaims any warranties including","particular purpose the software","purpose the software provided","the software provided hereunder","software provided hereunder is","provided hereunder is on","hereunder is on an","is on an as","basis and the university","and the university of","of california has no","california has no obligations","has no obligations to","no obligations to provide","obligations to provide maintenance","postgresql database management system formerly","database management system formerly known","management system formerly known as","system formerly known as postgres","formerly known as postgres then","known as postgres then as","as postgres then as postgres95","postgres then as postgres95 portions","then as postgres95 portions copyright","as postgres95 portions copyright c","postgres95 portions copyright c 1996","portions copyright c 1996 2010","copyright c 1996 2010 the","c 1996 2010 the postgresql","1996 2010 the postgresql global","2010 the postgresql global development","the postgresql global development group","postgresql global development group portions","global development group portions copyright","development group portions copyright c","group portions copyright c 1994","portions copyright c 1994 the","copyright c 1994 the regents","c 1994 the regents of","1994 the regents of the","university of california permission to","of california permission to use","california permission to use copy","documentation for any purpose without","any purpose without fee and","purpose without fee and without","without fee and without a","fee and without a written","and without a written agreement","without a written agreement is","a written agreement is hereby","written agreement is hereby granted","agreement is hereby granted provided","copyright notice and this paragraph","notice and this paragraph and","and this paragraph and the","this paragraph and the following","paragraph and the following two","and the following two paragraphs","the following two paragraphs appear","following two paragraphs appear in","two paragraphs appear in all","paragraphs appear in all copies","appear in all copies in","in all copies in no","all copies in no event","copies in no event shall","no event shall the university","event shall the university of","shall the university of california","of california be liable to","california be liable to any","or consequential damages including lost","consequential damages including lost profits","damages including lost profits arising","including lost profits arising out","lost profits arising out of","profits arising out of the","of this software and its","software and its documentation even","and its documentation even if","its documentation even if the","documentation even if the university","even if the university of","if the university of california","university of california has been","of california has been advised","california has been advised of"]},{"licenseTexts":["PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2\n\n   1. This LICENSE AGREEMENT is between the Python Software Foundation (\"PSF\"), and the Individual or Organization (\"Licensee\") accessing and otherwise using this software (\"Python\") in source or binary form and its associated documentation.\n\n   2. Subject to the terms and conditions of this License Agreement, PSF hereby grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivative works, distribute, and otherwise use Python alone or in any derivative version, provided, however, that PSF's License Agreement and PSF's notice of copyright, i.e., \"Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006 Python Software Foundation; All Rights Reserved\" are retained in Python alone or in any derivative version prepared by Licensee.\n\n   3. In the event Licensee prepares a derivative work that is based on or incorporates Python or any part thereof, and wants to make the derivative work available to others as provided herein, then Licensee hereby agrees to include in any such work a brief summary of the changes made to Python.\n\n   4. PSF is making Python available to Licensee on an \"AS IS\" basis. PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.\n\n   5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON, OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.\n\n   6. This License Agreement will automatically terminate upon a material breach of its terms and conditions.\n\n   7. Nothing in this License Agreement shall be deemed to create any relationship of agency, partnership, or joint venture between PSF and Licensee. This License Agreement does not grant permission to use PSF trademarks or trade name in a trademark sense to endorse or promote products or services of Licensee, or any third party.\n\n   8. By copying, installing or otherwise using Python, Licensee agrees to be bound by the terms and conditions of this License Agreement. BEOPEN.COM LICENSE AGREEMENT FOR PYTHON 2.0\n\nBEOPEN PYTHON OPEN SOURCE LICENSE AGREEMENT VERSION 1\n\n   1. This LICENSE AGREEMENT is between BeOpen.com (\"BeOpen\"), having an office at 160 Saratoga Avenue, Santa Clara, CA 95051, and the Individual or Organization (\"Licensee\") accessing and otherwise using this software in source or binary form and its associated documentation (\"the Software\").\n\n   2. Subject to the terms and conditions of this BeOpen Python License Agreement, BeOpen hereby grants Licensee a non-exclusive, royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivative works, distribute, and otherwise use the Software alone or in any derivative version, provided, however, that the BeOpen Python License is retained in the Software, alone or in any derivative version prepared by Licensee.\n\n   3. BeOpen is making the Software available to Licensee on an \"AS IS\" basis. BEOPEN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, BEOPEN MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.\n\n   4. BEOPEN SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE SOFTWARE FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.\n\n   5. This License Agreement will automatically terminate upon a material breach of its terms and conditions.\n\n   6. This License Agreement shall be governed by and interpreted in all respects by the law of the State of California, excluding conflict of law provisions. Nothing in this License Agreement shall be deemed to create any relationship of agency, partnership, or joint venture between BeOpen and Licensee. This License Agreement does not grant permission to use BeOpen trademarks or trade names in a trademark sense to endorse or promote products or services of Licensee, or any third party. As an exception, the \"BeOpen Python\" logos available at http://www.pythonlabs.com/logos.html may be used according to the permissions granted on that web page.\n\n   7. By copying, installing or otherwise using the software, Licensee agrees to be bound by the terms and conditions of this License Agreement. CNRI OPEN SOURCE LICENSE AGREEMENT (for Python 1.6b1) IMPORTANT: PLEASE READ THE FOLLOWING AGREEMENT CAREFULLY.\n\nBY CLICKING ON \"ACCEPT\" WHERE INDICATED BELOW, OR BY COPYING, INSTALLING OR OTHERWISE USING PYTHON 1.6, beta 1 SOFTWARE, YOU ARE DEEMED TO HAVE AGREED TO THE TERMS AND CONDITIONS OF THIS LICENSE AGREEMENT.\n\n   1. This LICENSE AGREEMENT is between the Corporation for National Research Initiatives, having an office at 1895 Preston White Drive, Reston, VA 20191 (\"CNRI\"), and the Individual or Organization (\"Licensee\") accessing and otherwise using Python 1.6, beta 1 software in source or binary form and its associated documentation, as released at the www.python.org Internet site on August 4, 2000 (\"Python 1.6b1\").\n\n   2. Subject to the terms and conditions of this License Agreement, CNRI hereby grants Licensee a non-exclusive, royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivative works, distribute, and otherwise use Python 1.6b1 alone or in any derivative version, provided, however, that CNRIs License Agreement is retained in Python 1.6b1, alone or in any derivative version prepared by Licensee.\n\n   Alternately, in lieu of CNRIs License Agreement, Licensee may substitute the following text (omitting the quotes): \"Python 1.6, beta 1, is made available subject to the terms and conditions in CNRIs License Agreement. This Agreement may be located on the Internet using the following unique, persistent identifier (known as a handle): 1895.22/1011. This Agreement may also be obtained from a proxy server on the Internet using the URL:http://hdl.handle.net/1895.22/1011\".\n\n   3. In the event Licensee prepares a derivative work that is based on or incorporates Python 1.6b1 or any part thereof, and wants to make the derivative work available to the public as provided herein, then Licensee hereby agrees to indicate in any such work the nature of the modifications made to Python 1.6b1.\n\n   4. CNRI is making Python 1.6b1 available to Licensee on an \"AS IS\" basis. CNRI MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, CNRI MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 1.6b1 WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.\n\n   5. CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE SOFTWARE FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF USING, MODIFYING OR DISTRIBUTING PYTHON 1.6b1, OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.\n\n   6. This License Agreement will automatically terminate upon a material breach of its terms and conditions.\n\n   7. This License Agreement shall be governed by and interpreted in all respects by the law of the State of Virginia, excluding conflict of law provisions. Nothing in this License Agreement shall be deemed to create any relationship of agency, partnership, or joint venture between CNRI and Licensee. This License Agreement does not grant permission to use CNRI trademarks or trade name in a trademark sense to endorse or promote products or services of Licensee, or any third party.\n\n   8. By clicking on the \"ACCEPT\" button where indicated, or by copying, installing or otherwise using Python 1.6b1, Licensee agrees to be bound by the terms and conditions of this License Agreement. ACCEPT CWI LICENSE AGREEMENT FOR PYTHON 0.9.0 THROUGH 1.2 Copyright (c) 1991 - 1995, Stichting Mathematisch Centrum Amsterdam, The Netherlands. All rights reserved.\n\nPermission to use, copy, modify, and distribute this software and its documentation for any purpose and without fee is hereby granted, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation, and that the name of Stichting Mathematisch Centrum or CWI not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission.\n\nSTICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE."],"licenseIds":["Python-2.0"],"keywords":["agreement beopen com","beopen com license","com license agreement","for python 2","python 2 0","2 0 beopen","0 beopen python","beopen python open","python open source","is between beopen","between beopen com","beopen com beopen","com beopen having","beopen having an","office at 160","at 160 saratoga","160 saratoga avenue","saratoga avenue santa","avenue santa clara","santa clara ca","clara ca 95051","ca 95051 and","95051 and the","of this beopen","this beopen python","python license agreement","agreement beopen hereby","beopen hereby grants","that the beopen","python license is","licensee 3 beopen","3 beopen is","beopen is making","is basis beopen","basis beopen makes","not limitation beopen","limitation beopen makes","rights 4 beopen","4 beopen shall","beopen shall not","possibility thereof 5","thereof 5 this","conditions 6 this","venture between beopen","between beopen and","beopen and licensee","to use beopen","use beopen trademarks","beopen trademarks or","third party as","party as an","an exception the","exception the beopen","beopen python logos","python logos available","http www pythonlabs","www pythonlabs com","pythonlabs com logos","com logos html","logos html may","html may be","be used according","used according to","permissions granted on","granted on that","on that web","that web page","web page 7","page 7 by","7 by copying","agreement cnri open","for python 1","1 6b1 important","6b1 important please","agreement accept cwi","accept cwi license","cwi license agreement","for python 0","python 0 9","0 9 0","9 0 through","0 through 1","1 2 copyright","1991 1995 stichting","1995 stichting mathematisch","mathematisch centrum amsterdam","centrum amsterdam the","amsterdam the netherlands","the netherlands all","netherlands all rights","name of stichting","of stichting mathematisch","mathematisch centrum or","centrum or cwi","or cwi not","cwi not be","prior permission stichting","permission stichting mathematisch","mathematisch centrum disclaims","centrum disclaims all","event shall stichting","shall stichting mathematisch","mathematisch centrum be","centrum be liable","this license agreement beopen","license agreement beopen com","agreement beopen com license","beopen com license agreement","com license agreement for","agreement for python 2","for python 2 0","python 2 0 beopen","2 0 beopen python","0 beopen python open","beopen python open source","python open source license","source license agreement version","agreement is between beopen","is between beopen com","between beopen com beopen","beopen com beopen having","com beopen having an","beopen having an office","an office at 160","office at 160 saratoga","at 160 saratoga avenue","160 saratoga avenue santa","saratoga avenue santa clara","avenue santa clara ca","santa clara ca 95051","clara ca 95051 and","ca 95051 and the","95051 and the individual","the software 2 subject","conditions of this beopen","of this beopen python","this beopen python license","beopen python license agreement","python license agreement beopen","license agreement beopen hereby","agreement beopen hereby grants","beopen hereby grants licensee","however that the beopen","that the beopen python","the beopen python license","beopen python license is","python license is retained","license is retained in","by licensee 3 beopen","licensee 3 beopen is","3 beopen is making","beopen is making the","as is basis beopen","is basis beopen makes","basis beopen makes no","beopen makes no representations","but not limitation beopen","not limitation beopen makes","limitation beopen makes no","beopen makes no and","party rights 4 beopen","rights 4 beopen shall","4 beopen shall not","beopen shall not be","the possibility thereof 5","possibility thereof 5 this","thereof 5 this license","5 this license agreement","and conditions 6 this","conditions 6 this license","joint venture between beopen","venture between beopen and","between beopen and licensee","beopen and licensee this","permission to use beopen","to use beopen trademarks","use beopen trademarks or","beopen trademarks or trade","any third party as","third party as an","party as an exception","as an exception the","an exception the beopen","exception the beopen python","the beopen python logos","beopen python logos available","python logos available at","at http www pythonlabs","http www pythonlabs com","www pythonlabs com logos","pythonlabs com logos html","com logos html may","logos html may be","html may be used","may be used according","be used according to","used according to the","according to the permissions","the permissions granted on","permissions granted on that"]},{"licenseTexts":["THE Q PUBLIC LICENSE version 1.0 Copyright (C) 1999-2005 Trolltech AS, Norway.\n\nEveryone is permitted to copy and distribute this license document.\n\nThe intent of this license is to establish freedom to share and change the software regulated by this license under the open source model.\n\nThis license applies to any software containing a notice placed by the copyright holder saying that it may be distributed under the terms of the Q Public License version 1.0. Such software is herein referred to as the Software. This license covers modification and distribution of the Software, use of third-party application programs based on the Software, and development of free software which uses the Software.\n\nGranted Rights\n\n   1. You are granted the non-exclusive rights set forth in this license provided you agree to and comply with any and all conditions in this license. Whole or partial distribution of the Software, or software items that link with the Software, in any form signifies acceptance of this license.\n\n   2. You may copy and distribute the Software in unmodified form provided that the entire package, including - but not restricted to - copyright, trademark notices and disclaimers, as released by the initial developer of the Software, is distributed.\n\n   3. You may make modifications to the Software and distribute your modifications, in a form that is separate from the Software, such as patches. The following restrictions apply to modifications:\n\n      a. Modifications must not alter or remove any copyright notices in the Software.\n\n      b. When modifications to the Software are released under this license, a non-exclusive royalty-free right is granted to the initial developer of the Software to distribute your modification in future versions of the Software provided such versions remain available under these terms in addition to any other license(s) of the initial developer.\n\n   4. You may distribute machine-executable forms of the Software or machine-executable forms of modified versions of the Software, provided that you meet these restrictions:\n\n      a. You must include this license document in the distribution.\n\n      b. You must ensure that all recipients of the machine-executable forms are also able to receive the complete machine-readable source code to the distributed Software, including all modifications, without any charge beyond the costs of data transfer, and place prominent notices in the distribution explaining this.\n\n      c. You must ensure that all modifications included in the machine-executable forms are available under the terms of this license.\n\n   5. You may use the original or modified versions of the Software to compile, link and run application programs legally developed by you or by others.\n\n   6. You may develop application programs, reusable components and other software items that link with the original or modified versions of the Software. These items, when distributed, are subject to the following requirements:\n\n      a. You must ensure that all recipients of machine-executable forms of these items are also able to receive and use the complete machine-readable source code to the items without any charge beyond the costs of data transfer.\n\n      b. You must explicitly license all recipients of your items to use and re-distribute original and modified versions of the items in both machine-executable and source code forms. The recipients must be able to do so without any charges whatsoever, and they must be able to re-distribute to anyone they choose.\n\n      c. If the items are not available to the general public, and the initial developer of the Software requests a copy of the items, then you must supply one.\n\nLimitations of Liability\n\nIn no event shall the initial developers or copyright holders be liable for any damages whatsoever, including - but not restricted to - lost revenue or profits or other direct, indirect, special, incidental or consequential damages, even if they have been advised of the possibility of such damages, except to the extent invariable law, if any, provides otherwise.\n\nNo Warranty\n\nThe Software and this license document are provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.\n\nChoice of Law\n\nThis license is governed by the Laws of Norway. Disputes shall be settled by Oslo City Court."],"licenseIds":["QPL-1.0"],"keywords":["c 1999 2005","1999 2005 trolltech","2005 trolltech as","trolltech as norway","as norway everyone","norway everyone is","document the intent","is to establish","to establish freedom","establish freedom to","the software regulated","software regulated by","regulated by this","open source model","source model this","model this license","any software containing","software containing a","holder saying that","saying that it","of the q","1 0 such","0 such software","software is herein","is herein referred","herein referred to","license covers modification","covers modification and","the software use","software use of","use of third","third party application","party application programs","application programs based","programs based on","software and development","and development of","which uses the","software granted rights","granted rights 1","rights 1 you","granted the non","non exclusive rights","exclusive rights set","provided you agree","agree to and","to and comply","and all conditions","all conditions in","this license whole","license whole or","whole or partial","or partial distribution","partial distribution of","software or software","or software items","any form signifies","form signifies acceptance","signifies acceptance of","software in unmodified","unmodified form provided","entire package including","package including but","restricted to copyright","to copyright trademark","copyright trademark notices","trademark notices and","and disclaimers as","disclaimers as released","distributed 3 you","the software such","such as patches","as patches the","patches the following","following restrictions apply","restrictions apply to","apply to modifications","to modifications a","modifications a modifications","a modifications must","modifications must not","must not alter","alter or remove","or remove any","remove any copyright","software b when","b when modifications","when modifications to","software are released","are released under","free right is","software to distribute","distribute your modification","your modification in","modification in future","software provided such","provided such versions","such versions remain","versions remain available","remain available under","these terms in","terms in addition","other license s","license s of","initial developer 4","developer 4 you","may distribute machine","distribute machine executable","software or machine","or machine executable","forms of modified","you meet these","meet these restrictions","these restrictions a","license document in","document in the","the distribution b","distribution b you","of the machine","forms are also","receive the complete","to the distributed","the distributed software","distributed software including","all modifications without","modifications without any","data transfer and","transfer and place","and place prominent","place prominent notices","prominent notices in","the distribution explaining","distribution explaining this","explaining this c","this c you","all modifications included","modifications included in","in the machine","forms are available","are available under","license 5 you","software to compile","to compile link","compile link and","link and run","and run application","run application programs","application programs legally","programs legally developed","legally developed by","by others 6","others 6 you","may develop application","develop application programs","application programs reusable","programs reusable components","reusable components and","components and other","and other software","other software items","the software these","software these items","these items when","items when distributed","when distributed are","distributed are subject","the following requirements","following requirements a","requirements a you","recipients of machine","forms of these","of these items","these items are","items are also","to receive and","receive and use","use the complete","to the items","the items without","items without any","data transfer b","transfer b you","you must explicitly","must explicitly license","explicitly license all","license all recipients","of your items","your items to","items to use","and re distribute","re distribute original","distribute original and","the items in","items in both","in both machine","both machine executable","machine executable and","source code forms","code forms the","forms the recipients"]},{"licenseTexts":["Qhull, Copyright (c) 1993-2003\n\nThe National Science and Technology Research Center for Computation and Visualization of Geometric Structures (The Geometry Center) University of Minnesota\n\nemail: qhull@qhull.org\n\nThis software includes Qhull from The Geometry Center. Qhull is copyrighted as noted above. Qhull is free software and may be obtained via http from www.qhull.org. It may be freely copied, modified, and redistributed under the following conditions:\n\n   1. All copyright notices must remain intact in all files.\n\n   2. A copy of this text file must be distributed along with any copies of Qhull that you redistribute; this includes copies that you have modified, or copies of programs or other software products that include Qhull.\n\n   3. If you modify Qhull, you must include a notice giving the name of the person performing the modification, the date of modification, and the reason for such modification.\n\n   4. When distributing modified versions of Qhull, or other software products that include Qhull, you must provide notice that the original source code may be obtained as noted above.\n\n   5. There is no warranty or other guarantee of fitness for Qhull, it is provided solely \"as is\". Bug reports or fixes may be sent to qhull_bug@qhull.org; the authors may or may not act on them as they desire."],"licenseIds":["Qhull"],"keywords":["qhull copyright c","c 1993 2003","1993 2003 the","2003 the national","the national science","national science and","science and technology","and technology research","technology research center","research center for","center for computation","for computation and","computation and visualization","and visualization of","visualization of geometric","of geometric structures","geometric structures the","structures the geometry","geometry center university","center university of","university of minnesota","of minnesota email","minnesota email qhull","email qhull qhull","qhull qhull org","qhull org this","software includes qhull","includes qhull from","qhull from the","from the geometry","geometry center qhull","center qhull is","qhull is copyrighted","is copyrighted as","copyrighted as noted","noted above qhull","above qhull is","qhull is free","be obtained via","obtained via http","via http from","http from www","from www qhull","www qhull org","qhull org it","org it may","freely copied modified","copied modified and","and redistributed under","redistributed under the","conditions 1 all","copyright notices must","notices must remain","must remain intact","intact in all","in all files","all files 2","files 2 a","2 a copy","of this text","this text file","text file must","be distributed along","distributed along with","with any copies","copies of qhull","of qhull that","qhull that you","that you redistribute","you redistribute this","redistribute this includes","this includes copies","includes copies that","copies that you","have modified or","modified or copies","copies of programs","of programs or","include qhull 3","qhull 3 if","you modify qhull","modify qhull you","a notice giving","giving the name","the person performing","person performing the","performing the modification","the modification the","modification the date","of modification and","and the reason","the reason for","reason for such","for such modification","such modification 4","modification 4 when","4 when distributing","when distributing modified","distributing modified versions","versions of qhull","of qhull or","qhull or other","include qhull you","must provide notice","provide notice that","be obtained as","obtained as noted","noted above 5","above 5 there","5 there is","warranty or other","or other guarantee","other guarantee of","fitness for qhull","for qhull it","qhull it is","is provided solely","provided solely as","solely as is","as is bug","is bug reports","bug reports or","reports or fixes","or fixes may","fixes may be","may be sent","be sent to","sent to qhull","to qhull bug","qhull bug qhull","bug qhull org","qhull org the","org the authors","the authors may","authors may or","may not act","not act on","act on them","on them as","them as they","as they desire","qhull copyright c 1993","copyright c 1993 2003","c 1993 2003 the","1993 2003 the national","2003 the national science","the national science and","national science and technology","science and technology research","and technology research center","technology research center for","research center for computation","center for computation and","for computation and visualization","computation and visualization of","and visualization of geometric","visualization of geometric structures","of geometric structures the","geometric structures the geometry","structures the geometry center","the geometry center university","geometry center university of","center university of minnesota","university of minnesota email","of minnesota email qhull","minnesota email qhull qhull","email qhull qhull org","qhull qhull org this","qhull org this software","org this software includes","this software includes qhull","software includes qhull from","includes qhull from the","qhull from the geometry","from the geometry center","the geometry center qhull","geometry center qhull is","center qhull is copyrighted","qhull is copyrighted as","is copyrighted as noted","copyrighted as noted above","as noted above qhull","noted above qhull is","above qhull is free","qhull is free software","free software and may","software and may be","and may be obtained","may be obtained via","be obtained via http","obtained via http from","via http from www","http from www qhull","from www qhull org","www qhull org it","qhull org it may","org it may be","be freely copied modified","freely copied modified and","copied modified and redistributed"]},{"licenseTexts":["Red Hat eCos Public License v1.1\n\n   1. DEFINITIONS\n\n      1.1. \"Contributor\" means each entity that creates or contributes to the creation of Modifications.\n\n      1.2. \"Contributor Version\" means the combination of the Original Code, prior Modifications used by a Contributor, and the Modifications made by that particular Contributor.\n\n      1.3. \"Covered Code\" means the Original Code or Modifications or the combination of the Original Code and Modifications, in each case including portions thereof.\n\n      1.4. \"Electronic Distribution Mechanism\" means a mechanism generally accepted in the software development community for the electronic transfer of data.\n\n      1.5. \"Executable\" means Covered Code in any form other than Source Code.\n\n      1.6. \"Initial Developer\" means the individual or entity identified as the Initial Developer in the Source Code notice required by Exhibit A.\n\n      1.7. \"Larger Work\" means a work which combines Covered Code or portions thereof with code not governed by the terms of this License.\n\n      1.8. \"License\" means this document.\n\n      1.9. \"Modifications\" means any addition to or deletion from the substance or structure of either the Original Code or any previous Modifications. When Covered Code is released as a series of files, a Modification is:\n\n         A. Any addition to or deletion from the contents of a file containing Original Code or previous Modifications.\n\n         B. Any new file that contains any part of the Original Code or previous Modifications.\n\n      1.10. \"Original Code\" means Source Code of computer software code which is described in the Source Code notice required by Exhibit A as Original Code, and which, at the time of its release under this License is not already Covered Code governed by this License.\n\n      1.11. \"Source Code\" means the preferred form of the Covered Code for making modifications to it, including all modules it contains, plus any associated interface definition files, scripts used to control compilation and installation of an Executable, or a list of source code differential comparisons against either the Original Code or another well known, available Covered Code of the Contributor's choice. The Source Code can be in a compressed or archival form, provided the appropriate decompression or de-archiving software is widely available for no charge.\n\n      1.12. \"You\" means an individual or a legal entity exercising rights under, and complying with all of the terms of, this License or a future version of this License issued under Section 6.1. For legal entities, \"You\" includes any entity which controls, is controlled by, or is under common control with You. For purposes of this definition, \"control\" means (a) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (b) ownership of fifty percent (50%) or more of the outstanding shares or beneficial ownership of such entity.\n\n      1.13. \"Red Hat Branded Code\" is code that Red Hat distributes and/or permits others to distribute under different terms than the Red Hat eCos Public License. Red Hat's Branded Code may contain part or all of the Covered Code.\n\n   2. SOURCE CODE LICENSE\n\n      2.1. The Initial Developer Grant. The Initial Developer hereby grants You a world-wide, royalty-free, non-exclusive license, subject to third party intellectual property claims:\n\n         (a) to use, reproduce, modify, display, perform, sublicense and distribute the Original Code (or portions thereof) with or without Modifications, or as part of a Larger Work; and\n\n         (b) under patents now or hereafter owned or controlled by Initial Developer, to make, have made, use and sell (\"Utilize\") the Original Code (or portions thereof), but solely to the extent that any such patent is reasonably necessary to enable You to Utilize the Original Code (or portions thereof) and not to any greater extent that may be necessary to Utilize further Modifications or combinations.\n\n      2.2. Contributor Grant. Each Contributor hereby grants You a world-wide, royalty-free, non-exclusive license, subject to third party intellectual property claims:\n\n         (a) to use, reproduce, modify, display, perform, sublicense and distribute the Modifications created by such Contributor (or portions thereof) either on an unmodified basis, with other Modifications, as Covered Code or as part of a Larger Work; and\n\n         (b) under patents now or hereafter owned or controlled by Contributor, to Utilize the Contributor Version (or portions thereof), but solely to the extent that any such patent is reasonably necessary to enable You to Utilize the Contributor Version (or portions thereof), and not to any greater extent that may be necessary to Utilize further Modifications or combinations.\n\n   3. DISTRIBUTION OBLIGATIONS\n\n      3.1. Application of License. The Modifications which You create or to which You contribute are governed by the terms of this License, including without limitation Section 2.2. The Source Code version of Covered Code may be distributed only under the terms of this License or a future version of this License released under Section 6.1, and You must include a copy of this License with every copy of the Source Code You distribute. You may not offer or impose any terms on any Source Code version that alters or restricts the applicable version of this License or the recipients' rights hereunder. However, You may include an additional document offering the additional rights described in Section 3.5.\n\n      3.2. Availability of Source Code. Any Modification which You create or to which You contribute must be made available in Source Code form under the terms of this License via an accepted Electronic Distribution Mechanism to anyone to whom you made an Executable version available and to the Initial Developer; and if made available via Electronic Distribution Mechanism, must remain available for at least twelve (12) months after the date it initially became available, or at least six (6) months after a subsequent version of that particular Modification has been made available to such recipients. You are responsible for ensuring that the Source Code version remains available even if the Electronic Distribution Mechanism is maintained by a third party. You are responsible for notifying the Initial Developer of the Modification and the location of the Source if a contact means is provided. Red Hat will be acting as maintainer of the Source and may provide an Electronic Distribution mechanism for the Modification to be made available. You can contact Red Hat to make the Modification available and to notify the Initial Developer. (http://sourceware.cygnus.com/ecos/)\n\n      3.3. Description of Modifications. You must cause all Covered Code to which you contribute to contain a file documenting the changes You made to create that Covered Code and the date of any change. You must include a prominent statement that the Modification is derived, directly or indirectly, from Original Code provided by the Initial Developer and including the name of the Initial Developer in (a) the Source Code, and (b) in any notice in an Executable version or related documentation in which You describe the origin or ownership of the Covered Code.\n\n      3.4. Intellectual Property Matters\n\n         (a) Third Party Claims. If You have knowledge that a party claims an intellectual property right in particular functionality or code (or its utilization under this License), you must include a text file with the source code distribution titled \"LEGAL\" which describes the claim and the party making the claim in sufficient detail that a recipient will know whom to contact. If you obtain such knowledge after You make Your Modification available as described in Section 3.2, You shall promptly modify the LEGAL file in all copies You make available thereafter and shall take other steps (such as notifying appropriate mailing lists or newsgroups) reasonably calculated to inform those who received the Covered Code that new knowledge has been obtained.\n\n         (b) Contributor APIs. If Your Modification is an application programming interface and You own or control patents which are reasonably necessary to implement that API, you must also include this information in the LEGAL file.\n\n      3.5. Required Notices. You must duplicate the notice in Exhibit A in each file of the Source Code, and this License in any documentation for the Source Code, where You describe recipients' rights relating to Covered Code. If You created one or more Modification(s), You may add your name as a Contributor to the Source Code. If it is not possible to put such notice in a particular Source Code file due to its structure, then you must include such notice in a location (such as a relevant directory file) where a user would be likely to look for such a notice. You may choose to offer, and to charge a fee for, warranty, support, indemnity or liability obligations to one or more recipients of Covered Code.\n\n      However, You may do so only on Your own behalf, and not on behalf of the Initial Developer or any Contributor. You must make it absolutely clear that any such warranty, support, indemnity or liability obligation is offered by You alone, and You hereby agree to indemnify the Initial Developer and every Contributor for any liability incurred by the Initial Developer or such Contributor as a result of warranty, support, indemnity or liability terms You offer.\n\n      3.6. Distribution of Executable Versions. You may distribute Covered Code in Executable form only if the requirements of Section 3.1-3.5 have been met for that Covered Code, and if You include a notice stating that the Source Code version of the Covered Code is available under the terms of this License, including a description of how and where You have fulfilled the obligations of Section 3.2. The notice must be conspicuously included in any notice in an Executable version, related documentation or collateral in which You describe recipients' rights relating to the Covered Code. You may distribute the Executable version of Covered Code under a license of Your choice, which may contain terms different from this License, provided that You are in compliance with the terms of this License and that the license for the Executable version does not attempt to limit or alter the recipient's rights in the Source Code version from the rights set forth in this License. If You distribute the Executable version under a different license You must make it absolutely clear that any terms which differ from this License are offered by You alone, not by the Initial Developer or any Contributor. You hereby agree to indemnify the Initial Developer and every Contributor for any liability incurred by the Initial Developer or such Contributor as a result of any such terms You offer.\n\n      If you distribute executable versions containing Covered Code, you must reproduce the notice in Exhibit B in the documentation and/or other materials provided with the product.\n\n      3.7. Larger Works. You may create a Larger Work by combining Covered Code with other code not governed by the terms of this License and distribute the Larger Work as a single product. In such a case, You must make sure the requirements of this License are fulfilled for the Covered Code.\n\n   4. INABILITY TO COMPLY DUE TO STATUTE OR REGULATION\n\n   If it is impossible for You to comply with any of the terms of this License with respect to some or all of the Covered Code due to statute or regulation then You must: (a) comply with the terms of this License to the maximum extent possible; (b) cite the statute or regulation that prohibits you from adhering to the license; and (c) describe the limitations and the code they affect. Such description must be included in the LEGAL file described in Section 3.4 and must be included with all distributions of the Source Code. Except to the extent prohibited by statute or regulation, such description must be sufficiently detailed for a recipient of ordinary skill to be able to understand it. You must submit this LEGAL file to Red Hat for review, and You will not be able use the covered code in any means until permission is granted from Red Hat to allow for the inability to comply due to statute or regulation.\n\n   5. APPLICATION OF THIS LICENSE\n\n   This License applies to code to which the Initial Developer has attached the notice in Exhibit A, and to related Covered Code.\n\n   Red Hat may include Covered Code in products without such additional products becoming subject to the terms of this License, and may license such additional products on different terms from those contained in this License.\n\n   Red Hat may license the Source Code of Red Hat Branded Code without Red Hat Branded Code becoming subject to the terms of this License, and may license Red Hat Branded Code on different terms from those contained in this License. Contact Red Hat for details of alternate licensing terms available.\n\n   6. VERSIONS OF THE LICENSE\n\n      6.1. New Versions. Red Hat may publish revised and/or new versions of the License from time to time. Each version will be given a distinguishing version number.\n\n      6.2. Effect of New Versions. Once Covered Code has been published under a particular version of the License, You may always continue to use it under the terms of that version. You may also choose to use such Covered Code under the terms of any subsequent version of the License published by Red Hat. No one other than Red Hat has the right to modify the terms applicable to Covered Code beyond what is granted under this and subsequent Licenses.\n\n      6.3. Derivative Works. If you create or use a modified version of this License (which you may only do in order to apply it to code which is not already Covered Code governed by this License), you must (a) rename Your license so that the phrases \"ECOS\", \"eCos\", \"Red Hat\", \"RHEPL\" or any confusingly similar phrase do not appear anywhere in your license and (b) otherwise make it clear that your version of the license contains terms which differ from the Red Hat eCos Public License. (Filling in the name of the Initial Developer, Original Code or Contributor in the notice described in Exhibit A shall not of themselves be deemed to be modifications of this License.)\n\n   7. DISCLAIMER OF WARRANTY\n\n   COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN \"AS IS\" BASIS, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER.\n\n   8. TERMINATION\n\n   This License and the rights granted hereunder will terminate automatically if You fail to comply with terms herein and fail to cure such breach within 30 days of becoming aware of the breach. All sublicenses to the Covered Code which are properly granted shall survive any termination of this License. Provisions which, by their nature, must remain in effect beyond the termination of this License shall survive.\n\n   9. LIMITATION OF LIABILITY\n\n   UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER TORT (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL THE INITIAL DEVELOPER, ANY OTHER CONTRIBUTOR, OR ANY DISTRIBUTOR OF COVERED CODE, OR ANY SUPPLIER OF ANY OF SUCH PARTIES, BE LIABLE TO YOU OR ANY OTHER PERSON FOR ANY INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, COMPUTER FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER COMMERCIAL DAMAGES OR LOSSES, EVEN IF SUCH PARTY SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF LIABILITY SHALL NOT APPLY TO LIABILITY FOR DEATH OR PERSONAL INJURY RESULTING FROM SUCH PARTY'S NEGLIGENCE TO THE EXTENT APPLICABLE LAW PROHIBITS SUCH LIMITATION. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OR LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THAT EXCLUSION AND LIMITATION MAY NOT APPLY TO YOU.\n\n   10. U.S. GOVERNMENT END USERS\n\n   The Covered Code is a \"commercial item,\" as that term is defined in 48 C.F.R. 2.101 (Oct. 1995), consisting of \"commercial computer software\" and \"commercial computer software documentation,\" as such terms are used in 48 C.F.R. 12.212 (Sept. 1995). Consistent with 48 C.F.R. 12.212 and 48 C.F.R. 227.7202-1 through 227.7202-4 (June 1995), all U.S. Government End Users acquire Covered Code with only those rights set forth herein.\n\n   11. MISCELLANEOUS\n\n   This License represents the complete agreement concerning subject matter hereof. If any provision of this License is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable. This License shall be governed by California law provisions (except to the extent applicable law, if any, provides otherwise), excluding its conflict-of-law provisions. With respect to disputes in which at least one party is a citizen of, or an entity chartered or registered to do business in, the United States of America: (a) unless otherwise agreed in writing, all disputes relating to this License (excepting any dispute relating to intellectual property rights) shall be subject to final and binding arbitration, with the losing party paying all costs of arbitration; (b) any arbitration relating to this Agreement shall be held in Santa Clara County, California, under the auspices of JAMS/EndDispute; and (c) any litigation relating to this Agreement shall be subject to the jurisdiction of the Federal Courts of the Northern District of California, with venue lying in Santa Clara County, California, with the losing party responsible for costs, including without limitation, court costs and reasonable attorneys fees and expenses. The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded. Any law or regulation which provides that the language of a contract shall be construed against the drafter shall not apply to this License.\n\n   12. RESPONSIBILITY FOR CLAIMS\n\n   Except in cases where another Contributor has failed to comply with Section 3.4, You are responsible for damages arising, directly or indirectly, out of Your utilization of rights under this License, based on the number of copies of Covered Code you made available, the revenues you received from utilizing such rights, and other relevant factors. You agree to work with affected parties to distribute responsibility on an equitable basis.\n\n   13. ADDITIONAL TERMS APPLICABLE TO THE RED HAT ECOS PUBLIC LICENSE\n\n   Nothing in this License shall be interpreted to prohibit Red Hat from licensing under different terms than this License any code which Red Hat otherwise would have a right to license.\n\n   Red Hat and logo - This License does not grant any rights to use the trademark Red Hat, the Red Hat logo, eCos logo, even if such marks are included in the Original Code. You may contact Red Hat for permission to display the Red Hat and eCos marks in either the documentation or the Executable version beyond that required in Exhibit B.\n\n   Inability to Comply Due to Contractual Obligation - To the extent that Red Hat is limited contractually from making third party code available under this License, Red Hat may choose to integrate such third party code into Covered Code without being required to distribute such third party code in Source Code form, even if such third party code would otherwise be considered \"Modifications\" under this License. EXHIBIT A\n\n\"The contents of this file are subject to the Red Hat eCos Public License Version 1.1 (the \"License\"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.redhat.com/\n\nSoftware distributed under the License is distributed on an \"AS IS\" basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the specific language governing rights and limitations under the License.\n\nThe Original Code is eCos - Embedded Configurable Operating System, released September 30, 1998. The Initial Developer of the Original Code is Red Hat. Portions created by Red Hat are Copyright (C) 1998, 1999, 2000 Red Hat, Inc. All Rights Reserved.\"\n\nEXHIBIT B\n\nPart of the software embedded in this product is eCos - Embedded Configurable Operating System, a trademark of Red Hat. Portions created by Red Hat are Copyright (C) 1998, 1999, 2000 Red Hat, Inc. (http://www.redhat.com/). All Rights Reserved.\n\nTHE SOFTWARE IN THIS PRODUCT WAS IN PART PROVIDED BY RED HAT AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."],"licenseIds":["RHeCos-1.1"],"keywords":["1 13 red","13 red hat","branded code is","code is code","is code that","code that red","red hat distributes","hat distributes and","distribute under different","terms than the","than the red","public license red","red hat s","hat s branded","branded code may","may contain part","contain part or","covered code 2","code 2 source","license via an","developer and if","party you are","responsible for notifying","for notifying the","notifying the initial","the source if","source if a","if a contact","a contact means","contact means is","means is provided","is provided red","provided red hat","red hat will","hat will be","source and may","available you can","you can contact","can contact red","hat to make","make the modification","the modification available","modification available and","and to notify","to notify the","initial developer http","developer http sourceware","http sourceware cygnus","sourceware cygnus com","cygnus com ecos","com ecos 3","ecos 3 3","extent possible b","possible b cite","b cite the","and c describe","understand it you","you must submit","must submit this","submit this legal","this legal file","legal file to","file to red","to red hat","hat for review","for review and","review and you","be able use","able use the","in any means","any means until","means until permission","until permission is","is granted from","granted from red","from red hat","hat to allow","to allow for","for the inability","or regulation 5","regulation 5 application","covered code red","code red hat","hat may include","in products without","products without such","hat may license","code of red","branded code without","code without red","without red hat","may license red","this license contact","license contact red","hat for details","for details of","details of alternate","of alternate licensing","alternate licensing terms","licensing terms available","terms available 6","available 6 versions","new versions red","versions red hat","hat may publish","published by red","red hat no","hat no one","other than red","than red hat","red hat has","hat has the","covered code beyond","code beyond what","beyond what is","what is granted","under this and","this and subsequent","and subsequent licenses","subsequent licenses 6","licenses 6 3","the phrases ecos","phrases ecos ecos","ecos ecos red","ecos red hat","red hat rhepl","hat rhepl or","rhepl or any","from the red","equitable basis 13","basis 13 additional","13 additional terms","public license nothing","license nothing in","to prohibit red","prohibit red hat","red hat from","hat from licensing","terms than this","code which red","which red hat","red hat otherwise","hat otherwise would","to license red","hat and logo","the trademark red","trademark red hat","red hat the","hat the red","red hat logo","hat logo ecos","logo ecos logo","ecos logo even","you may contact","may contact red","hat for permission","permission to display","display the red","hat and ecos","and ecos marks","ecos marks in","marks in either","in either the","either the documentation","or the executable","executable version beyond","version beyond that","beyond that required","that required in","required in exhibit","exhibit b inability","b inability to","contractual obligation to","obligation to the","extent that red","red hat is","hat is limited","from making third","making third party","hat may choose","choose to integrate","to integrate such","integrate such third","party code into","distribute such third","party code in","if such third","party code would","redhat com software","com software distributed","code is ecos","operating system released","system released september","released september 30","september 30 1998","30 1998 the","code is red","is red hat","hat inc all","product is ecos"]},{"licenseTexts":["Reciprocal Public License, version 1.1 Copyright (C) 2001-2002 Technical Pursuit Inc., All Rights Reserved. PREAMBLE\n\nThis Preamble is intended to describe, in plain English, the nature, intent, and scope of this License. However, this Preamble is not a part of this License. The legal effect of this License is dependent only upon the terms of the License and not this Preamble.\n\nThis License is based on the concept of reciprocity. In exchange for being granted certain rights under the terms of this License to Licensor's Software, whose Source Code You have access to, You are required to reciprocate by providing equal access and rights to all third parties to the Source Code of any Modifications, Derivative Works, and Required Components for execution of same (collectively defined as Extensions) that You Deploy by Deploying Your Extensions under the terms of this License. In this fashion the available Source Code related to the original Licensed Software is enlarged for the benefit of everyone.\n\nUnder the terms of this License You may:\n\n   a. Distribute the Licensed Software exactly as You received it under the terms of this License either alone or as a component of an aggregate software distribution containing programs from several different sources without payment of a royalty or other fee.\n\n   b. Use the Licensed Software for any purpose consistent with the rights granted by this License, but the Licensor is not providing You any warranty whatsoever, nor is the Licensor accepting any liability in the event that the Licensed Software doesn't work properly or causes You any injury or damages.\n\n   c. Create Extensions to the Licensed Software consistent with the rights granted by this License, provided that You make the Source Code to any Extensions You Deploy available to all third parties under the terms of this License, document Your Modifications clearly, and title all Extensions distinctly from the Licensed Software.\n\n   d. Charge a fee for warranty or support, or for accepting indemnity or liability obligations for Your customers.\n\nUnder the terms of this License You may not:\n\n   a. Charge for the Source Code to the Licensed Software, or Your Extensions, other than a nominal fee not to exceed Your cost for reproduction and distribution where such reproduction and distribution involve physical media.\n\n   b. Modify or delete any pre-existing copyright notices, change notices, or License text in the Licensed Software.\n\n   c. Assert any patent claims against the Licensor or Contributors, or which would in any way restrict the ability of any third party to use the Licensed Software or portions thereof in any form under the terms of this License, or Your rights to the Licensed Software under this License automatically terminate.\n\n   d. Represent either expressly or by implication, appearance, or otherwise that You represent Licensor or\n\n   Contributors in any capacity or that You have any form of legal association by virtue of this License.\n\nUnder the terms of this License You must:\n\n   a. Document any Modifications You make to the Licensed Software including the nature of the change, the authors of the change, and the date of the change. This documentation must appear both in the Source Code and in a text file titled \"CHANGES\" distributed with the Licensed Software and Your Extensions.\n\n   b. Make the Source Code for any Extensions You Deploy available in a timely fashion via an Electronic Distribution Mechanism such as FTP or HTTP download.\n\n   c. Notify the Licensor of the availability of Source Code to Your Extensions in a timely fashion and include in such notice a brief description of the Extensions, the distinctive title used, and instructions on how to acquire the Source Code and future updates.\n\n   d. Grant Licensor and all third parties a world-wide, non-exclusive, royalty-free license under any intellectual property rights owned or controlled by You to use, reproduce, display, perform, modify, sublicense, and distribute Your Extensions, in any form, under the terms of this License.\n\nLICENSE TERMS\n\n   1.0 General; Applicability \u0026 Definitions. This Reciprocal Public License Version 1.1 (\"License\") applies to any programs or other works as well as any and all updates or maintenance releases of said programs or works (\"Software\") not already covered by this License which the Software copyright holder (\"Licensor\") makes publicly available containing a Notice (hereinafter defined) from the Licensor specifying or allowing use or distribution under the terms of this License. As used in this License and Preamble:\n\n      1.1 \"Contributor\" means any person or entity who created or contributed to the creation of an Extension.\n\n      1.2 \"Deploy\" means to use, Serve, sublicense or distribute Licensed Software other than for Your internal Research and/or Personal Use, and includes without limitation, any and all internal use or distribution of Licensed Software within Your business or organization other than for Research and/or Personal Use, as well as direct or indirect sublicensing or distribution of Licensed Software by You to any third party in any form or manner.\n\n      1.3 \"Derivative Works\" as used in this License is defined under U.S. copyright law.\n\n      1.4 \"Electronic Distribution Mechanism\" means a mechanism generally accepted in the software development community for the electronic transfer of data such as download from an FTP or web site, where such mechanism is publicly accessible.\n\n      1.5 \"Extensions\" means any Modifications, Derivative Works, or Required Components as those terms are defined in this License.\n\n      1.6 \"License\" means this Reciprocal Public License.\n\n      1.7 \"Licensed Software\" means any Software licensed pursuant to this License. Licensed Software also includes all previous Extensions from any Contributor that You receive.\n\n      1.8 \"Licensor\" means the copyright holder of any Software previously uncovered by this License who releases the Software under the terms of this License.\n\n      1.9 \"Modifications\" means any additions to or deletions from the substance or structure of (i) a file or other storage containing Licensed Software, or (ii) any new file or storage that contains any part of Licensed Software, or (iii) any file or storage which replaces or otherwise alters the original functionality of Licensed Software at runtime.\n\n      1.10 \"Notice\" means the notice contained in EXHIBIT A.\n\n      1.11 \"Personal Use\" means use of Licensed Software by an individual solely for his or her personal, private and non-commercial purposes. An individual's use of Licensed Software in his or her capacity as an officer, employee, member, independent contractor or agent of a corporation, business or organization (commercial or non-commercial) does not qualify as Personal Use.\n\n      1.12 \"Required Components\" means any text, programs, scripts, schema, interface definitions, control files, or other works created by You which are required by a third party of average skill to successfully install and run Licensed Software containing Your Modifications, or to install and run Your Derivative Works.\n\n      1.13 \"Research\" means investigation or experimentation for the purpose of understanding the nature and limits of the Licensed Software and its potential uses.\n\n      1.14 \"Serve\" means to deliver Licensed Software and/or Your Extensions by means of a computer network to one or more computers for purposes of execution of Licensed Software and/or Your Extensions.\n\n      1.15 \"Software\" means any computer programs or other works as well as any updates or maintenance releases of those programs or works which are distributed publicly by Licensor.\n\n      1.16 \"Source Code\" means the preferred form for making modifications to the Licensed Software and/or Your Extensions, including all modules contained therein, plus any associated text, interface definition files, scripts used to control compilation and installation of an executable program or other components required by a third party of average skill to build a running version of the Licensed Software or Your Extensions.\n\n      1.17 \"You\" or \"Your\" means an individual or a legal entity exercising rights under this License. For legal entities, \"You\" or \"Your\" includes any entity which controls, is controlled by, or is under common control with, You, where \"control\" means (a) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (b) ownership of fifty percent (50%) or more of the outstanding shares or beneficial ownership of such entity.\n\n   2.0 Acceptance Of License. You are not required to accept this License since you have not signed it, however nothing else grants you permission to use, copy, distribute, modify, or create derivatives of either the Software or any Extensions created by a Contributor. These actions are prohibited by law if you do not accept this License. Therefore, by performing any of these actions You indicate Your acceptance of this License and Your agreement to be bound by all its terms and conditions. IF YOU DO NOT AGREE WITH ALL THE TERMS AND CONDITIONS OF THIS LICENSE DO NOT USE, MODIFY, CREATE DERIVATIVES, OR DISTRIBUTE THE SOFTWARE. IF IT IS IMPOSSIBLE FOR YOU TO COMPLY WITH ALL THE TERMS AND CONDITIONS OF THIS LICENSE THEN YOU CAN NOT USE, MODIFY, CREATE DERIVATIVES, OR DISTRIBUTE THE SOFTWARE.\n\n   3.0 Grant of License From Licensor. Subject to the terms and conditions of this License, Licensor hereby grants You a world-wide, royalty-free, non-exclusive license, subject to Licensor's intellectual property rights, and any third party intellectual property claims derived from the Licensed Software under this License, to do the following:\n\n      3.1 Use, reproduce, modify, display, perform, sublicense and distribute Licensed Software and Your Extensions in both Source Code form or as an executable program.\n\n      3.2 Create Derivative Works (as that term is defined under U.S. copyright law) of Licensed Software by adding to or deleting from the substance or structure of said Licensed Software.\n\n      3.3 Under claims of patents now or hereafter owned or controlled by Licensor, to make, use, have made, and/or otherwise dispose of Licensed Software or portions thereof, but solely to the extent that any such claim is necessary to enable You to make, use, have made, and/or otherwise dispose of Licensed Software or portions thereof.\n\n      3.4 Licensor reserves the right to release new versions of the Software with different features, specifications, capabilities, functions, licensing terms, general availability or other characteristics. Title, ownership rights, and intellectual property rights in and to the Licensed Software shall remain in Licensor and/or its Contributors.\n\n   4.0 Grant of License From Contributor. By application of the provisions in Section 6 below, each Contributor hereby grants You a world-wide, royalty-free, non-exclusive license, subject to said Contributor's intellectual property rights, and any third party intellectual property claims derived from the Licensed Software under this License, to do the following:\n\n      4.1 Use, reproduce, modify, display, perform, sublicense and distribute any Extensions Deployed by such Contributor or portions thereof, in both Source Code form or as an executable program, either on an unmodified basis or as part of Derivative Works.\n\n      4.2 Under claims of patents now or hereafter owned or controlled by Contributor, to make, use, have made, and/or otherwise dispose of Extensions or portions thereof, but solely to the extent that any such claim is necessary to enable You to make, use, have made, and/or otherwise dispose of Contributor's Extensions or portions thereof.\n\n   5.0 Exclusions From License Grant. Nothing in this License shall be deemed to grant any rights to trademarks, copyrights, patents, trade secrets or any other intellectual property of Licensor or any Contributor except as expressly stated herein. Except as expressly stated in Sections 3 and 4, no other patent rights, express or implied, are granted herein. Your Extensions may require additional patent licenses from Licensor or Contributors which each may grant in its sole discretion. No right is granted to the trademarks of Licensor or any Contributor even if such marks are included in the Licensed Software. Nothing in this License shall be interpreted to prohibit Licensor from licensing under different terms from this License any code that Licensor otherwise would have a right to license.\n\n      5.1 You expressly acknowledge and agree that although Licensor and each Contributor grants the licenses to their respective portions of the Licensed Software set forth herein, no assurances are provided by Licensor or any Contributor that the Licensed Software does not infringe the patent or other intellectual property rights of any other entity. Licensor and each Contributor disclaim any liability to You for claims brought by any other entity based on infringement of intellectual property rights or otherwise. As a condition to exercising the rights and licenses granted hereunder, You hereby assume sole responsibility to secure any other intellectual property rights needed, if any. For example, if a third party patent license is required to allow You to distribute the Licensed Software, it is Your responsibility to acquire that license before distributing the Licensed Software.\n\n   6.0 Your Obligations And Grants. In consideration of, and as an express condition to, the licenses granted to You under this License You hereby agree that any Modifications, Derivative Works, or Required Components (collectively Extensions) that You create or to which You contribute are governed by the terms of this License including, without limitation, Section 4. Any Extensions that You create or to which You contribute must be Deployed under the terms of this License or a future version of this License released under Section 7. You hereby grant to Licensor and all third parties a world-wide, non-exclusive, royalty-free license under those intellectual property rights You own or control to use, reproduce, display, perform, modify, create derivatives, sublicense, and distribute Your Extensions, in any form. Any Extensions You make and Deploy must have a distinct title so as to readily tell any subsequent user or Contributor that the Extensions are by You. You must include a copy of this License with every copy of the Extensions You distribute. You agree not to offer or impose any terms on any Source Code or executable version of the Licensed Software, or its Extensions that alter or restrict the applicable version of this License or the recipients' rights hereunder.\n\n      6.1 Availability of Source Code. You must make available, under the terms of this License, the Source Code of the Licensed Software and any Extensions that You Deploy, either on the same media as You distribute any executable or other form of the Licensed Software, or via an Electronic Distribution Mechanism. The Source Code for any version of Licensed Software, or its Extensions that You Deploy must be made available at the time of Deployment and must remain available for as long as You Deploy the Extensions or at least twelve (12) months after the date You Deploy, whichever is longer. You are responsible for ensuring that the Source Code version remains available even if the Electronic Distribution Mechanism is maintained by a third party. You may not charge a fee for the Source Code distributed under this Section in excess of Your actual cost of duplication and distribution where such duplication and distribution involve physical media.\n\n      6.2 Description of Modifications. You must cause any Modifications that You create or to which You contribute, to update the file titled \"CHANGES\" distributed with Licensed Software documenting the additions, changes or deletions You made, the authors of such Modifications, and the dates of any such additions, changes or deletions. You must also cause a cross-reference to appear in the Source Code at the location of each change. You must include a prominent statement that the Modifications are derived, directly or indirectly, from the Licensed Software and include the names of the Licensor and any Contributor to the Licensed Software in (i) the Source Code and (ii) in any notice displayed by the Licensed Software You distribute or in related documentation in which You describe the origin or ownership of the Licensed Software. You may not modify or delete any pre-existing copyright notices, change notices or License text in the Licensed Software.\n\n      6.3 Intellectual Property Matters.\n\n         a. Third Party Claims. If You have knowledge that a license to a third party's intellectual property right is required to exercise the rights granted by this License, You must include a text file with the Source Code distribution titled \"LEGAL\" that describes the claim and the party making the claim in sufficient detail that a recipient will know whom to contact. If You obtain such knowledge after You make any Extensions available as described in Section 6.1, You shall promptly modify the LEGAL file in all copies You make available thereafter and shall take other steps (such as notifying appropriate mailing lists or newsgroups) reasonably calculated to inform those who received the Licensed Software from You that new knowledge has been obtained.\n\n         b. Contributor APIs. If Your Extensions include an application programming interface (\"API\") and You have knowledge of patent licenses that are reasonably necessary to implement that API, You must also include this information in the LEGAL file.\n\n         c. Representations. You represent that, except as disclosed pursuant to 6.3(a) above, You believe that any Extensions You distribute are Your original creations and that You have sufficient rights to grant the rights conveyed by this License.\n\n      6.4 Required Notices.\n\n         a. License Text. You must duplicate this License in any documentation You provide along with the Source Code of any Extensions You create or to which You contribute, wherever You describe recipients' rights relating to Licensed Software. You must duplicate the notice contained in EXHIBIT A (the \"Notice\") in each file of the Source Code of any copy You distribute of the Licensed Software and Your Extensions. If You create an Extension, You may add Your name as a Contributor to the text file titled \"CONTRIB\" distributed with the Licensed Software along with a description of the contribution. If it is not possible to put the Notice in a particular Source Code file due to its structure, then You must include such Notice in a location (such as a relevant directory file) where a user would be likely to look for such a notice.\n\n         b. Source Code Availability. You must notify Licensor within one (1) month of the date You initially Deploy of the availability of Source Code to Your Extensions and include in such notification the name under which you Deployed Your Extensions, a description of the Extensions, and instructions on how to acquire the Source Code, including instructions on how to acquire updates over time. Should such instructions change you must provide Licensor with revised instructions within one (1) month of the date of change. Should you be unable to notify Licensor directly, you must provide notification by posting to appropriate news groups, mailing lists, or web sites where a search engine would reasonably be expected to index them.\n\n      6.5 Additional Terms. You may choose to offer, and charge a fee for, warranty, support, indemnity or liability obligations to one or more recipients of Licensed Software. However, You may do so only on Your own behalf, and not on behalf of the Licensor or any Contributor. You must make it clear that any such warranty, support, indemnity or liability obligation is offered by You alone, and You hereby agree to indemnify the Licensor and every Contributor for any liability plus attorney fees, costs, and related expenses due to any such action or claim incurred by the Licensor or such Contributor as a result of warranty, support, indemnity or liability terms You offer.\n\n      6.6 Conflicts With Other Licenses. Where any portion of Your Extensions, by virtue of being Derivative Works of another product or similar circumstance, fall under the terms of another license, the terms of that license should be honored however You must also make Your Extensions available under this License. If the terms of this License continue to conflict with the terms of the other license you may write the Licensor for permission to resolve the conflict in a fashion that remains consistent with the intent of this License. Such permission will be granted at the sole discretion of the Licensor.\n\n   7.0 Versions of This License. Licensor may publish from time to time revised and/or new versions of the License. Once Licensed Software has been published under a particular version of the License, You may always continue to use it under the terms of that version. You may also choose to use such Licensed Software under the terms of any subsequent version of the License published by Licensor. No one other than Licensor has the right to modify the terms applicable to Licensed Software created under this License.\n\n      7.1 If You create or use a modified version of this License, which You may do only in order to apply it to software that is not already Licensed Software under this License, You must rename Your license so that it is not confusingly similar to this License, and must make it clear that Your license contains terms that differ from this License. In so naming Your license, You may not use any trademark of Licensor or of any Contributor. Should Your modifications to this License be limited to alteration of EXHIBIT A purely for purposes of adjusting the Notice You require of licensees, You may continue to refer to Your License as the Reciprocal Public License or simply the RPL.\n\n   8.0 Disclaimer of Warranty. LICENSED SOFTWARE IS PROVIDED UNDER THIS LICENSE ON AN \"AS IS\" BASIS, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES THAT THE LICENSED SOFTWARE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE OR NON-INFRINGING. FURTHER THERE IS NO WARRANTY MADE AND ALL IMPLIED WARRANTIES ARE DISCLAIMED THAT THE LICENSED SOFTWARE MEETS OR COMPLIES WITH ANY DESCRIPTION OF PERFORMANCE OR OPERATION, SAID COMPATIBILITY AND SUITABILITY BEING YOUR RESPONSIBILITY. LICENSOR DISCLAIMS ANY WARRANTY, IMPLIED OR EXPRESSED, THAT ANY CONTRIBUTOR'S EXTENSIONS MEET ANY STANDARD OF COMPATIBILITY OR DESCRIPTION OF PERFORMANCE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE LICENSED SOFTWARE IS WITH YOU. SHOULD LICENSED SOFTWARE PROVE DEFECTIVE IN ANY RESPECT, YOU (AND NOT THE LICENSOR OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY SERVICING, REPAIR OR CORRECTION. UNDER THE TERMS OF THIS LICENSOR WILL NOT SUPPORT THIS SOFTWARE AND IS UNDER NO OBLIGATION TO ISSUE UPDATES TO THIS SOFTWARE. LICENSOR HAS NO KNOWLEDGE OF ERRANT CODE OR VIRUS IN THIS SOFTWARE, BUT DOES NOT WARRANT THAT THE SOFTWARE IS FREE FROM SUCH ERRORS OR VIRUSES. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. NO USE OF LICENSED SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER.\n\n   9.0 Limitation of Liability. UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER TORT (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL THE LICENSOR, ANY CONTRIBUTOR, OR ANY DISTRIBUTOR OF LICENSED SOFTWARE, OR ANY SUPPLIER OF ANY OF SUCH PARTIES, BE LIABLE TO ANY PERSON FOR ANY INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, COMPUTER FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER COMMERCIAL DAMAGES OR LOSSES, EVEN IF SUCH PARTY SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF LIABILITY SHALL NOT APPLY TO LIABILITY FOR DEATH OR PERSONAL INJURY RESULTING FROM SUCH PARTY'S NEGLIGENCE TO THE EXTENT APPLICABLE LAW PROHIBITS SUCH LIMITATION. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OR LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THIS EXCLUSION AND LIMITATION MAY NOT APPLY TO YOU.\n\n   10.0 High Risk Activities. THE LICENSED SOFTWARE IS NOT FAULT-TOLERANT AND IS NOT DESIGNED, MANUFACTURED, OR INTENDED FOR USE OR DISTRIBUTION AS ON-LINE CONTROL EQUIPMENT IN HAZARDOUS ENVIRONMENTS REQUIRING FAIL-SAFE PERFORMANCE, SUCH AS IN THE OPERATION OF NUCLEAR FACILITIES, AIRCRAFT NAVIGATION OR COMMUNICATIONS SYSTEMS, AIR TRAFFIC CONTROL, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH THE FAILURE OF THE LICENSED SOFTWARE COULD LEAD DIRECTLY TO DEATH, PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE (\"HIGH RISK ACTIVITIES\"). LICENSOR AND CONTRIBUTORS SPECIFICALLY DISCLAIM ANY EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.\n\n   11.0 Responsibility for Claims. As between Licensor and Contributors, each party is responsible for claims and damages arising, directly or indirectly, out of its utilization of rights under this License which specifically disclaims warranties and limits any liability of the Licensor. This paragraph is to be used in conjunction with and controlled by the Disclaimer Of Warranties of Section 8, the Limitation Of Damages in Section 9, and the disclaimer against use for High Risk Activities in Section 10. The Licensor has thereby disclaimed all warranties and limited any damages that it is or may be liable for. You agree to work with Licensor and Contributors to distribute such responsibility on an equitable basis consistent with the terms of this License including Sections 8, 9, and 10. Nothing herein is intended or shall be deemed to constitute any admission of liability.\n\n   12.0 Termination. This License and all rights granted hereunder will terminate immediately in the event of the circumstances described in Section 13.6 or if applicable law prohibits or restricts You from fully and or specifically complying with Sections 3, 4 and/or 6, or prevents the enforceability of any of those Sections, and You must immediately discontinue any use of Licensed Software.\n\n      12.1 Automatic Termination Upon Breach. This License and the rights granted hereunder will terminate automatically if You fail to comply with the terms herein and fail to cure such breach within thirty (30) days of becoming aware of the breach. All sublicenses to the Licensed Software that are properly granted shall survive any termination of this License. Provisions that, by their nature, must remain in effect beyond the termination of this License, shall survive.\n\n      12.2 Termination Upon Assertion of Patent Infringement. If You initiate litigation by asserting a patent infringement claim (excluding declaratory judgment actions) against Licensor or a Contributor (Licensor or Contributor against whom You file such an action is referred to herein as \"Respondent\") alleging that Licensed Software directly or indirectly infringes any patent, then any and all rights granted by such Respondent to You under Sections 3 or 4 of this License shall terminate prospectively upon sixty (60) days notice from Respondent (the \"Notice Period\") unless within that Notice Period You either agree in writing (i) to pay Respondent a mutually agreeable reasonably royalty for Your past or future use of Licensed Software made by such Respondent, or (ii) withdraw Your litigation claim with respect to Licensed Software against such Respondent. If within said Notice Period a reasonable royalty and payment arrangement are not mutually agreed upon in writing by the parties or the litigation claim is not withdrawn, the rights granted by Licensor to You under Sections 3 and 4 automatically terminate at the expiration of said Notice Period.\n\n      12.3 Reasonable Value of This License. If You assert a patent infringement claim against Respondent alleging that Licensed Software directly or indirectly infringes any patent where such claim is resolved (such as by license or settlement) prior to the initiation of patent infringement litigation, then the reasonable value of the licenses granted by said Respondent under Sections 3 and 4 shall be taken into account in determining the amount or value of any payment or license.\n\n      12.4 No Retroactive Effect of Termination. In the event of termination under this Section all end user license agreements (excluding licenses to distributors and resellers) that have been validly granted by You or any distributor hereunder prior to termination shall survive termination.\n\n   13.0 Miscellaneous.\n\n      13.1 U.S. Government End Users. The Licensed Software is a \"commercial item,\" as that term is defined in 48 C.F.R. 2.101 (Oct. 1995), consisting of \"commercial computer software\" and \"commercial computer software documentation,\" as such terms are used in 48 C.F.R. 12.212 (Sept. 1995). Consistent with 48 C.F.R. 12.212 and 48 C.F.R. 227.7202-1 through 227.7202-4 (June 1995), all U.S. Government End Users acquire Licensed Software with only those rights set forth herein.\n\n      13.2 Relationship of Parties. This License will not be construed as creating an agency, partnership, joint venture, or any other form of legal association between or among You, Licensor, or any Contributor, and You will not represent to the contrary, whether expressly, by implication, appearance, or otherwise.\n\n      13.3 Independent Development. Nothing in this License will impair Licensor's right to acquire, license, develop, subcontract, market, or distribute technology or products that perform the same or similar functions as, or otherwise compete with, Extensions that You may develop, produce, market, or distribute.\n\n      13.4 Consent To Breach Not Waiver. Failure by Licensor or Contributor to enforce any provision of this License will not be deemed a waiver of future enforcement of that or any other provision.\n\n      13.5 Severability. This License represents the complete agreement concerning the subject matter hereof. If any provision of this License is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable.\n\n      13.6 Inability to Comply Due to Statute or Regulation. If it is impossible for You to comply with any of the terms of this License with respect to some or all of the Licensed Software due to statute, judicial order, or regulation, then You cannot use, modify, or distribute the software.\n\n      13.7 Export Restrictions. You may be restricted with respect to downloading or otherwise acquiring, exporting, or reexporting the Licensed Software or any underlying information or technology by United States and other applicable laws and regulations. By downloading or by otherwise obtaining the Licensed Software, You are agreeing to be responsible for compliance with all applicable laws and regulations.\n\n      13.8 Arbitration, Jurisdiction \u0026 Venue. This License shall be governed by Colorado law provisions (except to the extent applicable law, if any, provides otherwise), excluding its conflict-of-law provisions. You expressly agree that any dispute relating to this License shall be submitted to binding arbitration under the rules then prevailing of the American Arbitration Association. You further agree that Adams County, Colorado USA is proper venue and grant such arbitration proceeding jurisdiction as may be appropriate for purposes of resolving any dispute under this License. Judgement upon any award made in arbitration may be entered and enforced in any court of competent jurisdiction. The arbitrator shall award attorney's fees and costs of arbitration to the prevailing party. Should either party find it necessary to enforce its arbitration award or seek specific performance of such award in a civil court of competent jurisdiction, the prevailing party shall be entitled to reasonable attorney's fees and costs. The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded. You and Licensor expressly waive any rights to a jury trial in any litigation concerning Licensed Software or this License. Any law or regulation that provides that the language of a contract shall be construed against the drafter shall not apply to this License.\n\n      13.9 Entire Agreement. This License constitutes the entire agreement between the parties with respect to the subject matter hereof. EXHIBIT A\n\nThe Notice below must appear in each file of the Source Code of any copy You distribute of the Licensed Software or any Extensions thereto, except as may be modified as allowed under the terms of Section 7.1\n\nCopyright (C) 1999-2002 Technical Pursuit Inc., All Rights Reserved. Patent Pending, Technical Pursuit Inc.\n\nUnless explicitly acquired and licensed from Licensor under the Technical Pursuit License (\"TPL\") Version 1.0 or greater, the contents of this file are subject to the Reciprocal Public License (\"RPL\") Version 1.1, or subsequent versions as allowed by the RPL, and You may not copy or use this file in either source code or executable form, except in compliance with the terms and conditions of the RPL.\n\nYou may obtain a copy of both the TPL and the RPL (the \"Licenses\") from Technical Pursuit Inc. at http://www.technicalpursuit.com.\n\nAll software distributed under the Licenses is provided strictly on an \"AS IS\" basis, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, AND TECHNICAL PURSUIT INC. HEREBY DISCLAIMS ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT, OR NON-INFRINGEMENT. See the Licenses for specific language governing rights and limitations under the Licenses."],"licenseIds":["RPL-1.1"],"keywords":["2001 2002 technical","reserved preamble this","the nature intent","nature intent and","intent and scope","of reciprocity in","reciprocity in exchange","exchange for being","for being granted","being granted certain","granted certain rights","certain rights under","licensor s software","s software whose","software whose source","code you have","you have access","access to you","to you are","required to reciprocate","to reciprocate by","reciprocate by providing","by providing equal","providing equal access","equal access and","access and rights","rights to all","parties to the","works and required","required components for","components for execution","for execution of","execution of same","of same collectively","same collectively defined","collectively defined as","defined as extensions","as extensions that","you deploy by","deploy by deploying","by deploying your","deploying your extensions","your extensions under","extensions under the","in this fashion","this fashion the","fashion the available","the available source","source code related","code related to","original licensed software","software is enlarged","is enlarged for","enlarged for the","benefit of everyone","of everyone under","everyone under the","you may a","may a distribute","licensed software exactly","software exactly as","exactly as you","received it under","license either alone","different sources without","sources without payment","without payment of","of a royalty","other fee b","fee b use","licensed software for","any purpose consistent","purpose consistent with","licensed software doesn","software doesn t","or damages c","damages c create","c create extensions","create extensions to","extensions to the","licensed software consistent","software consistent with","to any extensions","deploy available to","license document your","document your modifications","your modifications clearly","modifications clearly and","clearly and title","and title all","title all extensions","all extensions distinctly","extensions distinctly from","distinctly from the","licensed software d","software d charge","d charge a","liability obligations for","obligations for your","for your customers","your customers under","customers under the","may not a","not a charge","a charge for","your extensions other","extensions other than","nominal fee not","fee not to","not to exceed","to exceed your","exceed your cost","your cost for","cost for reproduction","for reproduction and","where such reproduction","such reproduction and","physical media b","media b modify","b modify or","licensed software c","software c assert","c assert any","or contributors or","contributors or which","or which would","which would in","would in any","any way restrict","way restrict the","party to use","or your rights","automatically terminate d","terminate d represent","d represent either","represent either expressly","expressly or by","that you represent","you represent licensor","represent licensor or","or contributors in","contributors in any","in any capacity","any capacity or","capacity or that","have any form","legal association by","association by virtue","virtue of this","must a document","a document any","document any modifications","licensed software including","software including the","including the nature","the change the","change the authors","the change and","change and the","the change this","change this documentation","this documentation must","documentation must appear","must appear both","appear both in","your extensions b","extensions b make","b make the","for any extensions","deploy available in","timely fashion via","fashion via an","distribution mechanism such","mechanism such as","or http download","http download c","download c notify","c notify the","notify the licensor","extensions in a","timely fashion and","fashion and include","in such notice","such notice a","a brief description","the extensions the","extensions the distinctive","the distinctive title","distinctive title used","title used and","used and instructions","code and future","and future updates","future updates d","updates d grant","d grant licensor","grant licensor and","under any intellectual","1 1 license","1 license applies"]},{"licenseTexts":["Reciprocal Public License 1.5 (RPL1.5)\n\nVersion 1.5, July 15, 2007 Copyright (C) 2001-2007 Technical Pursuit Inc., All Rights Reserved.\n\nPREAMBLE\n\nThe Reciprocal Public License (RPL) is based on the concept of reciprocity or, if you prefer, fairness.\n\nIn short, this license grew out of a desire to close loopholes in previous open source licenses, loopholes that allowed parties to acquire open source software and derive financial benefit from it without having to release their improvements or derivatives to the community which enabled them. This occurred any time an entity did not release their application to a \"third party\".\n\nWhile there is a certain freedom in this model of licensing, it struck the authors of the RPL as being unfair to the open source community at large and to the original authors of the works in particular. After all, bug fixes, extensions, and meaningful and valuable derivatives were not consistently finding their way back into the community where they could fuel further, and faster, growth and expansion of the overall open source software base.\n\nWhile you should clearly read and understand the entire license, the essence of the RPL is found in two definitions: \"Deploy\" and \"Required Components\".\n\nRegarding deployment, under the RPL your changes, bug fixes, extensions, etc. must be made available to the open source community at large when you Deploy in any form -- either internally or to an outside party. Once you start running the software you have to start sharing the software.\n\nFurther, under the RPL all components you author including schemas, scripts, source code, etc. -- regardless of whether they're compiled into a single binary or used as two halves of client/server application -- must be shared. You have to share the whole pie, not an isolated slice of it.\n\nIn addition to these goals, the RPL was authored to meet the requirements of the Open Source Definition as maintained by the Open Source Initiative (OSI).\n\nThe specific terms and conditions of the license are defined in the remainder of this document.\n\nLICENSE TERMS\n\n   1.0 General; Applicability \u0026 Definitions. This Reciprocal Public License Version 1.5 (\"License\") applies to any programs or other works as well as any and all updates or maintenance releases of said programs or works (\"Software\") not already covered by this License which the Software copyright holder (\"Licensor\") makes available containing a License Notice (hereinafter defined) from the Licensor specifying or allowing use or distribution under the terms of this License. As used in this License:\n\n      1.1 \"Contributor\" means any person or entity who created or contributed to the creation of an Extension.\n\n      1.2 \"Deploy\" means to use, Serve, sublicense or distribute Licensed Software other than for Your internal Research and/or Personal Use, and includes without limitation, any and all internal use or distribution of Licensed Software within Your business or organization other than for Research and/or Personal Use, as well as direct or indirect sublicensing or distribution of Licensed Software by You to any third party in any form or manner.\n\n      1.3 \"Derivative Works\" as used in this License is defined under U.S. copyright law.\n\n      1.4 \"Electronic Distribution Mechanism\" means a mechanism generally accepted in the software development community for the electronic transfer of data such as download from an FTP server or web site, where such mechanism is publicly accessible.\n\n      1.5 \"Extensions\" means any Modifications, Derivative Works, or Required Components as those terms are defined in this License.\n\n      1.6 \"License\" means this Reciprocal Public License.\n\n      1.7 \"License Notice\" means any notice contained in EXHIBIT A.\n\n      1.8 \"Licensed Software\" means any Software licensed pursuant to this License. Licensed Software also includes all previous Extensions from any Contributor that You receive.\n\n      1.9 \"Licensor\" means the copyright holder of any Software previously not covered by this License who releases the Software under the terms of this License.\n\n      1.10 \"Modifications\" means any additions to or deletions from the substance or structure of (i) a file or other storage containing Licensed Software, or (ii) any new file or storage that contains any part of Licensed Software, or (iii) any file or storage which replaces or otherwise alters the original functionality of Licensed Software at runtime.\n\n      1.11 \"Personal Use\" means use of Licensed Software by an individual solely for his or her personal, private and non-commercial purposes. An individual's use of Licensed Software in his or her capacity as an officer, employee, member, independent contractor or agent of a corporation, business or organization (commercial or non-commercial) does not qualify as Personal Use.\n\n      1.12 \"Required Components\" means any text, programs, scripts, schema, interface definitions, control files, or other works created by You which are required by a third party of average skill to successfully install and run Licensed Software containing Your Modifications, or to install and run Your Derivative Works.\n\n      1.13 \"Research\" means investigation or experimentation for the purpose of understanding the nature and limits of the Licensed Software and its potential uses.\n\n      1.14 \"Serve\" means to deliver Licensed Software and/or Your Extensions by means of a computer network to one or more computers for purposes of execution of Licensed Software and/or Your Extensions.\n\n      1.15 \"Software\" means any computer programs or other works as well as any updates or maintenance releases of those programs or works which are distributed publicly by Licensor.\n\n      1.16 \"Source Code\" means the preferred form for making modifications to the Licensed Software and/or Your Extensions, including all modules contained therein, plus any associated text, interface definition files, scripts used to control compilation and installation of an executable program or other components required by a third party of average skill to build a running version of the Licensed Software or Your Extensions.\n\n      1.17 \"User-Visible Attribution Notice\" means any notice contained in EXHIBIT B.\n\n      1.18 \"You\" or \"Your\" means an individual or a legal entity exercising rights under this License. For legal entities, \"You\" or \"Your\" includes any entity which controls, is controlled by, or is under common control with, You, where \"control\" means (a) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (b) ownership of fifty percent (50%) or more of the outstanding shares or beneficial ownership of such entity.\n\n   2.0 Acceptance Of License. You are not required to accept this License since you have not signed it, however nothing else grants you permission to use, copy, distribute, modify, or create derivatives of either the Software or any Extensions created by a Contributor. These actions are prohibited by law if you do not accept this License. Therefore, by performing any of these actions You indicate Your acceptance of this License and Your agreement to be bound by all its terms and conditions. IF YOU DO NOT AGREE WITH ALL THE TERMS AND CONDITIONS OF THIS LICENSE DO NOT USE, MODIFY, CREATE DERIVATIVES, OR DISTRIBUTE THE SOFTWARE. IF IT IS IMPOSSIBLE FOR YOU TO COMPLY WITH ALL THE TERMS AND CONDITIONS OF THIS LICENSE THEN YOU CAN NOT USE, MODIFY, CREATE DERIVATIVES, OR DISTRIBUTE THE SOFTWARE.\n\n   3.0 Grant of License From Licensor. Subject to the terms and conditions of this License, Licensor hereby grants You a world-wide, royalty-free, non-exclusive license, subject to Licensor's intellectual property rights, and any third party intellectual property claims derived from the Licensed Software under this License, to do the following:\n\n      3.1 Use, reproduce, modify, display, perform, sublicense and distribute Licensed Software and Your Extensions in both Source Code form or as an executable program.\n\n      3.2 Create Derivative Works (as that term is defined under U.S. copyright law) of Licensed Software by adding to or deleting from the substance or structure of said Licensed Software.\n\n      3.3 Under claims of patents now or hereafter owned or controlled by Licensor, to make, use, have made, and/or otherwise dispose of Licensed Software or portions thereof, but solely to the extent that any such claim is necessary to enable You to make, use, have made, and/or otherwise dispose of Licensed Software or portions thereof.\n\n      3.4 Licensor reserves the right to release new versions of the Software with different features, specifications, capabilities, functions, licensing terms, general availability or other characteristics. Title, ownership rights, and intellectual property rights in and to the Licensed Software shall remain in Licensor and/or its Contributors.\n\n   4.0 Grant of License From Contributor. By application of the provisions in Section 6 below, each Contributor hereby grants You a world-wide, royalty-free , non-exclusive license, subject to said Contributor's intellectual property rights, and any third party intellectual property claims derived from the Licensed Software under this License, to do the following:\n\n      4.1 Use, reproduce, modify, display, perform, sublicense and distribute any Extensions Deployed by such Contributor or portions thereof, in both Source Code form or as an executable program, either on an unmodified basis or as part of Derivative Works.\n\n      4.2 Under claims of patents now or hereafter owned or controlled by Contributor, to make, use, have made, and/or otherwise dispose of Extensions or portions thereof, but solely to the extent that any such claim is necessary to enable You to make, use, have made, and/or otherwise dispose of Licensed Software or portions thereof.\n\n   5.0 Exclusions From License Grant. Nothing in this License shall be deemed to grant any rights to trademarks, copyrights, patents, trade secrets or any other intellectual property of Licensor or any Contributor except as expressly stated herein. Except as expressly stated in Sections 3 and 4, no other patent rights, express or implied, are granted herein. Your Extensions may require additional patent licenses from Licensor or Contributors which each may grant in its sole discretion. No right is granted to the trademarks of Licensor or any Contributor even if such marks are included in the Licensed Software. Nothing in this License shall be interpreted to prohibit Licensor from licensing under different terms from this License any code that Licensor otherwise would have a right to license.\n\n      5.1 You expressly acknowledge and agree that although Licensor and each Contributor grants the licenses to their respective portions of the Licensed Software set forth herein, no assurances are provided by Licensor or any Contributor that the Licensed Software does not infringe the patent or other intellectual property rights of any other entity. Licensor and each Contributor disclaim any liability to You for claims brought by any other entity based on infringement of intellectual property rights or otherwise. As a condition to exercising the rights and licenses granted hereunder, You hereby assume sole responsibility to secure any other intellectual property rights needed, if any. For example, if a third party patent license is required to allow You to distribute the Licensed Software, it is Your responsibility to acquire that license before distributing the Licensed Software.\n\n   6.0 Your Obligations And Grants. In consideration of, and as an express condition to, the licenses granted to You under this License You hereby agree that any Modifications, Derivative Works, or Required Components (collectively Extensions) that You create or to which You contribute are governed by the terms of this License including, without limitation, Section 4. Any Extensions that You create or to which You contribute must be Deployed under the terms of this License or a future version of this License released under Section 7. You hereby grant to Licensor and all third parties a world-wide, non-exclusive, royalty-free license under those intellectual property rights You own or control to use, reproduce, display, perform, modify, create derivatives, sublicense, and distribute Licensed Software, in any form. Any Extensions You make and Deploy must have a distinct title so as to readily tell any subsequent user or Contributor that the Extensions are by You. You must include a copy of this License or directions on how to obtain a copy with every copy of the Extensions You distribute. You agree not to offer or impose any terms on any Source Code or executable version of the Licensed Software, or its Extensions that alter or restrict the applicable version of this License or the recipients' rights hereunder.\n\n      6.1 Availability of Source Code. You must make available, under the terms of this License, the Source Code of any Extensions that You Deploy, via an Electronic Distribution Mechanism. The Source Code for any version that You Deploy must be made available within one (1) month of when you Deploy and must remain available for no less than twelve (12) months after the date You cease to Deploy. You are responsible for ensuring that the Source Code to each version You Deploy remains available even if the Electronic Distribution Mechanism is maintained by a third party. You may not charge a fee for any copy of the Source Code distributed under this Section in excess of Your actual cost of duplication and distribution of said copy.\n\n      6.2 Description of Modifications. You must cause any Modifications that You create or to which You contribute to be documented in the Source Code, clearly describing the additions, changes or deletions You made. You must include a prominent statement that the Modifications are derived, directly or indirectly, from the Licensed Software and include the names of the Licensor and any Contributor to the Licensed Software in (i) the Source Code and (ii) in any notice displayed by the Licensed Software You distribute or in related documentation in which You describe the origin or ownership of the Licensed Software. You may not modify or delete any pre-existing copyright notices, change notices or License text in the Licensed Software without written permission of the respective Licensor or Contributor.\n\n      6.3 Intellectual Property Matters.\n\n         a. Third Party Claims. If You have knowledge that a license to a third party's intellectual property right is required to exercise the rights granted by this License, You must include a human-readable file with Your distribution that describes the claim and the party making the claim in sufficient detail that a recipient will know whom to contact.\n\n         b. Contributor APIs. If Your Extensions include an application programming interface (\"API\") and You have knowledge of patent licenses that are reasonably necessary to implement that API, You must also include this information in a human-readable file supplied with Your distribution.\n\n         c. Representations. You represent that, except as disclosed pursuant to 6.3(a) above, You believe that any Extensions You distribute are Your original creations and that You have sufficient rights to grant the rights conveyed by this License.\n\n      6.4 Required Notices.\n\n         a. License Text. You must duplicate this License or instructions on how to acquire a copy in any documentation You provide along with the Source Code of any Extensions You create or to which You contribute, wherever You describe recipients' rights relating to Licensed Software.\n\n         b. License Notice. You must duplicate any notice contained in EXHIBIT A (the \"License Notice\") in each file of the Source Code of any copy You distribute of the Licensed Software and Your Extensions. If You create an Extension, You may add Your name as a Contributor to the Source Code and accompanying documentation along with a description of the contribution. If it is not possible to put the License Notice in a particular Source Code file due to its structure, then You must include such License Notice in a location where a user would be likely to look for such a notice.\n\n         c. Source Code Availability. You must notify the software community of the availability of Source Code to Your Extensions within one (1) month of the date You initially Deploy and include in such notification a description of the Extensions, and instructions on how to acquire the Source Code. Should such instructions change you must notify the software community of revised instructions within one (1) month of the date of change. You must provide notification by posting to appropriate news groups, mailing lists, weblogs, or other sites where a publicly accessible search engine would reasonably be expected to index your post in relationship to queries regarding the Licensed Software and/or Your Extensions.\n\n         d. User-Visible Attribution. You must duplicate any notice contained in EXHIBIT B (the \"User-Visible Attribution Notice\") in each user-visible display of the Licensed Software and Your Extensions which delineates copyright, ownership, or similar attribution information. If You create an Extension, You may add Your name as a Contributor, and add Your attribution notice, as an equally visible and functional element of any User-Visible Attribution Notice content. To ensure proper attribution, You must also include such User-Visible Attribution Notice in at least one location in the Software documentation where a user would be likely to look for such notice.\n\n      6.5 Additional Terms. You may choose to offer, and charge a fee for, warranty, support, indemnity or liability obligations to one or more recipients of Licensed Software. However, You may do so only on Your own behalf, and not on behalf of the Licensor or any Contributor except as permitted under other agreements between you and Licensor or Contributor. You must make it clear that any such warranty, support, indemnity or liability obligation is offered by You alone, and You hereby agree to indemnify the Licensor and every Contributor for any liability plus attorney fees, costs, and related expenses due to any such action or claim incurred by the Licensor or such Contributor as a result of warranty, support, indemnity or liability terms You offer.\n\n      6.6 Conflicts With Other Licenses. Where any portion of Your Extensions, by virtue of being Derivative Works of another product or similar circumstance, fall under the terms of another license, the terms of that license should be honored however You must also make Your Extensions available under this License. If the terms of this License continue to conflict with the terms of the other license you may write the Licensor for permission to resolve the conflict in a fashion that remains consistent with the intent of this License. Such permission will be granted at the sole discretion of the Licensor.\n\n   7.0 Versions of This License. Licensor may publish from time to time revised versions of the License. Once Licensed Software has been published under a particular version of the License, You may always continue to use it under the terms of that version. You may also choose to use such Licensed Software under the terms of any subsequent version of the License published by Licensor. No one other than Licensor has the right to modify the terms applicable to Licensed Software created under this License.\n\n      7.1 If You create or use a modified version of this License, which You may do only in order to apply it to software that is not already Licensed Software under this License, You must rename Your license so that it is not confusingly similar to this License, and must make it clear that Your license contains terms that differ from this License. In so naming Your license, You may not use any trademark of Licensor or of any Contributor. Should Your modifications to this License be limited to alteration of a) Section 13.8 solely to modify the legal Jurisdiction or Venue for disputes, b) EXHIBIT A solely to define License Notice text, or c) to EXHIBIT B solely to define a User-Visible Attribution Notice, You may continue to refer to Your License as the Reciprocal Public License or simply the RPL.\n\n   8.0 Disclaimer of Warranty. LICENSED SOFTWARE IS PROVIDED UNDER THIS LICENSE ON AN \"AS IS\" BASIS, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES THAT THE LICENSED SOFTWARE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE OR NON-INFRINGING. FURTHER THERE IS NO WARRANTY MADE AND ALL IMPLIED WARRANTIES ARE DISCLAIMED THAT THE LICENSED SOFTWARE MEETS OR COMPLIES WITH ANY DESCRIPTION OF PERFORMANCE OR OPERATION, SAID COMPATIBILITY AND SUITABILITY BEING YOUR RESPONSIBILITY. LICENSOR DISCLAIMS ANY WARRANTY, IMPLIED OR EXPRESSED, THAT ANY CONTRIBUTOR'S EXTENSIONS MEET ANY STANDARD OF COMPATIBILITY OR DESCRIPTION OF PERFORMANCE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE LICENSED SOFTWARE IS WITH YOU. SHOULD LICENSED SOFTWARE PROVE DEFECTIVE IN ANY RESPECT, YOU (AND NOT THE LICENSOR OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY SERVICING, REPAIR OR CORRECTION. UNDER THE TERMS OF THIS LICENSOR WILL NOT SUPPORT THIS SOFTWARE AND IS UNDER NO OBLIGATION TO ISSUE UPDATES TO THIS SOFTWARE. LICENSOR HAS NO KNOWLEDGE OF ERRANT CODE OR VIRUS IN THIS SOFTWARE, BUT DOES NOT WARRANT THAT THE SOFTWARE IS FREE FROM SUCH ERRORS OR VIRUSES. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. NO USE OF LICENSED SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER.\n\n   9.0 Limitation of Liability. UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER TORT (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL THE LICENSOR, ANY CONTRIBUTOR, OR ANY DISTRIBUTOR OF LICENSED SOFTWARE, OR ANY SUPPLIER OF ANY OF SUCH PARTIES, BE LIABLE TO ANY PERSON FOR ANY INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, COMPUTER FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER COMMERCIAL DAMAGES OR LOSSES, EVEN IF SUCH PARTY SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF LIABILITY SHALL NOT APPLY TO LIABILITY FOR DEATH OR PERSONAL INJURY RESULTING FROM SUCH PARTY'S NEGLIGENCE TO THE EXTENT APPLICABLE LAW PROHIBITS SUCH LIMITATION. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OR LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THIS EXCLUSION AND LIMITATION MAY NOT APPLY TO YOU.\n\n   10.0 High Risk Activities. THE LICENSED SOFTWARE IS NOT FAULT-TOLERANT AND IS NOT DESIGNED, MANUFACTURED, OR INTENDED FOR USE OR DISTRIBUTION AS ON-LINE CONTROL EQUIPMENT IN HAZARDOUS ENVIRONMENTS REQUIRING FAIL-SAFE PERFORMANCE, SUCH AS IN THE OPERATION OF NUCLEAR FACILITIES, AIRCRAFT NAVIGATION OR COMMUNICATIONS SYSTEMS, AIR TRAFFIC CONTROL, DIRECT LIFE SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH THE FAILURE OF THE LICENSED SOFTWARE COULD LEAD DIRECTLY TO DEATH, PERSONAL INJURY, OR SEVERE PHYSICAL OR ENVIRONMENTAL DAMAGE (\"HIGH RISK ACTIVITIES\"). LICENSOR AND CONTRIBUTORS SPECIFICALLY DISCLAIM ANY EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR HIGH RISK ACTIVITIES.\n\n   11.0 Responsibility for Claims. As between Licensor and Contributors, each party is responsible for claims and damages arising, directly or indirectly, out of its utilization of rights under this License which specifically disclaims warranties and limits any liability of the Licensor. This paragraph is to be used in conjunction with and controlled by the Disclaimer Of Warranties of Section 8, the Limitation Of Damages in Section 9, and the disclaimer against use for High Risk Activities in Section 10. The Licensor has thereby disclaimed all warranties and limited any damages that it is or may be liable for. You agree to work with Licensor and Contributors to distribute such responsibility on an equitable basis consistent with the terms of this License including Sections 8, 9, and 10. Nothing herein is intended or shall be deemed to constitute any admission of liability.\n\n   12.0 Termination. This License and all rights granted hereunder will terminate immediately in the event of the circumstances described in Section 13.6 or if applicable law prohibits or restricts You from fully and or specifically complying with Sections 3, 4 and/or 6, or prevents the enforceability of any of those Sections, and You must immediately discontinue any use of Licensed Software.\n\n      12.1 Automatic Termination Upon Breach. This License and the rights granted hereunder will terminate automatically if You fail to comply with the terms herein and fail to cure such breach within thirty (30) days of becoming aware of the breach. All sublicenses to the Licensed Software that are properly granted shall survive any termination of this License. Provisions that, by their nature, must remain in effect beyond the termination of this License, shall survive.\n\n      12.2 Termination Upon Assertion of Patent Infringement. If You initiate litigation by asserting a patent infringement claim (excluding declaratory judgment actions) against Licensor or a Contributor (Licensor or Contributor against whom You file such an action is referred to herein as \"Respondent\") alleging that Licensed Software directly or indirectly infringes any patent, then any and all rights granted by such Respondent to You under Sections 3 or 4 of this License shall terminate prospectively upon sixty (60) days notice from Respondent (the \"Notice Period\") unless within that Notice Period You either agree in writing (i) to pay Respondent a mutually agreeable reasonably royalty for Your past or future use of Licensed Software made by such Respondent, or (ii) withdraw Your litigation claim with respect to Licensed Software against such Respondent. If within said Notice Period a reasonable royalty and payment arrangement are not mutually agreed upon in writing by the parties or the litigation claim is not withdrawn, the rights granted by Licensor to You under Sections 3 and 4 automatically terminate at the expiration of said Notice Period.\n\n      12.3 Reasonable Value of This License. If You assert a patent infringement claim against Respondent alleging that Licensed Software directly or indirectly infringes any patent where such claim is resolved (such as by license or settlement) prior to the initiation of patent infringement litigation, then the reasonable value of the licenses granted by said Respondent under Sections 3 and 4 shall be taken into account in determining the amount or value of any payment or license.\n\n      12.4 No Retroactive Effect of Termination. In the event of termination under this Section all end user license agreements (excluding licenses to distributors and resellers) that have been validly granted by You or any distributor hereunder prior to termination shall survive termination.\n\n   13.0 Miscellaneous.\n\n      13.1 U.S. Government End Users. The Licensed Software is a \"commercial item,\" as that term is defined in 48 C.F.R. 2.101 (Oct. 1995), consisting of \"commercial computer software\" and \"commercial computer software documentation,\" as such terms are used in 48 C.F.R. 12.212 (Sept. 1995). Consistent with 48 C.F.R. 12.212 and 48 C.F.R. 227.7202-1 through 227.7202-4 (June 1995), all U.S. Government End Users acquire Licensed Software with only those rights set forth herein.\n\n      13.2 Relationship of Parties. This License will not be construed as creating an agency, partnership, joint venture, or any other form of legal association between or among You, Licensor, or any Contributor, and You will not represent to the contrary, whether expressly, by implication, appearance, or otherwise.\n\n      13.3 Independent Development. Nothing in this License will impair Licensor's right to acquire, license, develop, subcontract, market, or distribute technology or products that perform the same or similar functions as, or otherwise compete with, Extensions that You may develop, produce, market, or distribute.\n\n      13.4 Consent To Breach Not Waiver. Failure by Licensor or Contributor to enforce any provision of this License will not be deemed a waiver of future enforcement of that or any other provision.\n\n      13.5 Severability. This License represents the complete agreement concerning the subject matter hereof. If any provision of this License is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable.\n\n      13.6 Inability to Comply Due to Statute or Regulation. If it is impossible for You to comply with any of the terms of this License with respect to some or all of the Licensed Software due to statute, judicial order, or regulation, then You cannot use, modify, or distribute the software.\n\n      13.7 Export Restrictions. You may be restricted with respect to downloading or otherwise acquiring, exporting, or reexporting the Licensed Software or any underlying information or technology by United States and other applicable laws and regulations. By downloading or by otherwise obtaining the Licensed Software, You are agreeing to be responsible for compliance with all applicable laws and regulations.\n\n      13.8 Arbitration, Jurisdiction \u0026 Venue. This License shall be governed by Colorado law provisions (except to the extent applicable law, if any, provides otherwise), excluding its conflict-of-law provisions. You expressly agree that any dispute relating to this License shall be submitted to binding arbitration under the rules then prevailing of the American Arbitration Association. You further agree that Adams County, Colorado USA is proper venue and grant such arbitration proceeding jurisdiction as may be appropriate for purposes of resolving any dispute under this License. Judgement upon any award made in arbitration may be entered and enforced in any court of competent jurisdiction. The arbitrator shall award attorney's fees and costs of arbitration to the prevailing party. Should either party find it necessary to enforce its arbitration award or seek specific performance of such award in a civil court of competent jurisdiction, the prevailing party shall be entitled to reasonable attorney's fees and costs. The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded. You and Licensor expressly waive any rights to a jury trial in any litigation concerning Licensed Software or this License. Any law or regulation that provides that the language of a contract shall be construed against the drafter shall not apply to this License.\n\n      13.9 Entire Agreement. This License constitutes the entire agreement between the parties with respect to the subject matter hereof. EXHIBIT A\n\nThe License Notice below must appear in each file of the Source Code of any copy You distribute of the Licensed Software or any Extensions thereto:\n\nUnless explicitly acquired and licensed from Licensor under another license, the contents of this file are subject to the Reciprocal Public License (\"RPL\") Version 1.5, or subsequent versions as allowed by the RPL, and You may not copy or use this file in either source code or executable form, except in compliance with the terms and conditions of the RPL.\n\nAll software distributed under the RPL is provided strictly on an \"AS IS\" basis, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, AND LICENSOR HEREBY DISCLAIMS ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT, OR NON-INFRINGEMENT. See the RPL for specific language governing rights and limitations under the RPL.\n\nEXHIBIT B\n\nThe User-Visible Attribution Notice below, when provided, must appear in each user-visible display as defined in Section 6.4 (d):"],"licenseIds":["RPL-1.5"],"keywords":["1 5 rpl1","5 rpl1 5","rpl1 5 version","5 version 1","1 5 july","5 july 15","july 15 2007","15 2007 copyright","c 2001 2007","2001 2007 technical","2007 technical pursuit","reserved preamble the","preamble the reciprocal","license rpl is","rpl is based","of reciprocity or","reciprocity or if","if you prefer","you prefer fairness","prefer fairness in","fairness in short","in short this","short this license","this license grew","license grew out","grew out of","out of a","of a desire","a desire to","desire to close","to close loopholes","close loopholes in","loopholes in previous","in previous open","previous open source","source licenses loopholes","licenses loopholes that","loopholes that allowed","that allowed parties","allowed parties to","parties to acquire","to acquire open","acquire open source","source software and","software and derive","and derive financial","derive financial benefit","financial benefit from","benefit from it","from it without","it without having","having to release","to release their","release their improvements","their improvements or","improvements or derivatives","or derivatives to","derivatives to the","the community which","community which enabled","which enabled them","enabled them this","them this occurred","this occurred any","occurred any time","any time an","time an entity","an entity did","entity did not","did not release","not release their","release their application","their application to","application to a","third party while","party while there","while there is","is a certain","a certain freedom","certain freedom in","freedom in this","in this model","this model of","model of licensing","of licensing it","licensing it struck","it struck the","struck the authors","the rpl as","rpl as being","as being unfair","being unfair to","unfair to the","original authors of","the works in","works in particular","in particular after","particular after all","after all bug","all bug fixes","fixes extensions and","extensions and meaningful","and meaningful and","meaningful and valuable","and valuable derivatives","valuable derivatives were","derivatives were not","were not consistently","not consistently finding","consistently finding their","finding their way","their way back","way back into","into the community","the community where","community where they","where they could","they could fuel","could fuel further","fuel further and","further and faster","and faster growth","faster growth and","growth and expansion","and expansion of","expansion of the","of the overall","the overall open","overall open source","source software base","software base while","base while you","while you should","you should clearly","should clearly read","clearly read and","understand the entire","entire license the","license the essence","the essence of","essence of the","rpl is found","found in two","in two definitions","two definitions deploy","definitions deploy and","deploy and required","required components regarding","components regarding deployment","regarding deployment under","deployment under the","the rpl your","rpl your changes","your changes bug","changes bug fixes","fixes extensions etc","extensions etc must","etc must be","at large when","large when you","you deploy in","deploy in any","any form either","form either internally","either internally or","internally or to","or to an","to an outside","an outside party","outside party once","party once you","once you start","you start running","start running the","running the software","software you have","have to start","to start sharing","start sharing the","sharing the software","the software further","software further under","further under the","rpl all components","all components you","components you author","you author including","author including schemas","including schemas scripts","schemas scripts source","scripts source code","source code etc","code etc regardless","etc regardless of","of whether they","whether they re","they re compiled","re compiled into","compiled into a","a single binary"]},{"licenseTexts":["RealNetworks Public Source License Version 1.0\n\n(Rev. Date October 28, 2002)\n\n   1. General Definitions. This License applies to any program or other work which RealNetworks, Inc., or any other entity that elects to use this license, (\"Licensor\") makes publicly available and which contains a notice placed by Licensor identifying such program or work as \"Original Code\" and stating that it is subject to the terms of this RealNetworks Public Source License version 1.0 (or subsequent version thereof) (\"License\"). You are not required to accept this License. However, nothing else grants You permission to use, copy, modify or distribute the software or its derivative works. These actions are prohibited by law if You do not accept this License. Therefore, by modifying, copying or distributing the software (or any work based on the software), You indicate your acceptance of this License to do so, and all its terms and conditions. In addition, you agree to the terms of this License by clicking the Accept button or downloading the software. As used in this License:\n\n      1.1 \"Applicable Patent Rights\" mean: (a) in the case where Licensor is the grantor of rights, claims of patents that (i) are now or hereafter acquired, owned by or assigned to Licensor and (ii) are necessarily infringed by using or making the Original Code alone and not in combination with other software or hardware; and (b) in the case where You are the grantor of rights, claims of patents that (i) are now or hereafter acquired, owned by or assigned to You and (ii) are infringed (directly or indirectly) by using or making Your Modifications, taken alone or in combination with Original Code.\n\n      1.2 \"Compatible Source License\" means any one of the licenses listed on Exhibit B or at https://www.helixcommunity.org/content/complicense or other licenses specifically identified by Licensor in writing. Notwithstanding any term to the contrary in any Compatible Source License, any code covered by any Compatible Source License that is used with Covered Code must be made readily available in Source Code format for royalty-free use under the terms of the Compatible Source License or this License.\n\n      1.3 \"Contributor\" means any person or entity that creates or contributes to the creation of Modifications.\n\n      1.4 \"Covered Code\" means the Original Code, Modifications, the combination of Original Code and any Modifications, and/or any respective portions thereof.\n\n      1.5 \"Deploy\" means to use, sublicense or distribute Covered Code other than for Your internal research and development (R\u0026D) and/or Personal Use, and includes without limitation, any and all internal use or distribution of Covered Code within Your business or organization except for R\u0026D use and/or Personal Use, as well as direct or indirect sublicensing or distribution of Covered Code by You to any third party in any form or manner.\n\n      1.6 \"Derivative Work\" means either the Covered Code or any derivative work under United States copyright law, and including any work containing or including any portion of the Covered Code or Modifications, either verbatim or with modifications and/or translated into another language. Derivative Work also includes any work which combines any portion of Covered Code or Modifications with code not otherwise governed by the terms of this License.\n\n      1.7 \"Externally Deploy\" means to Deploy the Covered Code in any way that may be accessed or used by anyone other than You, used to provide any services to anyone other than You, or used in any way to deliver any content to anyone other than You, whether the Covered Code is distributed to those parties, made available as an application intended for use over a computer network, or used to provide services or otherwise deliver content to anyone other than You.\n\n      1.8. \"Interface\" means interfaces, functions, properties, class definitions, APIs, header files, GUIDs, V-Tables, and/or protocols allowing one piece of software, firmware or hardware to communicate or interoperate with another piece of software, firmware or hardware.\n\n      1.9 \"Modifications\" mean any addition to, deletion from, and/or change to, the substance and/or structure of the Original Code, any previous Modifications, the combination of Original Code and any previous Modifications, and/or any respective portions thereof. When code is released as a series of files, a Modification is: (a) any addition to or deletion from the contents of a file containing Covered Code; and/or (b) any new file or other representation of computer program statements that contains any part of Covered Code.\n\n      1.10 \"Original Code\" means (a) the Source Code of a program or other work as originally made available by Licensor under this License, including the Source Code of any updates or upgrades to such programs or works made available by Licensor under this License, and that has been expressly identified by Licensor as such in the header file(s) of such work; and (b) the object code compiled from such Source Code and originally made available by Licensor under this License.\n\n      1.11 \"Personal Use\" means use of Covered Code by an individual solely for his or her personal, private and non-commercial purposes. An individual's use of Covered Code in his or her capacity as an officer, employee, member, independent contractor or agent of a corporation, business or organization (commercial or non-commercial) does not qualify as Personal Use.\n\n      1.12 \"Source Code\" means the human readable form of a program or other work that is suitable for making modifications to it, including all modules it contains, plus any associated interface definition files, scripts used to control compilation and installation of an executable (object code).\n\n      1.13 \"You\" or \"Your\" means an individual or a legal entity exercising rights under this License. For legal entities, \"You\" or \"Your\" includes any entity which controls, is controlled by, or is under common control with, You, where \"control\" means (a) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (b) ownership of fifty percent (50%) or more of the outstanding shares or beneficial ownership of such entity.\n\n   2. Permitted Uses; Conditions \u0026 Restrictions. Subject to the terms and conditions of this License, Licensor hereby grants You, effective on the date You accept this License (via downloading or using Covered Code or otherwise indicating your acceptance of this License), a worldwide, royalty-free, non-exclusive copyright license, to the extent of Licensor's copyrights cover the Original Code, to do the following:\n\n      2.1 You may reproduce, display, perform, modify and Deploy Covered Code, provided that in each instance:\n\n         (a) You must retain and reproduce in all copies of Original Code the copyright and other proprietary notices and disclaimers of Licensor as they appear in the Original Code, and keep intact all notices in the Original Code that refer to this License;\n\n         (b) You must include a copy of this License with every copy of Source Code of Covered Code and documentation You distribute, and You may not offer or impose any terms on such Source Code that alter or restrict this License or the recipients' rights hereunder, except as permitted under Section 6;\n\n         (c) You must duplicate, to the extent it does not already exist, the notice in Exhibit A in each file of the Source Code of all Your Modifications, and cause the modified files to carry prominent notices stating that You changed the files and the date of any change;\n\n         (d) You must make Source Code of all Your Externally Deployed Modifications publicly available under the terms of this License, including the license grants set forth in Section 3 below, for as long as you Deploy the Covered Code or twelve (12) months from the date of initial Deployment, whichever is longer. You should preferably distribute the Source Code of Your Deployed Modifications electronically (e.g. download from a web site); and\n\n         (e) if You Deploy Covered Code in object code, executable form only, You must include a prominent notice, in the code itself as well as in related documentation, stating that Source Code of the Covered Code is available under the terms of this License with information on how and where to obtain such Source Code. You must also include the Object Code Notice set forth in Exhibit A in the \"about\" box or other appropriate place where other copyright notices are placed, including any packaging materials.\n\n      2.2 You expressly acknowledge and agree that although Licensor and each Contributor grants the licenses to their respective portions of the Covered Code set forth herein, no assurances are provided by Licensor or any Contributor that the Covered Code does not infringe the patent or other intellectual property rights of any other entity. Licensor and each Contributor disclaim any liability to You for claims brought by any other entity based on infringement of intellectual property rights or otherwise. As a condition to exercising the rights and licenses granted hereunder, You hereby assume sole responsibility to secure any other intellectual property rights needed, if any. For example, if a third party patent license is required to allow You to make, use, sell, import or offer for sale the Covered Code, it is Your responsibility to acquire such license(s).\n\n      2.3 Subject to the terms and conditions of this License, Licensor hereby grants You, effective on the date You accept this License (via downloading or using Covered Code or otherwise indicating your acceptance of this License), a worldwide, royalty-free, perpetual, non-exclusive patent license under Licensor's Applicable Patent Rights to make, use, sell, offer for sale and import the Covered Code, provided that in each instance you comply with the terms of this License.\n\n   3. Your Grants. In consideration of, and as a condition to, the licenses granted to You under this License:\n\n      (a) You grant to Licensor and all third parties a non-exclusive, perpetual, irrevocable, royalty free license under Your Applicable Patent Rights and other intellectual property rights owned or controlled by You, to make, sell, offer for sale, use, import, reproduce, display, perform, modify, distribute and Deploy Your Modifications of the same scope and extent as Licensor's licenses under Sections 2.1 and 2.2; and\n\n      (b) You grant to Licensor and its subsidiaries a non-exclusive, worldwide, royalty-free, perpetual and irrevocable license, under Your Applicable Patent Rights and other intellectual property rights owned or controlled by You, to make, use, sell, offer for sale, import, reproduce, display, perform, distribute, modify or have modified (for Licensor and/or its subsidiaries), sublicense and distribute Your Modifications, in any form and for any purpose, through multiple tiers of distribution.\n\n      (c) You agree not use any information derived from Your use and review of the Covered Code, including but not limited to any algorithms or inventions that may be contained in the Covered Code, for the purpose of asserting any of Your patent rights, or assisting a third party to assert any of its patent rights, against Licensor or any Contributor.\n\n   4. Derivative Works. You may create a Derivative Work by combining Covered Code with other code not otherwise governed by the terms of this License and distribute the Derivative Work as an integrated product. In each such instance, You must make sure the requirements of this License are fulfilled for the Covered Code or any portion thereof, including all Modifications.\n\n      4.1 You must cause any Derivative Work that you distribute, publish or Externally Deploy, that in whole or in part contains or is derived from the Covered Code or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License and no other license except as provided in Section 4.2. You also must make Source Code available for the Derivative Work under the same terms as Modifications, described in Sections 2 and 3, above.\n\n      4.2 Compatible Source Licenses. Software modules that have been independently developed without any use of Covered Code and which contain no portion of the Covered Code, Modifications or other Derivative Works, but are used or combined in any way with the Covered Code or any Derivative Work to form a larger Derivative Work, are exempt from the conditions described in Section 4.1 but only to the extent that: the software module, including any software that is linked to, integrated with, or part of the same applications as, the software module by any method must be wholly subject to one of the Compatible Source Licenses. Notwithstanding the foregoing, all Covered Code must be subject to the terms of this License. Thus, the entire Derivative Work must be licensed under a combination of the RPSL (for Covered Code) and a Compatible Source License for any independently developed software modules within the Derivative Work. The foregoing requirement applies even if the Compatible Source License would ordinarily allow the software module to link with, or form larger works with, other software that is not subject to the Compatible Source License. For example, although the Mozilla Public License v1.1 allows Mozilla code to be combined with proprietary software that is not subject to the MPL, if MPL-licensed code is used with Covered Code the MPL-licensed code could not be combined or linked with any code not governed by the MPL. The general intent of this section 4.2 is to enable use of Covered Code with applications that are wholly subject to an acceptable open source license. You are responsible for determining whether your use of software with Covered Code is allowed under Your license to such software.\n\n      4.3 Mere aggregation of another work not based on the Covered Code with the Covered Code (or with a work based on the Covered Code) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. If You deliver the Covered Code for combination and/or integration with an application previously provided by You (for example, via automatic updating technology), such combination and/or integration constitutes a Derivative Work subject to the terms of this License.\n\n   5. Exclusions From License Grant. Nothing in this License shall be deemed to grant any rights to trademarks, copyrights, patents, trade secrets or any other intellectual property of Licensor or any Contributor except as expressly stated herein. No right is granted to the trademarks of Licensor or any Contributor even if such marks are included in the Covered Code. Nothing in this License shall be interpreted to prohibit Licensor from licensing under different terms from this License any code that Licensor otherwise would have a right to license. Modifications, Derivative Works and/or any use or combination of Covered Code with other technology provided by Licensor or third parties may require additional patent licenses from Licensor which Licensor may grant in its sole discretion. No patent license is granted separate from the Original Code or combinations of the Original Code with other software or hardware.\n\n      5.1. Trademarks. This License does not grant any rights to use the trademarks or trade names owned by Licensor (\"Licensor Marks\" defined in Exhibit C) or to any trademark or trade name belonging to any Contributor. No Licensor Marks may be used to endorse or promote products derived from the Original Code other than as permitted by the Licensor Trademark Policy defined in Exhibit C.\n\n   6. Additional Terms. You may choose to offer, and to charge a fee for, warranty, support, indemnity or liability obligations and/or other rights consistent with the scope of the license granted herein (\"Additional Terms\") to one or more recipients of Covered Code. However, You may do so only on Your own behalf and as Your sole responsibility, and not on behalf of Licensor or any Contributor. You must obtain the recipient's agreement that any such Additional Terms are offered by You alone, and You hereby agree to indemnify, defend and hold Licensor and every Contributor harmless for any liability incurred by or claims asserted against Licensor or such Contributor by reason of any such Additional Terms.\n\n   7. Versions of the License. Licensor may publish revised and/or new versions of this License from time to time. Each version will be given a distinguishing version number. Once Original Code has been published under a particular version of this License, You may continue to use it under the terms of that version. You may also choose to use such Original Code under the terms of any subsequent version of this License published by Licensor. No one other than Licensor has the right to modify the terms applicable to Covered Code created under this License.\n\n   8. NO WARRANTY OR SUPPORT. The Covered Code may contain in whole or in part pre-release, untested, or not fully tested works. The Covered Code may contain errors that could cause failures or loss of data, and may be incomplete or contain inaccuracies. You expressly acknowledge and agree that use of the Covered Code, or any portion thereof, is at Your sole and entire risk. THE COVERED CODE IS PROVIDED \"AS IS\" AND WITHOUT WARRANTY, UPGRADES OR SUPPORT OF ANY KIND AND LICENSOR AND LICENSOR'S LICENSOR(S) (COLLECTIVELY REFERRED TO AS \"LICENSOR\" FOR THE PURPOSES OF SECTIONS 8 AND 9) AND ALL CONTRIBUTORS EXPRESSLY DISCLAIM ALL WARRANTIES AND/OR CONDITIONS, EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES AND/OR CONDITIONS OF MERCHANTABILITY, OF SATISFACTORY QUALITY, OF FITNESS FOR A PARTICULAR PURPOSE, OF ACCURACY, OF QUIET ENJOYMENT, AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. LICENSOR AND EACH CONTRIBUTOR DOES NOT WARRANT AGAINST INTERFERENCE WITH YOUR ENJOYMENT OF THE COVERED CODE, THAT THE FUNCTIONS CONTAINED IN THE COVERED CODE WILL MEET YOUR REQUIREMENTS, THAT THE OPERATION OF THE COVERED CODE WILL BE UNINTERRUPTED OR ERROR-FREE, OR THAT DEFECTS IN THE COVERED CODE WILL BE CORRECTED. NO ORAL OR WRITTEN DOCUMENTATION, INFORMATION OR ADVICE GIVEN BY LICENSOR, A LICENSOR AUTHORIZED REPRESENTATIVE OR ANY CONTRIBUTOR SHALL CREATE A WARRANTY. You acknowledge that the Covered Code is not intended for use in high risk activities, including, but not limited to, the design, construction, operation or maintenance of nuclear facilities, aircraft navigation, aircraft communication systems, or air traffic control machines in which case the failure of the Covered Code could lead to death, personal injury, or severe physical or environmental damage. Licensor disclaims any express or implied warranty of fitness for such uses.\n\n   9. LIMITATION OF LIABILITY. TO THE EXTENT NOT PROHIBITED BY LAW, IN NO EVENT SHALL LICENSOR OR ANY CONTRIBUTOR BE LIABLE FOR ANY INCIDENTAL, SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES ARISING OUT OF OR RELATING TO THIS LICENSE OR YOUR USE OR INABILITY TO USE THE COVERED CODE, OR ANY PORTION THEREOF, WHETHER UNDER A THEORY OF CONTRACT, WARRANTY, TORT (INCLUDING NEGLIGENCE OR STRICT LIABILITY), PRODUCTS LIABILITY OR OTHERWISE, EVEN IF LICENSOR OR SUCH CONTRIBUTOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES AND NOTWITHSTANDING THE FAILURE OF ESSENTIAL PURPOSE OF ANY REMEDY. SOME JURISDICTIONS DO NOT ALLOW THE LIMITATION OF LIABILITY OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THIS LIMITATION MAY NOT APPLY TO YOU. In no event shall Licensor's total liability to You for all damages (other than as may be required by applicable law) under this License exceed the amount of ten dollars ($10.00).\n\n   10. Ownership. Subject to the licenses granted under this License, each Contributor retains all rights, title and interest in and to any Modifications made by such Contributor. Licensor retains all rights, title and interest in and to the Original Code and any Modifications made by or on behalf of Licensor (\"Licensor Modifications\"), and such Licensor Modifications will not be automatically subject to this License. Licensor may, at its sole discretion, choose to license such Licensor Modifications under this License, or on different terms from those contained in this License or may choose not to license them at all.\n\n   11. Termination.\n\n      11.1 Term and Termination. The term of this License is perpetual unless terminated as provided below. This License and the rights granted hereunder will terminate:\n\n         (a) automatically without notice from Licensor if You fail to comply with any term(s) of this License and fail to cure such breach within 30 days of becoming aware of such breach;\n\n         (b) immediately in the event of the circumstances described in Section 12.5(b); or\n\n         (c) automatically without notice from Licensor if You, at any time during the term of this License, commence an action for patent infringement against Licensor (including by cross-claim or counter claim in a lawsuit);\n\n         (d) upon written notice from Licensor if You, at any time during the term of this License, commence an action for patent infringement against any third party alleging that the Covered Code itself (excluding combinations with other software or hardware) infringes any patent (including by cross-claim or counter claim in a lawsuit).\n\n      11.2 Effect of Termination. Upon termination, You agree to immediately stop any further use, reproduction, modification, sublicensing and distribution of the Covered Code and to destroy all copies of the Covered Code that are in your possession or control. All sublicenses to the Covered Code which have been properly granted prior to termination shall survive any termination of this License. Provisions which, by their nature, should remain in effect beyond the termination of this License shall survive, including but not limited to Sections 3, 5, 8, 9, 10, 11, 12.2 and 13. No party will be liable to any other for compensation, indemnity or damages of any sort solely as a result of terminating this License in accordance with its terms, and termination of this License will be without prejudice to any other right or remedy of any party.\n\n   12. Miscellaneous.\n\n      12.1 Government End Users. The Covered Code is a \"commercial item\" as defined in FAR 2.101. Government software and technical data rights in the Covered Code include only those rights customarily provided to the public as defined in this License. This customary commercial license in technical data and software is provided in accordance with FAR 12.211 (Technical Data) and 12.212 (Computer Software) and, for Department of Defense purchases, DFAR 252.227-7015 (Technical Data -- Commercial Items) and 227.7202-3 (Rights in Commercial Computer Software or Computer Software Documentation). Accordingly, all U.S. Government End Users acquire Covered Code with only those rights set forth herein.\n\n      12.2 Relationship of Parties. This License will not be construed as creating an agency, partnership, joint venture or any other form of legal association between or among You, Licensor or any Contributor, and You will not represent to the contrary, whether expressly, by implication, appearance or otherwise.\n\n      12.3 Independent Development. Nothing in this License will impair Licensor's right to acquire, license, develop, have others develop for it, market and/or distribute technology or products that perform the same or similar functions as, or otherwise compete with, Modifications, Derivative Works, technology or products that You may develop, produce, market or distribute.\n\n      12.4 Waiver; Construction. Failure by Licensor or any Contributor to enforce any provision of this License will not be deemed a waiver of future enforcement of that or any other provision. Any law or regulation which provides that the language of a contract shall be construed against the drafter will not apply to this License.\n\n      12.5 Severability. (a) If for any reason a court of competent jurisdiction finds any provision of this License, or portion thereof, to be unenforceable, that provision of the License will be enforced to the maximum extent permissible so as to effect the economic benefits and intent of the parties, and the remainder of this License will continue in full force and effect. (b) Notwithstanding the foregoing, if applicable law prohibits or restricts You from fully and/or specifically complying with Sections 2 and/or 3 or prevents the enforceability of either of those Sections, this License will immediately terminate and You must immediately discontinue any use of the Covered Code and destroy all copies of it that are in your possession or control.\n\n      12.6 Dispute Resolution. Any litigation or other dispute resolution between You and Licensor relating to this License shall take place in the Seattle, Washington, and You and Licensor hereby consent to the personal jurisdiction of, and venue in, the state and federal courts within that District with respect to this License. The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded.\n\n      12.7 Export/Import Laws. This software is subject to all export and import laws and restrictions and regulations of the country in which you receive the Covered Code and You are solely responsible for ensuring that You do not export, re-export or import the Covered Code or any direct product thereof in violation of any such restrictions, laws or regulations, or without all necessary authorizations.\n\n      12.8 Entire Agreement; Governing Law. This License constitutes the entire agreement between the parties with respect to the subject matter hereof. This License shall be governed by the laws of the United States and the State of Washington.\n\n      Where You are located in the province of Quebec, Canada, the following clause applies: The parties hereby confirm that they have requested that this License and all related documents be drafted in English. Les parties ont exigé que le présent contrat et tous les documents connexes soient rédigés en anglais. EXHIBIT A.\n\n\"Copyright (c) 1995-2002 RealNetworks, Inc. and/or its licensors. All Rights Reserved.\n\nThe contents of this file, and the files included with this file, are subject to the current version of the RealNetworks Public Source License Version 1.0 (the \"RPSL\") available at https://www.helixcommunity.org/content/rpsl unless you have licensed the file under the RealNetworks Community Source License Version 1.0 (the \"RCSL\") available at https://www.helixcommunity.org/content/rcsl, in which case the RCSL will apply. You may also obtain the license terms directly from RealNetworks. You may not use this file except in compliance with the RPSL or, if you have a valid RCSL with RealNetworks applicable to this file, the RCSL. Please see the applicable RPSL or RCSL for the rights, obligations and limitations governing use of the contents of the file.\n\nThis file is part of the Helix DNA Technology. RealNetworks is the developer of the Original code and owns the copyrights in the portions it created.\n\nThis file, and the files included with this file, is distributed and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.\n\nContributor(s): ____________________________________\n\nTechnology Compatibility Kit Test Suite(s) Location (if licensed under the RCSL): _____\"\n\nObject Code Notice: Helix DNA Client technology included. Copyright (c) RealNetworks, Inc., 1995-2002. All rights reserved.\n\nEXHIBIT B\n\nCompatible Source Licenses for the RealNetworks Public Source License. The following list applies to the most recent version of the license as of October 25, 2002, unless otherwise indicated.\n\nAcademic Free License\n\nApache Software License\n\nApple Public Source License\n\nArtistic license\n\nAttribution Assurance Licenses\n\nBSD license\n\nCommon Public License1\n\nEiffel Forum License\n\nGNU General Public License (GPL)1\n\nGNU Library or \"Lesser\" General Public License (LGPL)1\n\nIBM Public License\n\nIntel Open Source License\n\nJabber Open Source License\n\nMIT license\n\nMITRE Collaborative Virtual Workspace License (CVW License)\n\nMotosoto License\n\nMozilla Public License 1.0 (MPL)\n\nMozilla Public License 1.1 (MPL)\n\nNokia Open Source License\n\nOpen Group Test Suite License\n\nPython Software Foundation License\n\nRicoh Source Code Public License\n\nSun Industry Standards Source License (SISSL)\n\nSun Public License\n\nUniversity of Illinois/NCSA Open Source License\n\nVovida Software License v. 1.0\n\nW3C License\n\nX.Net License\n\nZope Public License\n\nzlib/libpng license\n\n1Note: because this license contains certain reciprocal licensing terms that purport to extend to independently developed code, You may be prohibited under the terms of this otherwise compatible license from using code licensed under its terms with Covered Code because Covered Code may only be licensed under the RealNetworks Public Source License. Any attempt to apply non RPSL license terms, including without limitation the GPL, to Covered Code is expressly forbidden. You are responsible for ensuring that Your use of Compatible Source Licensed code does not violate either the RPSL or the Compatible Source License.\n\nThe latest version of this list can be found at: https://www.helixcommunity.org/content/complicense\n\nEXHIBIT C\n\nRealNetworks' Trademark policy.\n\nRealNetworks defines the following trademarks collectively as \"Licensor Trademarks\": \"RealNetworks\", \"RealPlayer\", \"RealJukebox\", \"RealSystem\", \"RealAudio\", \"RealVideo\", \"RealOne Player\", \"RealMedia\", \"Helix\" or any other trademarks or trade names belonging to RealNetworks.\n\nRealNetworks \"Licensor Trademark Policy\" forbids any use of Licensor Trademarks except as permitted by and in strict compliance at all times with RealNetworks' third party trademark usage guidelines which are posted at www.realnetworks.com/info/helixlogo.html."],"licenseIds":["RPSL-1.0"],"keywords":["1 0 rev","0 rev date","rev date october","date october 28","october 28 2002","28 2002 1","2002 1 general","work which realnetworks","which realnetworks inc","realnetworks inc or","entity that elects","that elects to","license licensor makes","placed by licensor","by licensor identifying","licensor identifying such","of this realnetworks","this realnetworks public","thereof license you","license however nothing","by modifying copying","modifying copying or","conditions in addition","addition you agree","license by clicking","by clicking the","clicking the accept","button or downloading","or downloading the","downloading the software","software as used","case where licensor","where licensor is","assigned to licensor","licensor and ii","ii are necessarily","infringed by using","or making the","not in combination","or hardware and","hardware and b","ii are infringed","are infringed directly","infringed directly or","or indirectly by","indirectly by using","or making your","making your modifications","source license means","license means any","means any one","any one of","the licenses listed","licenses listed on","listed on exhibit","on exhibit b","exhibit b or","b or at","or at https","content complicense or","complicense or other","other licenses specifically","licenses specifically identified","specifically identified by","in writing notwithstanding","writing notwithstanding any","notwithstanding any term","any term to","term to the","contrary in any","in any compatible","any code covered","code covered by","covered by any","by any compatible","source license that","be made readily","made readily available","readily available in","code format for","format for royalty","for royalty free","free use under","license or this","license 1 3","3 contributor means","modifications 1 4","1 5 deploy","5 deploy means","manner 1 6","1 6 derivative","6 derivative work","either the covered","work under united","under united states","states copyright law","law and including","and including any","including any work","work containing or","containing or including","or including any","including any portion","or modifications either","modifications either verbatim","another language derivative","language derivative work","derivative work also","work also includes","also includes any","includes any work","which combines any","combines any portion","portion of covered","or modifications with","modifications with code","1 7 externally","7 externally deploy","means to deploy","to deploy the","way that may","than you used","you used to","provide any services","services to anyone","you or used","or used in","way to deliver","to deliver any","deliver any content","any content to","whether the covered","to those parties","those parties made","parties made available","you 1 8","1 8 interface","8 interface means","interface means interfaces","means interfaces functions","interfaces functions properties","functions properties class","properties class definitions","class definitions apis","definitions apis header","apis header files","header files guids","files guids v","guids v tables","v tables and","tables and or","and or protocols","or protocols allowing","protocols allowing one","allowing one piece","one piece of","or hardware to","hardware to communicate","to communicate or","communicate or interoperate","interoperate with another","with another piece","another piece of","or hardware 1","hardware 1 9","9 modifications mean","by licensor as","licensor as such","licensor s copyrights","s copyrights cover","copyrights cover the","cover the original","may reproduce display","disclaimers of licensor","of licensor as","licensor as they","license b you","6 c you","any change d","change d you","site and e","and e if","include the object","code notice set","in the about","the about box","about box or","box or other","or other appropriate","other appropriate place","appropriate place where","place where other","where other copyright","notices are placed","are placed including","placed including any","including any packaging","any packaging materials","packaging materials 2","materials 2 2"]},{"licenseTexts":["Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All rights reserved.\n\nLicense to copy and use this software is granted provided that it is identified as the \"RSA Data Security, Inc. MD5 Message-Digest Algorithm\" in all material mentioning or referencing this software or this function.\n\nLicense is also granted to make and use derivative works provided that such works are identified as \"derived from the RSA Data Security, Inc. MD5 Message-Digest Algorithm\" in all material mentioning or referencing the derived work.\n\nRSA Data Security, Inc. makes no representations concerning either the merchantability of this software or the suitability of this software for any particular purpose. It is provided \"as is\" without express or implied warranty of any kind.\n\nThese notices must be retained in any copies of any part of this documentation and/or software."],"licenseIds":["RSA-MD"],"keywords":["c 1991 2","1991 2 rsa","2 rsa data","security inc created","inc created 1991","created 1991 all","1991 all rights","rights reserved license","reserved license to","copy and use","it is identified","is identified as","as the rsa","or referencing this","referencing this software","or this function","this function license","function license is","license is also","is also granted","make and use","and use derivative","use derivative works","that such works","works are identified","are identified as","identified as derived","as derived from","from the rsa","or referencing the","referencing the derived","derived work rsa","work rsa data","security inc makes","no representations concerning","representations concerning either","concerning either the","either the merchantability","the merchantability of","merchantability of this","or the suitability","particular purpose it","kind these notices","these notices must","in any copies","this documentation and","copyright c 1991 2","c 1991 2 rsa","1991 2 rsa data","2 rsa data security","data security inc created","security inc created 1991","inc created 1991 all","created 1991 all rights","1991 all rights reserved","all rights reserved license","rights reserved license to","reserved license to copy","license to copy and","to copy and use","copy and use this","and use this software","use this software is","granted provided that it","that it is identified","it is identified as","is identified as the","identified as the rsa","as the rsa data","mentioning or referencing this","or referencing this software","referencing this software or","software or this function","or this function license","this function license is","function license is also","license is also granted","is also granted to","also granted to make","to make and use","make and use derivative","and use derivative works","use derivative works provided","works provided that such","provided that such works","that such works are","such works are identified","works are identified as","are identified as derived","identified as derived from","as derived from the","derived from the rsa","from the rsa data","mentioning or referencing the","or referencing the derived","referencing the derived work","the derived work rsa","derived work rsa data","work rsa data security","data security inc makes","security inc makes no","inc makes no representations","makes no representations concerning","no representations concerning either","representations concerning either the","concerning either the merchantability","either the merchantability of","the merchantability of this","merchantability of this software","software or the suitability","or the suitability of","software for any particular","any particular purpose it","particular purpose it is","implied warranty of any","any kind these notices","kind these notices must","these notices must be","retained in any copies","in any copies of","copies of any part","part of this documentation","of this documentation and","this documentation and or","documentation and or software","copyright c 1991 2 rsa","c 1991 2 rsa data","1991 2 rsa data security","2 rsa data security inc","rsa data security inc created","data security inc created 1991","security inc created 1991 all","inc created 1991 all rights","created 1991 all rights reserved","1991 all rights reserved license","all rights reserved license to","rights reserved license to copy","reserved license to copy and","license to copy and use","to copy and use this","copy and use this software","and use this software is","use this software is granted","is granted provided that it","granted provided that it is","provided that it is identified","that it is identified as","it is identified as the","is identified as the rsa","identified as the rsa data","as the rsa data security","material mentioning or referencing this","mentioning or referencing this software","or referencing this software or","referencing this software or this","this software or this function","software or this function license","or this function license is","this function license is also","function license is also granted","license is also granted to","is also granted to make","also granted to make and","granted to make and use","to make and use derivative","make and use derivative works","and use derivative works provided","use derivative works provided that","derivative works provided that such","works provided that such works","provided that such works are","that such works are identified","such works are identified as","works are identified as derived","are identified as derived from","identified as derived from the","as derived from the rsa","derived from the rsa data","from the rsa data security","material mentioning or referencing the","mentioning or referencing the derived","or referencing the derived work","referencing the derived work rsa","the derived work rsa data","derived work rsa data security","work rsa data security inc","rsa data security inc makes","data security inc makes no","security inc makes no representations","inc makes no representations concerning","makes no representations concerning either","no representations concerning either the","representations concerning either the merchantability","concerning either the merchantability of","either the merchantability of this","the merchantability of this software","merchantability of this software or","this software or the suitability","software or the suitability of","or the suitability of this"]},{"licenseTexts":["Ricoh Source Code Public License\n\nVersion 1.0\n\n   1. Definitions.\n\n      1.1. \"Contributor\" means each entity that creates or contributes to the creation of Modifications.\n\n      1.2. \"Contributor Version\" means the combination of the Original Code, prior Modifications used by a Contributor, and the Modifications made by that particular Contributor.\n\n      1.3. \"Electronic Distribution Mechanism\" means a website or any other mechanism generally accepted in the software development community for the electronic transfer of data.\n\n      1.4. \"Executable Code\" means Governed Code in any form other than Source Code.\n\n      1.5. \"Governed Code\" means the Original Code or Modifications or the combination of the Original Code and Modifications, in each case including portions thereof.\n\n      1.6. \"Larger Work\" means a work which combines Governed Code or portions thereof with code not governed by the terms of this License.\n\n      1.7. \"Licensable\" means the right to grant, to the maximum extent possible, whether at the time of the initial grant or subsequently acquired, any and all of the rights conveyed herein.\n\n      1.8. \"License\" means this document.\n\n      1.9. \"Modifications\" means any addition to or deletion from the substance or structure of either the Original Code or any previous Modifications. When Governed Code is released as a series of files, a Modification is:\n\n         (a) Any addition to or deletion from the contents of a file containing Original Code or previous Modifications.\n\n         (b) Any new file that contains any part of the Original Code or previous Modifications.\n\n      1.10. \"Original Code\" means the \"Platform for Information Applications\" Source Code as released under this License by RSV.\n\n      1.11 \"Patent Claims\" means any patent claim(s), now owned or hereafter acquired, including without limitation, method, process, and apparatus claims, in any patent Licensable by the grantor of a license thereto.\n\n      1.12. \"RSV\" means Ricoh Silicon Valley, Inc., a California corporation with offices at 2882 Sand Hill Road, Suite 115, Menlo Park, CA 94025-7022.\n\n      1.13. \"Source Code\" means the preferred form of the Governed Code for making modifications to it, including all modules it contains, plus any associated interface definition files, scripts used to control compilation and installation of Executable Code, or a list of source code differential comparisons against either the Original Code or another well known, available Governed Code of the Contributor's choice. The Source Code can be in a compressed or archival form, provided the appropriate decompression or de-archiving software is widely available for no charge.\n\n      1.14. \"You\" means an individual or a legal entity exercising rights under, and complying with all of the terms of, this License or a future version of this License issued under Section 6.1. For legal entities, \"You\" includes any entity which controls, is controlled by, or is under common control with You. For purposes of this definition, \"control\" means (a) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (b) ownership of fifty percent (50%) or more of the outstanding shares or beneficial ownership of such entity.\n\n   2. Source Code License.\n\n      2.1. Grant from RSV. RSV hereby grants You a worldwide, royalty-free, non-exclusive license, subject to third party intellectual property claims:\n\n         (a) to use, reproduce, modify, create derivative works of, display, perform, sublicense and distribute the Original Code (or portions thereof) with or without Modifications, or as part of a Larger Work; and\n\n         (b) under Patent Claims infringed by the making, using or selling of Original Code, to make, have made, use, practice, sell, and offer for sale, and/or otherwise dispose of the Original Code (or portions thereof).\n\n      2.2. Contributor Grant. Each Contributor hereby grants You a worldwide, royalty-free, non-exclusive license, subject to third party intellectual property claims:\n\n         (a) to use, reproduce, modify, create derivative works of, display, perform, sublicense and distribute the Modifications created by such Contributor (or portions thereof) either on an unmodified basis, with other Modifications, as Governed Code or as part of a Larger Work; and\n\n         (b) under Patent Claims infringed by the making, using, or selling of Modifications made by that Contributor either alone and/or in combination with its Contributor Version (or portions of such combination), to make, use, sell, offer for sale, have made, and/or otherwise dispose of: (i) Modifications made by that Contributor (or portions thereof); and (ii) the combination of Modifications made by that Contributor with its Contributor Version (or portions of such combination).\n\n   3. Distribution Obligations.\n\n      3.1. Application of License. The Modifications which You create or to which You contribute are governed by the terms of this License, including without limitation Section 2.2. The Source Code version of Governed Code may be distributed only under the terms of this License or a future version of this License released under Section 6.1, and You must include a copy of this License with every copy of the Source Code You distribute. You may not offer or impose any terms on any Source Code version that alters or restricts the applicable version of this License or the recipients' rights hereunder. However, You may include an additional document offering the additional rights described in Section 3.5.\n\n      3.2. Availability of Source Code. Any Modification which You create or to which You contribute must be made available in Source Code form under the terms of this License either on the same media as an Executable Code version or via an Electronic Distribution Mechanism to anyone to whom you made an Executable Code version available; and if made available via an Electronic Distribution Mechanism, must remain available for at least twelve (12) months after the date it initially became available, or at least six (6) months after a subsequent version of that particular Modification has been made available to such recipients. You are responsible for ensuring that the Source Code version remains available even if the Electronic Distribution Mechanism is maintained by a third party.\n\n      3.3. Description of Modifications. You must cause all Governed Code to which you contribute to contain a file documenting the changes You made to create that Governed Code and the date of any change. You must include a prominent statement that the Modification is derived, directly or indirectly, from Original Code provided by RSV and including the name of RSV in (a) the Source Code, and (b) in any notice in an Executable Code version or related documentation in which You describe the origin or ownership of the Governed Code.\n\n      3.4. Intellectual Property Matters.\n\n         3.4.1. Third Party Claims. If You have knowledge that a party claims an intellectual property right in particular functionality or code (or its utilization under this License), you must include a text file with the source code distribution titled \"LEGAL\" which describes the claim and the party making the claim in sufficient detail that a recipient will know whom to contact. If you obtain such knowledge after You make Your Modification available as described in Section 3.2, You shall promptly modify the LEGAL file in all copies You make available thereafter and shall take other steps (such as notifying RSV and appropriate mailing lists or newsgroups) reasonably calculated to inform those who received the Governed Code that new knowledge has been obtained. In the event that You are a Contributor, You represent that, except as disclosed in the LEGAL file, your Modifications are your original creations and, to the best of your knowledge, no third party has any claim (including but not limited to intellectual property claims) relating to your Modifications. You represent that the LEGAL file includes complete details of any license or other restriction associated with any part of your Modifications.\n\n         3.4.2. Contributor APIs. If Your Modification is an application programming interface and You own or control patents which are reasonably necessary to implement that API, you must also include this information in the LEGAL file.\n\n      3.5. Required Notices. You must duplicate the notice in Exhibit A in each file of the Source Code, and this License in any documentation for the Source Code, where You describe recipients' rights relating to Governed Code. If You created one or more Modification(s), You may add your name as a Contributor to the notice described in Exhibit A. If it is not possible to put such notice in a particular Source Code file due to its structure, then you must include such notice in a location (such as a relevant directory file) where a user would be likely to look for such a notice. You may choose to offer, and to charge a fee for, warranty, support, indemnity or liability obligations to one or more recipients of Governed Code. However, You may do so only on Your own behalf, and not on behalf of RSV or any Contributor. You must make it absolutely clear than any such warranty, support, indemnity or liability obligation is offered by You alone, and You hereby agree to indemnify RSV and every Contributor for any liability incurred by RSV or such Contributor as a result of warranty, support, indemnity or liability terms You offer.\n\n      3.6. Distribution of Executable Code Versions. You may distribute Governed Code in Executable Code form only if the requirements of Section 3.1-3.5 have been met for that Governed Code, and if You include a prominent notice stating that the Source Code version of the Governed Code is available under the terms of this License, including a description of how and where You have fulfilled the obligations of Section 3.2. The notice must be conspicuously included in any notice in an Executable Code version, related documentation or collateral in which You describe recipients' rights relating to the Governed Code. You may distribute the Executable Code version of Governed Code under a license of Your choice, which may contain terms different from this License, provided that You are in compliance with the terms of this License and that the license for the Executable Code version does not attempt to limit or alter the recipient's rights in the Source Code version from the rights set forth in this License. If You distribute the Executable Code version under a different license You must make it absolutely clear that any terms which differ from this License are offered by You alone, not by RSV or any Contributor. You hereby agree to indemnify RSV and every Contributor for any liability incurred by RSV or such Contributor as a result of any such terms You offer.\n\n      3.7. Larger Works. You may create a Larger Work by combining Governed Code with other code not governed by the terms of this License and distribute the Larger Work as a single product. In such a case, You must make sure the requirements of this License are fulfilled for the Governed Code.\n\n   4. Inability to Comply Due to Statute or Regulation.\n\n   If it is impossible for You to comply with any of theterms of this License with respect to some or all of the Governed Code due to statute or regulation then You must: (a) comply with the terms of this License to the maximum extent possible; and (b) describe the limitations and the code they affect. Such description must be included in the LEGAL file described in Section 3.4 and must be included with all distributions of the Source Code. Except to the extent prohibited by statute or regulation, such description must be sufficiently detailed for a recipient of ordinary skill to be able to understand it.\n\n   5. Trademark Usage.\n\n      5.1. Advertising Materials. All advertising materials mentioning features or use of the Governed Code must display the following acknowledgement: \"This product includes software developed by Ricoh Silicon Valley, Inc.\"\n\n      5.2. Endorsements. The names \"Ricoh,\" \"Ricoh Silicon Valley,\" and \"RSV\" must not be used to endorse or promote Contributor Versions or Larger Works without the prior written permission of RSV.\n\n      5.3. Product Names. Contributor Versions and Larger Works may not be called \"Ricoh\" nor may the word \"Ricoh\" appear in their names without the prior written permission of RSV.\n\n   6. Versions of the License.\n\n      6.1. New Versions. RSV may publish revised and/or new versions of the License from time to time. Each version will be given a distinguishing version number.\n\n      6.2. Effect of New Versions. Once Governed Code has been published under a particular version of the License, You may always continue to use it under the terms of that version. You may also choose to use such Governed Code under the terms of any subsequent version of the License published by RSV. No one other than RSV has the right to modify the terms applicable to Governed Code created under this License.\n\n   7. Disclaimer of Warranty.\n\n   GOVERNED CODE IS PROVIDED UNDER THIS LICENSE ON AN \"AS IS\" BASIS, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES THAT THE GOVERNED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE GOVERNED CODE IS WITH YOU. SHOULD ANY GOVERNED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT RSV OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. NO USE OF ANY GOVERNED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER.\n\n   8. Termination.\n\n      8.1. This License and the rights granted hereunder will terminate automatically if You fail to comply with terms herein and fail to cure such breach within 30 days of becoming aware of the breach. All sublicenses to the Governed Code which are properly granted shall survive any termination of this License. Provisions which, by their nature, must remain in effect beyond the termination of this License shall survive.\n\n      8.2. If You initiate patent infringement litigation against RSV or a Contributor (RSV or the Contributor against whom You file such action is referred to as \"Participant\") alleging that:\n\n         (a) such Participant's Original Code or Contributor Version directly or indirectly infringes any patent, then any and all rights granted by such Participant to You under Sections 2.1 and/or 2.2 of this License shall, upon 60 days notice from Participant terminate prospectively, unless if within 60 days after receipt of notice You either: (i) agree in writing to pay Participant a mutually agreeable reasonable royalty for Your past and future use of the Original Code or the Modifications made by such Participant, or (ii) withdraw Your litigation claim with respect to the Original Code or the Contributor Version against such Participant. If within 60 days of notice, a reasonable royalty and payment arrangement are not mutually agreed upon in writing by the parties or the litigation claim is not withdrawn, the rights granted by Participant to You under Sections 2.1 and/or 2.2 automatically terminate at the expiration of the 60 day notice period specified above.\n\n         (b) any software, hardware, or device provided to You by the Participant, other than such Participant's Original Code or Contributor Version, directly or indirectly infringes any patent, then any rights granted to You by such Participant under Sections 2.1(b) and 2.2(b) are revoked effective as of the date You first made, used, sold, distributed, or had made, Original Code or the Modifications made by that Participant.\n\n      8.3. If You assert a patent infringement claim against Participant alleging that such Participant's Original Code or Contributor Version directly or indirectly infringes any patent where such claim is resolved (such as by license or settlement) prior to the initiation of patent infringement litigation, then the reasonable value of the licenses granted by such Participant under Sections 2.1 or 2.2 shall be taken into account in determining the amount or value of any payment or license.\n\n      8.4. In the event of termination under Sections 8.1 or 8.2 above, all end user license agreements (excluding distributors and resellers) which have been validly granted by You or any distributor hereunder prior to termination shall survive termination.\n\n   9. Limitation of Liability.\n\n   UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER TORT (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL RSV, ANY CONTRIBUTOR, OR ANY DISTRIBUTOR OF GOVERNED CODE, OR ANY SUPPLIER OF ANY OF SUCH PARTIES, BE LIABLE TO YOU OR ANY OTHER PERSON FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, COMPUTER FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER COMMERCIAL DAMAGES OR LOSSES, EVEN IF SUCH PARTY SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF LIABILITY SHALL NOT APPLY TO LIABILITY FOR DEATH OR PERSONAL INJURY RESULTING FROM SUCH PARTY'S NEGLIGENCE TO THE EXTENT APPLICABLE LAW PROHIBITS SUCH LIMITATION. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OR LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THAT EXCLUSION AND LIMITATION MAY NOT APPLY TO YOU. TO THE EXTENT THAT ANY EXCLUSION OF DAMAGES ABOVE IS NOT VALID, YOU AGREE THAT IN NO EVENT WILL RSV'S LIABILITY UNDER OR RELATED TO THIS AGREEMENT EXCEED FIVE THOUSAND DOLLARS ($5,000). THE GOVERNED CODE IS NOT INTENDED FOR USE IN CONNECTION WITH ANY NUCLER, AVIATION, MASS TRANSIT OR MEDICAL APPLICATION OR ANY OTHER INHERENTLY DANGEROUS APPLICATION THAT COULD RESULT IN DEATH, PERSONAL INJURY, CATASTROPHIC DAMAGE OR MASS DESTRUCTION, AND YOU AGREE THAT NEITHER RSV NOR ANY CONTRIBUTOR SHALL HAVE ANY LIABILITY OF ANY NATURE AS A RESULT OF ANY SUCH USE OF THE GOVERNED CODE.\n\n   10. U.S. Government End Users.\n\n   The Governed Code is a \"commercial item,\" as that term is defined in 48 C.F.R. 2.101 (Oct. 1995), consisting of \"commercial computer software\" and \"commercial computer software documentation,\" as such terms are used in 48 C.F.R. 12.212 (Sept. 1995). Consistent with 48 C.F.R. 12.212 and 48 C.F.R. 227.7202-1 through 227.7202-4 (June 1995), all U.S. Government End Users acquire Governed Code with only those rights set forth herein.\n\n   11. Miscellaneous.\n\n   This License represents the complete agreement concerning subject matter hereof. If any provision of this License is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable. This License shall be governed by California law provisions (except to the extent applicable law, if any, provides otherwise), excluding its conflict-of-law provisions. The parties submit to personal jurisdiction in California and further agree that any cause of action arising under or related to this Agreement shall be brought in the Federal Courts of the Northern District of California, with venue lying in Santa Clara County, California. The losing party shall be responsible for costs, including without limitation, court costs and reasonable attorney's fees and expenses. Notwithstanding anything to the contrary herein, RSV may seek injunctive relief related to a breach of this Agreement in any court of competent jurisdiction. The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded. Any law or regulation which provides that the language of a contract shall be construed against the drafter shall not apply to this License.\n\n   12. Responsibility for Claims.\n\n   Except in cases where another Contributor has failed to comply with Section 3.4, You are responsible for damages arising, directly or indirectly, out of Your utilization of rights under this License, based on the number of copies of Governed Code you made available, the revenues you received from utilizing such rights, and other relevant factors. You agree to work with affected parties to distribute responsibility on an equitable basis. EXHIBIT A\n\n\"The contents of this file are subject to the Ricoh Source Code Public License Version 1.0 (the \"License\"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.risource.org/RPL\n\nSoftware distributed under the License is distributed on an \"AS IS\" basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the specific language governing rights and limitations under the License.\n\nThis code was initially developed by Ricoh Silicon Valley, Inc. Portions created by Ricoh Silicon Valley, Inc. are Copyright (C) 1995-1999. All Rights Reserved.\n\nContributor(s): ______________________________________.\""],"licenseIds":["RSCPL"],"keywords":["means a website","a website or","website or any","any other mechanism","other mechanism generally","4 executable code","executable code means","code means governed","means governed code","1 5 governed","5 governed code","governed code means","thereof 1 6","which combines governed","combines governed code","1 7 licensable","7 licensable means","licensable means the","means the right","herein 1 8","modifications when governed","when governed code","means the platform","the platform for","platform for information","for information applications","information applications source","code as released","as released under","license by rsv","by rsv 1","rsv 1 11","by the grantor","grantor of a","a license thereto","license thereto 1","thereto 1 12","1 12 rsv","12 rsv means","rsv means ricoh","means ricoh silicon","valley inc a","inc a california","a california corporation","california corporation with","corporation with offices","with offices at","offices at 2882","at 2882 sand","2882 sand hill","sand hill road","hill road suite","road suite 115","suite 115 menlo","115 menlo park","park ca 94025","ca 94025 7022","94025 7022 1","7022 1 13","governed code for","installation of executable","known available governed","available governed code","governed code of","charge 1 14","14 you means","2 1 grant","1 grant from","grant from rsv","from rsv rsv","rsv rsv hereby","rsv hereby grants","portions thereof 2","thereof 2 2","modifications as governed","as governed code","dispose of i","of i modifications","i modifications made","such combination 3","combination 3 distribution","governed code may","code version available","available via an","cause all governed","all governed code","governed code to","create that governed","provided by rsv","by rsv and","rsv and including","name of rsv","of rsv in","rsv in a","governed code 3","property matters 3","matters 3 4","3 4 1","4 1 third","1 third party","as notifying rsv","notifying rsv and","rsv and appropriate","and appropriate mailing","received the governed","governed code that","been obtained in","obtained in the","event that you","as disclosed in","disclosed in the","legal file your","file your modifications","creations and to","modifications you represent","represent that the","that the legal","legal file includes","file includes complete","other restriction associated","modifications 3 4","4 2 contributor","2 contributor apis","relating to governed","governed code if","recipients of governed","governed code however","behalf of rsv","of rsv or","executable code versions","code versions you","may distribute governed","distribute governed code","in executable code","executable code form","code form only","for that governed","prominent notice stating","code version related","code version does","code version under","not by rsv","by combining governed","combining governed code","for the governed","governed code 4","any of theterms","of theterms of","theterms of this","governed code due","it 5 trademark","5 trademark usage","trademark usage 5","usage 5 1","5 1 advertising","governed code must","valley inc 5","inc 5 2","5 2 endorsements","the names ricoh","names ricoh ricoh","ricoh ricoh silicon","silicon valley and","valley and rsv","and rsv must","rsv must not","of rsv 5","rsv 5 3","5 3 product","be called ricoh","called ricoh nor","ricoh nor may","the word ricoh","word ricoh appear","ricoh appear in","of rsv 6","rsv 6 versions","new versions rsv","versions rsv may","rsv may publish","versions once governed","once governed code","governed code has","use such governed","such governed code","published by rsv","by rsv no","rsv no one","other than rsv","than rsv has","rsv has the","applicable to governed","governed code created","of warranty governed","warranty governed code","that the governed","should any governed","governed code prove","you not rsv","not rsv or"]},{"licenseTexts":["Rdisc (this program) was developed by Sun Microsystems, Inc. and is provided for unrestricted use provided that this legend is included on all tape media and as a part of the software program in whole or part. Users may copy or modify Rdisc without charge, and they may freely distribute it.\n\nRDISC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.\n\nRdisc is provided with no support and without any obligation on the part of Sun Microsystems, Inc. to assist in its use, correction, modification or enhancement.\n\nSUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY RDISC OR ANY PART THEREOF.\n\nIn no event will Sun Microsystems, Inc. be liable for any lost revenue or profits or other special, indirect and consequential damages, even if Sun has been advised of the possibility of such damages.\n\nSun Microsystems, Inc.\n\n2550 Garcia Avenue\n\nMountain View, California 94043"],"licenseIds":["Rdisc"],"keywords":["rdisc this program","program was developed","developed by sun","inc and is","and is provided","provided for unrestricted","for unrestricted use","unrestricted use provided","that this legend","this legend is","legend is included","is included on","included on all","on all tape","all tape media","tape media and","media and as","the software program","software program in","program in whole","or part users","part users may","users may copy","may copy or","copy or modify","or modify rdisc","modify rdisc without","rdisc without charge","charge and they","and they may","they may freely","freely distribute it","distribute it rdisc","it rdisc is","of design merchantibility","design merchantibility and","purpose or arising","trade practice rdisc","practice rdisc is","part of sun","microsystems inc to","inc to assist","or enhancement sun","enhancement sun microsystems","microsystems inc shall","inc shall have","patents by rdisc","by rdisc or","rdisc or any","part thereof in","thereof in no","will sun microsystems","microsystems inc be","such damages sun","damages sun microsystems","microsystems inc 2550","inc 2550 garcia","2550 garcia avenue","garcia avenue mountain","avenue mountain view","mountain view california","view california 94043","rdisc this program was","this program was developed","program was developed by","was developed by sun","developed by sun microsystems","microsystems inc and is","inc and is provided","and is provided for","is provided for unrestricted","provided for unrestricted use","for unrestricted use provided","unrestricted use provided that","use provided that this","provided that this legend","that this legend is","this legend is included","legend is included on","is included on all","included on all tape","on all tape media","all tape media and","tape media and as","media and as a","and as a part","of the software program","the software program in","software program in whole","program in whole or","whole or part users","or part users may","part users may copy","users may copy or","may copy or modify","copy or modify rdisc","or modify rdisc without","modify rdisc without charge","rdisc without charge and","without charge and they","charge and they may","and they may freely","they may freely distribute","may freely distribute it","freely distribute it rdisc","distribute it rdisc is","it rdisc is provided","rdisc is provided as","warranties of design merchantibility","of design merchantibility and","design merchantibility and fitness","particular purpose or arising","purpose or arising from","or trade practice rdisc","trade practice rdisc is","practice rdisc is provided","rdisc is provided with","the part of sun","part of sun microsystems","sun microsystems inc to","microsystems inc to assist","inc to assist in","modification or enhancement sun","or enhancement sun microsystems","enhancement sun microsystems inc","sun microsystems inc shall","microsystems inc shall have","inc shall have no","any patents by rdisc","patents by rdisc or","by rdisc or any","rdisc or any part","any part thereof in","part thereof in no","thereof in no event","event will sun microsystems","will sun microsystems inc","sun microsystems inc be","microsystems inc be liable","and consequential damages even","damages even if sun","of such damages sun","such damages sun microsystems","damages sun microsystems inc","sun microsystems inc 2550","microsystems inc 2550 garcia","inc 2550 garcia avenue","2550 garcia avenue mountain","garcia avenue mountain view","avenue mountain view california","mountain view california 94043","rdisc this program was developed","this program was developed by","program was developed by sun","was developed by sun microsystems","developed by sun microsystems inc","by sun microsystems inc and","sun microsystems inc and is","microsystems inc and is provided","inc and is provided for","and is provided for unrestricted","is provided for unrestricted use","provided for unrestricted use provided","for unrestricted use provided that","unrestricted use provided that this","use provided that this legend","provided that this legend is","that this legend is included","this legend is included on","legend is included on all","is included on all tape","included on all tape media","on all tape media and","all tape media and as","tape media and as a","media and as a part","and as a part of","a part of the software","part of the software program","of the software program in","the software program in whole","software program in whole or","program in whole or part","in whole or part users","whole or part users may","or part users may copy","part users may copy or","users may copy or modify","may copy or modify rdisc","copy or modify rdisc without","or modify rdisc without charge","modify rdisc without charge and","rdisc without charge and they","without charge and they may","charge and they may freely","and they may freely distribute","they may freely distribute it","may freely distribute it rdisc","freely distribute it rdisc is","distribute it rdisc is provided"]},{"licenseTexts":["\n\n   1. You may make and give away verbatim copies of the source form of the software without restriction, provided that you duplicate all of the original copyright notices and associated disclaimers.\n\n   2. You may modify your copy of the software in any way, provided that you do at least ONE of the following:\n\n   a) place your modifications in the Public Domain or otherwise make them Freely Available, such as by posting said modifications to Usenet or an equivalent medium, or by allowing the author to include your modifications in the software.\n\n   b) use the modified software only within your corporation or organization.\n\n   c) give non-standard binaries non-standard names, with instructions on where to get the original software distribution.\n\n   d) make other distribution arrangements with the author.\n\n   3. You may distribute the software in object code or binary form, provided that you do at least ONE of the following:\n\n   a) distribute the binaries and library files of the software, together with instructions (in the manual page or equivalent) on where to get the original distribution.\n\n   b) accompany the distribution with the machine-readable source of the software.\n\n   c) give non-standard binaries non-standard names, with instructions on where to get the original software distribution.\n\n   d) make other distribution arrangements with the author.\n\n   4. You may modify and include the part of the software into any other software (possibly commercial). But some files in the distribution are not written by the author, so that they are not under these terms.\n\n   For the list of those files and their copying conditions, see the file LEGAL.\n\n   5. The scripts and library files supplied as input to or produced as output from the software do not automatically fall under the copyright of the software, but belong to whomever generated them, and may be sold commercially, and may be aggregated with this software.\n\n   6. THIS SOFTWARE IS PROVIDED \"AS IS\" AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE."],"licenseIds":["Ruby"],"keywords":["medium or by","allowing the author","author to include","software b use","modified software only","software only within","organization c give","the author 3","author 3 you","distribute the binaries","the binaries and","binaries and library","library files of","the software together","software together with","original distribution b","distribution b accompany","software c give","the author 4","author 4 you","modify and include","include the part","the software into","software into any","into any other","other software possibly","software possibly commercial","possibly commercial but","commercial but some","but some files","some files in","distribution are not","are not written","not written by","written by the","the author so","author so that","not under these","these terms for","for the list","list of those","files and their","and their copying","their copying conditions","copying conditions see","conditions see the","file legal 5","legal 5 the","5 the scripts","the software do","software do not","copyright of the","software but belong","this software 6","software 6 this","6 this software","form of the software","software without restriction provided","software in any way","equivalent medium or by","medium or by allowing","by allowing the author","allowing the author to","the author to include","author to include your","modifications in the software","the software b use","software b use the","use the modified software","the modified software only","modified software only within","software only within your","or organization c give","organization c give non","with the author 3","the author 3 you","author 3 you may","software in object code","object code or binary","binary form provided that","following a distribute the","a distribute the binaries","distribute the binaries and","the binaries and library","binaries and library files","and library files of","library files of the","files of the software","of the software together","the software together with","software together with instructions","get the original distribution","the original distribution b","original distribution b accompany","distribution b accompany the","source of the software","of the software c","the software c give","software c give non","with the author 4","the author 4 you","author 4 you may","4 you may modify","you may modify and","may modify and include","modify and include the","and include the part","include the part of","of the software into","the software into any","software into any other","into any other software","any other software possibly","other software possibly commercial","software possibly commercial but","possibly commercial but some","commercial but some files","but some files in","some files in the","the distribution are not","distribution are not written","are not written by","not written by the","written by the author","by the author so","the author so that","author so that they","so that they are","that they are not","they are not under","are not under these","not under these terms","under these terms for","these terms for the","terms for the list","for the list of","the list of those","list of those files","those files and their","files and their copying","and their copying conditions","their copying conditions see","copying conditions see the","conditions see the file","the file legal 5","file legal 5 the","legal 5 the scripts","5 the scripts and","output from the software","from the software do","the software do not","software do not automatically","the copyright of the","copyright of the software","of the software but","the software but belong","software but belong to","aggregated with this software","with this software 6","this software 6 this","software 6 this software","6 this software is","source form of the software","form of the software without","of the software without restriction","the software without restriction provided","software without restriction provided that","disclaimers 2 you may modify","your copy of the software","copy of the software in","the software in any way","software in any way provided","way provided that you do","an equivalent medium or by","equivalent medium or by allowing","medium or by allowing the","or by allowing the author","by allowing the author to","allowing the author to include","the author to include your","author to include your modifications","your modifications in the software","modifications in the software b","in the software b use","the software b use the","software b use the modified","b use the modified software","use the modified software only","the modified software only within","modified software only within your","software only within your corporation","corporation or organization c give","or organization c give non","organization c give non standard","arrangements with the author 3","with the author 3 you","the author 3 you may","author 3 you may distribute","3 you may distribute the","distribute the software in object"]},{"licenseTexts":["Copyright Status\n\nSAX is free!\n\nIn fact, it's not possible to own a license to SAX, since it's been placed in the public domain.\n\nNo Warranty\n\nBecause SAX is released to the public domain, there is no warranty for the design or for the software implementation, to the extent permitted by applicable law. Except when otherwise stated in writing the copyright holders and/or other parties provide SAX \"as is\" without warranty of any kind, either expressed or implied, including, but not limited to, the implied warranties of merchantability and fitness for a particular purpose. The entire risk as to the quality and performance of SAX is with you. Should SAX prove defective, you assume the cost of all necessary servicing, repair or correction.\n\nIn no event unless required by applicable law or agreed to in writing will any copyright holder, or any other party who may modify and/or redistribute SAX, be liable to you for damages, including any general, special, incidental or consequential damages arising out of the use or inability to use SAX (including but not limited to loss of data or data being rendered inaccurate or losses sustained by you or third parties or a failure of the SAX to operate with any other programs), even if such holder or other party has been advised of the possibility of such damages.\n\nCopyright Disclaimers\n\nThis page includes statements to that effect by David Megginson, who would have been able to claim copyright for the original work.\n\nSAX 1.0\n\nVersion 1.0 of the Simple API for XML (SAX), created collectively by the membership of the XML-DEV mailing list, is hereby released into the public domain.\n\nNo one owns SAX: you may use it freely in both commercial and non-commercial applications, bundle it with your software distribution, include it on a CD-ROM, list the source code in a book, mirror the documentation at your own web site, or use it in any other way you see fit.\n\nDavid Megginson, Megginson Technologies Ltd.\n\n1998-05-11\n\nSAX 2.0\n\nI hereby abandon any property rights to SAX 2.0 (the Simple API for XML), and release all of the SAX 2.0 source code, compiled code, and documentation contained in this distribution into the Public Domain. SAX comes with NO WARRANTY or guarantee of fitness for any purpose.\n\nDavid Megginson, Megginson Technologies Ltd.\n\n2000-05-05"],"licenseIds":["SAX-PD"],"keywords":["copyright status sax","status sax is","sax is free","is free in","free in fact","in fact it","fact it s","it s not","s not possible","possible to own","to own a","own a license","license to sax","to sax since","sax since it","since it s","it s been","s been placed","been placed in","domain no warranty","warranty because sax","because sax is","sax is released","is released to","released to the","domain there is","for the design","the design or","design or for","the software implementation","software implementation to","implementation to the","parties provide sax","provide sax as","sax as is","performance of sax","of sax is","sax is with","you should sax","should sax prove","sax prove defective","or redistribute sax","redistribute sax be","sax be liable","to use sax","use sax including","sax including but","the sax to","sax to operate","such damages copyright","damages copyright disclaimers","copyright disclaimers this","disclaimers this page","this page includes","page includes statements","includes statements to","statements to that","to that effect","that effect by","effect by david","by david megginson","david megginson who","megginson who would","who would have","have been able","been able to","able to claim","to claim copyright","claim copyright for","copyright for the","original work sax","work sax 1","sax 1 0","1 0 version","0 version 1","of the simple","for xml sax","xml sax created","sax created collectively","created collectively by","collectively by the","by the membership","the membership of","membership of the","of the xml","the xml dev","xml dev mailing","dev mailing list","mailing list is","list is hereby","is hereby released","hereby released into","domain no one","no one owns","one owns sax","owns sax you","sax you may","use it freely","it freely in","freely in both","in both commercial","non commercial applications","commercial applications bundle","applications bundle it","bundle it with","it with your","with your software","your software distribution","software distribution include","distribution include it","include it on","on a cd","cd rom list","rom list the","list the source","a book mirror","book mirror the","mirror the documentation","the documentation at","documentation at your","your own web","own web site","web site or","site or use","or use it","other way you","way you see","you see fit","see fit david","fit david megginson","technologies ltd 1998","ltd 1998 05","1998 05 11","05 11 sax","11 sax 2","2 0 i","0 i hereby","i hereby abandon","hereby abandon any","abandon any property","any property rights","rights to sax","to sax 2","0 the simple","for xml and","xml and release","and release all","release all of","the sax 2","source code compiled","code compiled code","compiled code and","and documentation contained","documentation contained in","this distribution into","distribution into the","public domain sax","domain sax comes","sax comes with","comes with no","any purpose david","purpose david megginson","technologies ltd 2000","ltd 2000 05","2000 05 05","copyright status sax is","status sax is free","sax is free in","is free in fact","free in fact it","in fact it s","fact it s not","it s not possible","s not possible to","not possible to own","possible to own a","to own a license","own a license to","a license to sax","license to sax since","to sax since it","sax since it s","since it s been","it s been placed","s been placed in","been placed in the","public domain no warranty","domain no warranty because","no warranty because sax","warranty because sax is","because sax is released","sax is released to","is released to the","released to the public","public domain there is","domain there is no","warranty for the design","for the design or","the design or for","design or for the"]},{"licenseTexts":["SCEA Shared Source License 1.0\n\nTerms and Conditions:\n\n   1. Definitions:\n\n   \"Software\" shall mean the software and related documentation, whether in Source or Object Form, made available under this SCEA Shared Source license (\"License\"), that is indicated by a copyright notice file included in the source files or attached or accompanying the source files.\n\n   \"Licensor\" shall mean Sony Computer Entertainment America, Inc. (herein \"SCEA\")\n\n   \"Object Code\" or \"Object Form\" shall mean any form that results from translation or transformation of Source Code, including but not limited to compiled object code or conversions to other forms intended for machine execution.\n\n   \"Source Code\" or \"Source Form\" shall have the plain meaning generally accepted in the software industry, including but not limited to software source code, documentation source, header and configuration files.\n\n   \"You\" or \"Your\" shall mean you as an individual or as a company, or whichever form under which you are exercising rights under this License.\n\n   2. License Grant.\n\n   Licensor hereby grants to You, free of charge subject to the terms and conditions of this License, an irrevocable, non-exclusive, worldwide, perpetual, and royalty-free license to use, modify, reproduce, distribute, publicly perform or display the Software in Object or Source Form .\n\n   3. No Right to File for Patent.\n\n   In exchange for the rights that are granted to You free of charge under this License, You agree that You will not file for any patent application, seek copyright protection or take any other action that might otherwise impair the ownership rights in and to the Software that may belong to SCEA or any of the other contributors/authors of the Software.\n\n   4. Contributions.\n\n   SCEA welcomes contributions in form of modifications, optimizations, tools or documentation designed to improve or expand the performance and scope of the Software (collectively \"Contributions\"). Per the terms of this License You are free to modify the Software and those modifications would belong to You. You may however wish to donate Your Contributions to SCEA for consideration for inclusion into the Software. For the avoidance of doubt, if You elect to send Your Contributions to SCEA, You are doing so voluntarily and are giving the Contributions to SCEA and its parent company Sony Computer Entertainment, Inc., free of charge, to use, modify or distribute in any form or in any manner. SCEA acknowledges that if You make a donation of Your Contributions to SCEA, such Contributions shall not exclusively belong to SCEA or its parent company and such donation shall not be to Your exclusion. SCEA, in its sole discretion, shall determine whether or not to include Your donated Contributions into the Software, in whole, in part, or as modified by SCEA. Should SCEA elect to include any such Contributions into the Software, it shall do so at its own risk and may elect to give credit or special thanks to any such contributors in the attached copyright notice. However, if any of Your contributions are included into the Software, they will become part of the Software and will be distributed under the terms and conditions of this License. Further, if Your donated Contributions are integrated into the Software then Sony Computer Entertainment, Inc. shall become the copyright owner of the Software now containing Your contributions and SCEA would be the Licensor.\n\n   5. Redistribution in Source Form\n\n   You may redistribute copies of the Software, modifications or derivatives thereof in Source Code Form, provided that You:\n\n      a. Include a copy of this License and any copyright notices with source\n\n      b. Identify modifications if any were made to the Software\n\n      c. Include a copy of all documentation accompanying the Software and modifications made by You\n\n   6. Redistribution in Object Form\n\n   If You redistribute copies of the Software, modifications or derivatives thereof in Object Form only (as incorporated into finished goods, i.e. end user applications) then You will not have a duty to include any copies of the code, this License, copyright notices, other attributions or documentation.\n\n   7. No Warranty\n\n   THE SOFTWARE IS PROVIDED ON AN \"AS IS\" BASIS, WITHOUT ANY REPRESENTATIONS OR WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE. YOU ARE SOLELY RESPONSIBLE FOR DETERMINING THE APPROPRIATENESS OF USING, MODIFYING OR REDISTRIBUTING THE SOFTWARE AND ASSUME ANY RISKS ASSOCIATED WITH YOUR EXERCISE OF PERMISSIONS UNDER THIS LICENSE.\n\n   8. Limitation of Liability\n\n   UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY WILL EITHER PARTY BE LIABLE TO THE OTHER PARTY OR ANY THIRD PARTY FOR ANY DIRECT, INDIRECT, CONSEQUENTIAL, SPECIAL, INCIDENTAL, OR EXEMPLARY DAMAGES WITH RESPECT TO ANY INJURY, LOSS, OR DAMAGE, ARISING UNDER OR IN CONNECTION WITH THIS LETTER AGREEMENT, WHETHER FORESEEABLE OR UNFORESEEABLE, EVEN IF SUCH PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH INJURY, LOSS, OR DAMAGE. THE LIMITATIONS OF LIABILITY SET FORTH IN THIS SECTION SHALL APPLY TO THE FULLEST EXTENT PERMISSIBLE AT LAW OR ANY GOVERMENTAL REGULATIONS.\n\n   9. Governing Law and Consent to Jurisdiction\n\n   This Agreement shall be governed by and interpreted in accordance with the laws of the State of California, excluding that body of law related to choice of laws, and of the United States of America. Any action or proceeding brought to enforce the terms of this Agreement or to adjudicate any dispute arising hereunder shall be brought in the Superior Court of the County of San Mateo, State of California or the United States District Court for the Northern District of California. Each of the parties hereby submits itself to the exclusive jurisdiction and venue of such courts for purposes of any such action. In addition, each party hereby waives the right to a jury trial in any action or proceeding related to this Agreement.\n\n   10. Copyright Notice for Redistribution of Source Code\n\nCopyright 2005 Sony Computer Entertainment Inc.\n\nLicensed under the SCEA Shared Source License, Version 1.0 (the \"License\"); you may not use this file except in compliance with the License. You may obtain a copy of the License at:\n\nhttp://research.scea.com/scea_shared_source_license.html\n\nUnless required by applicable law or agreed to in writing, software distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License."],"licenseIds":["SCEA"],"keywords":["1 0 terms","1 definitions software","definitions software shall","mean the software","related documentation whether","under this scea","this scea shared","license license that","that is indicated","is indicated by","copyright notice file","notice file included","file included in","source files or","files or attached","or attached or","attached or accompanying","or accompanying the","accompanying the source","source files licensor","files licensor shall","shall mean sony","mean sony computer","computer entertainment america","entertainment america inc","america inc herein","inc herein scea","herein scea object","scea object code","any form that","results from translation","from translation or","translation or transformation","or transformation of","transformation of source","code or conversions","or conversions to","to other forms","other forms intended","forms intended for","intended for machine","for machine execution","machine execution source","execution source code","code or source","form shall have","have the plain","the plain meaning","plain meaning generally","meaning generally accepted","the software industry","software industry including","industry including but","documentation source header","source header and","header and configuration","configuration files you","files you or","shall mean you","mean you as","as an individual","individual or as","as a company","company or whichever","or whichever form","whichever form under","form under which","you are exercising","are exercising rights","license 2 license","of charge subject","charge subject to","license an irrevocable","worldwide perpetual and","perpetual and royalty","use modify reproduce","modify reproduce distribute","reproduce distribute publicly","distribute publicly perform","perform or display","in object or","object or source","source form 3","form 3 no","3 no right","right to file","to file for","file for patent","for patent in","patent in exchange","exchange for the","that are granted","of charge under","charge under this","will not file","not file for","file for any","for any patent","any patent application","patent application seek","application seek copyright","seek copyright protection","copyright protection or","protection or take","or take any","take any other","any other action","other action that","action that might","that might otherwise","might otherwise impair","otherwise impair the","impair the ownership","the ownership rights","ownership rights in","that may belong","may belong to","scea or any","other contributors authors","contributors authors of","the software 4","software 4 contributions","4 contributions scea","contributions scea welcomes","scea welcomes contributions","welcomes contributions in","contributions in form","in form of","form of modifications","of modifications optimizations","modifications optimizations tools","optimizations tools or","tools or documentation","or documentation designed","documentation designed to","designed to improve","to improve or","improve or expand","or expand the","expand the performance","performance and scope","the software collectively","software collectively contributions","collectively contributions per","contributions per the","per the terms","free to modify","software and those","those modifications would","modifications would belong","would belong to","belong to you","to you you","you you may","you may however","may however wish","however wish to","wish to donate","to donate your","donate your contributions","to scea for","scea for consideration","for consideration for","consideration for inclusion","for inclusion into","inclusion into the","of doubt if","doubt if you","if you elect","you elect to","elect to send","to send your","send your contributions","to scea you","scea you are","you are doing","are doing so","doing so voluntarily","so voluntarily and","voluntarily and are","and are giving","are giving the","giving the contributions","the contributions to","to scea and","scea and its","and its parent","parent company sony","company sony computer","entertainment inc free","inc free of","charge to use","or distribute in","distribute in any","form or in","any manner scea","manner scea acknowledges","scea acknowledges that","acknowledges that if","make a donation"]},{"licenseTexts":["SGI FREE SOFTWARE LICENSE B\n\n(Version 1.0 1/25/2000)\n\n   1. Definitions.\n\n      1.1 \"Additional Notice Provisions\" means such additional provisions as appear in the Notice in Original Code under the heading \"Additional Notice Provisions.\"\n\n      1.2 \"API\" means an application programming interface established by SGI in conjunction with the Original Code.\n\n      1.3 \"Covered Code\" means the Original Code or Modifications or the combination of the Original Code and Modifications, in each case including portions thereof.\n\n      1.4 \"Hardware\" means any physical device that accepts input, processes input, stores the results of processing, and/or provides output.\n\n      1.5 \"Larger Work\" means a work which combines Covered Code or portions thereof with code not governed by the terms of this License.\n\n      1.6 \"Licensable\" means having the right to grant, to the maximum extent possible, whether at the time of the initial grant or subsequently acquired, any and all of the rights conveyed herein.\n\n      1.7 \"License\" means this document.\n\n      1.8 \"Modifications\" means any addition to the substance or structure of the Original Code and/or any addition to or deletion from previous Modifications. When Covered Code is released as a series of files, a Modification is:\n\n         A. Any addition to the contents of a file containing Original Code and/or any addition to or deletion from previous Modifications.\n\n         B. Any new file that contains any part of the Original Code or previous Modifications.\n\n      1.9 \"Notice\" means any notice in Original Code or Covered Code, as required by and in compliance with this License.\n\n      1.10 \"Original Code\" means source code of computer software code which is described in the source code Notice required by Exhibit A as Original Code, and updates and error corrections specifically thereto.\n\n      1.11 \"Recipient\" means an individual or a legal entity exercising rights under, and complying with all of the terms of, this License or a future version of this License issued under Section 8. For legal entities, \"Recipient\" includes any entity which controls, is controlled by, or is under common control with Recipient. For purposes of this definition, \"control\" of an entity means (a) the power, direct or indirect, to direct or manage such entity, or (b) ownership of fifty percent (50%) or more of the outstanding shares or beneficial ownership of such entity.\n\n      1.12 SGI\" means Silicon Graphics, Inc.\n\n   2. License Grant and Restrictions.\n\n      2.1 License Grant. Subject to the provisions of this License and any third party intellectual property claims, for the duration of intellectual property protections inherent in the Original Code, SGI hereby grants Recipient a worldwide, royalty-free, non-exclusive license, to do the following: (i) under copyrights Licensable by SGI, to reproduce, distribute, create derivative works from, and, to the extent applicable, display and perform the Original Code alone and/or as part of a Larger Work; and (ii) under any patent claims Licensable by SGI and embodied in the Original Code, to make, have made, use, practice, sell, and offer for sale, and/or otherwise dispose of the Original Code. Recipient accepts the terms and conditions of this License by undertaking any of the aforementioned actions.\n\n      2.2 Restriction on Patent License. Notwithstanding the provisions of Section 2.1(ii), no patent license is granted: 1) separate from the Original Code; nor 2) for infringements caused by (i) modification of the Original Code, or (ii) the combination of the Original Code with other software or Hardware.\n\n      2.3 No License For Hardware Implementations. The licenses granted in Section 2.1 are not applicable to implementation in Hardware of the algorithms embodied in the Original Code.\n\n      2.4 Modifications License and API Compliance. Modifications are only licensed under Section 2.1(i) to the extent such Modifications are fully compliant with any API as may be identified in Additional Notice Provisions as appear in the Original Code.\n\n   3. Redistributions.\n\n      A. Retention of Notice/Copy of License. The Notice set forth in Exhibit A, below, must be conspicuously retained or included in any and all redistributions of Covered Code. For distributions of the Covered Code in source code form, the Notice must appear in every file that can include a text comments field; in executable form, the Notice and a copy of this License must appear in related documentation or collateral where the Recipient's rights relating to Covered Code are described. Any Additional Notice Provisions which actually appears in the Original Code must also be retained or included in any and all redistributions of Covered Code.\n\n      B. Alternative License. Provided that Recipient is in compliance with the terms of this License, Recipient may distribute the source code and/or executable version(s) of Covered Code under (1) this License; (2) a license identical to this License but for only such changes as are necessary in order to clarify Recipient's role as licensor of Modifications, without derogation of any of SGI's rights; and/or (3) a license of Recipient's choosing, containing terms different from this License, provided that the license terms include this Section 3 and Sections 4, 6, 7, 10, 12, and 13, which terms may not be modified or superseded by any other terms of such license. If Recipient elects to use any license other than this License, Recipient must make it absolutely clear that any of its terms which differ from this License are offered by Recipient alone, and not by SGI.\n\n      C. Indemnity. Recipient hereby agrees to indemnify SGI for any liability incurred by SGI as a result of any such alternative license terms Recipient offers.\n\n   4. Termination. This License and the rights granted hereunder will terminate automatically if Recipient breaches any term herein and fails to cure such breach within 30 days thereof. Any sublicense to the Covered Code that is properly granted shall survive any termination of this License, absent termination by the terms of such sublicense. Provisions that, by their nature, must remain in effect beyond the termination of this License, shall survive.\n\n   5. No Trademark Or Other Rights. This License does not grant any rights to: (i) any software apart from the Covered Code, nor shall any other rights or licenses not expressly granted hereunder arise by implication, estoppel or otherwise with respect to the Covered Code; (ii) any trade name, trademark or service mark whatsoever, including without limitation any related right for purposes of endorsement or promotion of products derived from the Covered Code, without prior written permission of SGI; or (iii) any title to or ownership of the Original Code, which shall at all times remains with SGI. All rights in the Original Code not expressly granted under this License are reserved.\n\n   6. Compliance with Laws; Non-Infringement. Recipient hereby assures that it shall comply with all applicable laws, regulations, and executive orders, in connection with any and all dispositions of Covered Code, including but not limited to, all export, re-export, and import control laws, regulations, and executive orders, of the U.S. government and other countries. Recipient may not distribute Covered Code that (i) in any way infringes (directly or contributorily) the rights (including patent, copyright, trade secret, trademark or other intellectual property rights of any kind) of any other person or entity or (ii) breaches any representation or warranty, express, implied or statutory, to which, under any applicable law, it might be deemed to have been subject.\n\n   7. Claims of Infringement. If Recipient learns of any third party claim that any disposition of Covered Code and/or functionality wholly or partially infringes the third party's intellectual property rights, Recipient will promptly notify SGI of such claim.\n\n   8. Versions of the License. SGI may publish revised and/or new versions of the License from time to time, each with a distinguishing version number. Once Covered Code has been published under a particular version of the License, Recipient may, for the duration of the license, continue to use it under the terms of that version, or choose to use such Covered Code under the terms of any subsequent version published by SGI. Subject to the provisions of Sections 3 and 4 of this License, only SGI may modify the terms applicable to Covered Code created under this License.\n\n   9. DISCLAIMER OF WARRANTY. COVERED CODE IS PROVIDED \"AS IS.\" ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS ARE DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT. SGI ASSUMES NO RISK AS TO THE QUALITY AND PERFORMANCE OF THE SOFTWARE. SHOULD THE SOFTWARE PROVE DEFECTIVE IN ANY RESPECT, SGI ASSUMES NO COST OR LIABILITY FOR SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY IS AN ESSENTIAL PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT SUBJECT TO THIS DISCLAIMER.\n\n   10. LIMITATION OF LIABILITY. UNDER NO CIRCUMSTANCES NOR LEGAL THEORY, WHETHER TORT (INCLUDING, WITHOUT LIMITATION, NEGLIGENCE OR STRICT LIABILITY), CONTRACT, OR OTHERWISE, SHALL SGI OR ANY SGI LICENSOR BE LIABLE FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, LOSS OF DATA, COMPUTER FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER COMMERCIAL DAMAGES OR LOSSES, EVEN IF SUCH PARTY SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF LIABILITY SHALL NOT APPLY TO LIABILITY FOR DEATH OR PERSONAL INJURY RESULTING FROM SGI's NEGLIGENCE TO THE EXTENT APPLICABLE LAW PROHIBITS SUCH LIMITATION. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OR LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THAT EXCLUSION AND LIMITATION MAY NOT APPLY TO RECIPIENT.\n\n   11. Indemnity. Recipient shall be solely responsible for damages arising, directly or indirectly, out of its utilization of rights under this License. Recipient will defend, indemnify and hold harmless Silicon Graphics, Inc. from and against any loss, liability, damages, costs or expenses (including the payment of reasonable attorneys fees) arising out of Recipient's use, modification, reproduction and distribution of the Covered Code or out of any representation or warranty made by Recipient.\n\n   12. U.S. Government End Users. The Covered Code is a \"commercial item\" consisting of \"commercial computer software\" as such terms are defined in title 48 of the Code of Federal Regulations and all U.S. Government End Users acquire only the rights set forth in this License and are subject to the terms of this License.\n\n   13. Miscellaneous. This License represents the complete agreement concerning the its subject matter. If any provision of this License is held to be unenforceable, such provision shall be reformed so as to achieve as nearly as possible the same legal and economic effect as the original provision and the remainder of this License will remain in effect. This License shall be governed by and construed in accordance with the laws of the United States and the State of California as applied to agreements entered into and to be performed entirely within California between California residents. Any litigation relating to this License shall be subject to the exclusive jurisdiction of the Federal Courts of the Northern District of California (or, absent subject matter jurisdiction in such courts, the courts of the State of California), with venue lying exclusively in Santa Clara County, California, with the losing party responsible for costs, including without limitation, court costs and reasonable attorneys fees and expenses. The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded. Any law or regulation which provides that the language of a contract shall be construed against the drafter shall not apply to this License. Exhibit A\n\nLicense Applicability. Except to the extent portions of this file are made subject to an alternative license as permitted in the SGI Free Software License B, Version 1.0 (the \"License\"), the contents of this file are subject only to the provisions of the License. You may not use this file except in compliance with the License. You may obtain a copy of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 Ampitheatre Parkway, Mountain View, CA 94043-1351, or at:\n\nhttp://oss.sgi.com/projects/FreeB\n\nNote that, as provided in the License, the Software is distributed on an \"AS IS\" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.\n\nOriginal Code. The Original Code is: [ name of software , version number , and release date], developed by Silicon Graphics, Inc. The Original Code is Copyright (c) [ dates of first publication, as appearing in the Notice in the Original Code] Silicon Graphics, Inc. Copyright in any portions created by third parties is as indicated elsewhere herein. All Rights Reserved.\n\nAdditional Notice Provisions: [ such additional provisions, if any, as appear in the Notice in the Original Code under the heading \"Additional Notice Provisions\"]"],"licenseIds":["SGI-B-1.0"],"keywords":["0 1 25","1 25 2000","25 2000 1","1 2 api","2 api means","api means an","programming interface established","interface established by","established by sgi","sgi in conjunction","1 4 hardware","4 hardware means","output 1 5","1 6 licensable","6 licensable means","herein 1 7","1 12 sgi","12 sgi means","graphics inc 2","inc 2 license","2 1 license","1 license grant","by sgi and","sgi and embodied","and embodied in","original code recipient","code recipient accepts","aforementioned actions 2","actions 2 2","2 2 restriction","2 restriction on","restriction on patent","patent license notwithstanding","notwithstanding the provisions","1 ii no","ii no patent","granted 1 separate","1 separate from","original code nor","code nor 2","nor 2 for","by i modification","i modification of","or hardware 2","hardware 2 3","2 1 are","1 are not","4 modifications license","modifications license and","license and api","and api compliance","api compliance modifications","compliance modifications are","modifications are only","are only licensed","only licensed under","licensed under section","2 1 i","1 i to","i to the","extent such modifications","such modifications are","modifications are fully","are fully compliant","fully compliant with","compliant with any","with any api","any api as","api as may","may be identified","be identified in","identified in additional","in additional notice","notice provisions as","original code 3","code 3 redistributions","3 redistributions a","redistributions a retention","a retention of","code b alternative","b alternative license","recipient may distribute","of modifications without","modifications without derogation","s rights and","rights and or","by sgi c","sgi c indemnity","c indemnity recipient","non infringement recipient","infringement recipient hereby","recipient hereby assures","hereby assures that","assures that it","it shall comply","shall comply with","executive orders in","orders in connection","and all dispositions","all dispositions of","all export re","other countries recipient","countries recipient may","or contributorily the","contributorily the rights","the rights including","rights including patent","including patent copyright","trade secret trademark","secret trademark or","services 1600 ampitheatre","1600 ampitheatre parkway","ampitheatre parkway mountain","1 0 1 25","0 1 25 2000","1 25 2000 1","25 2000 1 definitions","provisions 1 2 api","1 2 api means","2 api means an","api means an application","means an application programming","application programming interface established","programming interface established by","interface established by sgi","established by sgi in","by sgi in conjunction","sgi in conjunction with","conjunction with the original","the original code 1","thereof 1 4 hardware","1 4 hardware means","4 hardware means any","provides output 1 5","output 1 5 larger","license 1 6 licensable","1 6 licensable means","6 licensable means having","conveyed herein 1 7","herein 1 7 license","document 1 8 modifications","addition to the substance","from previous modifications when","from previous modifications b","entity 1 12 sgi","1 12 sgi means","12 sgi means silicon","silicon graphics inc 2","graphics inc 2 license","inc 2 license grant","restrictions 2 1 license","2 1 license grant","1 license grant subject","code alone and or","ii under any patent","under any patent claims","licensable by sgi and","by sgi and embodied","sgi and embodied in","and embodied in the","the original code recipient","original code recipient accepts","code recipient accepts the","the aforementioned actions 2","aforementioned actions 2 2","actions 2 2 restriction","2 2 restriction on","2 restriction on patent","restriction on patent license","on patent license notwithstanding","patent license notwithstanding the","license notwithstanding the provisions","notwithstanding the provisions of","provisions of section 2","2 1 ii no","1 ii no patent","ii no patent license","is granted 1 separate","granted 1 separate from","1 separate from the","the original code nor","original code nor 2","code nor 2 for","nor 2 for infringements","caused by i modification","by i modification of","i modification of the","software or hardware 2","or hardware 2 3","hardware 2 3 no","section 2 1 are","2 1 are not","1 are not applicable","original code 2 4","code 2 4 modifications","2 4 modifications license","4 modifications license and","modifications license and api","license and api compliance","and api compliance modifications"]},{"licenseTexts":["SGI FREE SOFTWARE LICENSE B\n\n(Version 1.1 02/22/2000)\n\n   1. Definitions.\n\n      1.1 \"Additional Notice Provisions\" means such additional provisions as appear in the Notice in Original Code under the heading \"Additional Notice Provisions.\"\n\n      1.2 \"Covered Code\" means the Original Code or Modifications, or any combination thereof.\n\n      1.3 \"Hardware\" means any physical device that accepts input, processes input, stores the results of processing, and/or provides output.\n\n      1.4 \"Larger Work\" means a work that combines Covered Code or portions thereof with code not governed by the terms of this License.\n\n      1.5 \"Licensable\" means having the right to grant, to the maximum extent possible, whether at the time of the initial grant or subsequently acquired, any and all of the rights conveyed herein.\n\n      1.6 \"License\" means this document.\n\n      1.7 \"Licensed Patents\" means patent claims Licensable by SGI that are infringed by the use or sale of Original Code or any Modifications provided by SGI, or any combination thereof.\n\n      1.8 \"Modifications\" means any addition to or deletion from the substance or structure of the Original Code or any previous Modifications. When Covered Code is released as a series of files, a Modification is:\n\n         A. Any addition to the contents of a file containing Original Code and/or addition to or deletion from the contents of a file containing previous Modifications.\n\n         B. Any new file that contains any part of the Original Code or previous Modifications.\n\n      1.9 \"Notice\" means any notice in Original Code or Covered Code, as required by and in compliance with this License.\n\n      1.10 \"Original Code\" means source code of computer software code that is described in the source code Notice required by Exhibit A as Original Code, and updates and error corrections specifically thereto.\n\n      1.11 \"Recipient\" means an individual or a legal entity exercising rights under, and complying with all of the terms of, this License or a future version of this License issued under Section 8. For legal entities, \"Recipient\" includes any entity that controls, is controlled by, or is under common control with Recipient. For purposes of this definition, \"control\" of an entity means (a) the power, direct or indirect, to direct or manage such entity, or (b) ownership of fifty percent (50%) or more of the outstanding shares or beneficial ownership of such entity.\n\n      1.12 \"Recipient Patents\" means patent claims Licensable by a Recipient that are infringed by the use or sale of Original Code or any Modifications provided by SGI, or any combination thereof.\n\n      1.13 \"SGI\" means Silicon Graphics, Inc.\n\n      1.14 \"SGI Patents\" means patent claims Licensable by SGI other than the Licensed Patents.\n\n   2. License Grant and Restrictions.\n\n      2.1 SGI License Grant. Subject to the terms of this License and any third party intellectual property claims, for the duration of intellectual property protections inherent in the Original Code, SGI hereby grants Recipient a worldwide, royalty-free, non-exclusive license, to do the following: (i) under copyrights Licensable by SGI, to reproduce, distribute, create derivative works from, and, to the extent applicable, display and perform the Original Code and/or any Modifications provided by SGI alone and/or as part of a Larger Work; and (ii) under any Licensable Patents, to make, have made, use, sell, offer for sale, import and/or otherwise transfer the Original Code and/or any Modifications provided by SGI. Recipient accepts the terms and conditions of this License by undertaking any of the aforementioned actions. The patent license shall apply to the Covered Code if, at the time any related Modification is added, such addition of the Modification causes such combination to be covered by the Licensed Patents. The patent license in Section 2.1(ii) shall not apply to any other combinations that include the Modification. No patent license is provided under SGI Patents for infringements of SGI Patents by Modifications not provided by SGI or combinations of Original Code and Modifications not provided by SGI.\n\n      2.2 Recipient License Grant. Subject to the terms of this License and any third party intellectual property claims, Recipient hereby grants SGI and any other Recipients a worldwide, royalty-free, non-exclusive license, under any Recipient Patents, to make, have made, use, sell, offer for sale, import and/or otherwise transfer the Original Code and/or any Modifications provided by SGI.\n\n      2.3 No License For Hardware Implementations. The licenses granted in Section 2.1 and 2.2 are not applicable to implementation in Hardware of the algorithms embodied in the Original Code or any Modifications provided by SGI .\n\n   3. Redistributions.\n\n      3.1 Retention of Notice/Copy of License. The Notice set forth in Exhibit A, below, must be conspicuously retained or included in any and all redistributions of Covered Code. For distributions of the Covered Code in source code form, the Notice must appear in every file that can include a text comments field; in executable form, the Notice and a copy of this License must appear in related documentation or collateral where the Recipient's rights relating to Covered Code are described. Any Additional Notice Provisions which actually appears in the Original Code must also be retained or included in any and all redistributions of Covered Code.\n\n      3.2 Alternative License. Provided that Recipient is in compliance with the terms of this License, Recipient may, so long as without derogation of any of SGI's rights in and to the Original Code, distribute the source code and/or executable version(s) of Covered Code under (1) this License; (2) a license identical to this License but for only such changes as are necessary in order to clarify Recipient's role as licensor of Modifications; and/or (3) a license of Recipient's choosing, containing terms different from this License, provided that the license terms include this Section 3 and Sections 4, 6, 7, 10, 12, and 13, which terms may not be modified or superseded by any other terms of such license. If Recipient elects to use any license other than this License, Recipient must make it absolutely clear that any of its terms which differ from this License are offered by Recipient alone, and not by SGI. It is emphasized that this License is a limited license, and, regardless of the license form employed by Recipient in accordance with this Section 3.2, Recipient may relicense only such rights, in Original Code and Modifications by SGI, as it has actually been granted by SGI in this License.\n\n      3.3 Indemnity. Recipient hereby agrees to indemnify SGI for any liability incurred by SGI as a result of any such alternative license terms Recipient offers.\n\n   4. Termination. This License and the rights granted hereunder will terminate automatically if Recipient breaches any term herein and fails to cure such breach within 30 days thereof. Any sublicense to the Covered Code that is properly granted shall survive any termination of this License, absent termination by the terms of such sublicense. Provisions that, by their nature, must remain in effect beyond the termination of this License, shall survive.\n\n   5. No Trademark Or Other Rights. This License does not grant any rights to: (i) any software apart from the Covered Code, nor shall any other rights or licenses not expressly granted hereunder arise by implication, estoppel or otherwise with respect to the Covered Code; (ii) any trade name, trademark or service mark whatsoever, including without limitation any related right for purposes of endorsement or promotion of products derived from the Covered Code, without prior written permission of SGI; or (iii) any title to or ownership of the Original Code, which shall at all times remains with SGI. All rights in the Original Code not expressly granted under this License are reserved.\n\n   6. Compliance with Laws; Non-Infringement. There are various worldwide laws, regulations, and executive orders applicable to dispositions of Covered Code, including without limitation export, re-export, and import control laws, regulations, and executive orders, of the U.S. government and other countries, and Recipient is reminded it is obliged to obey such laws, regulations, and executive orders. Recipient may not distribute Covered Code that (i) in any way infringes (directly or contributorily) any intellectual property rights of any kind of any other person or entity or (ii) breaches any representation or warranty, express, implied or statutory, to which, under any applicable law, it might be deemed to have been subject.\n\n   7. Claims of Infringement. If Recipient learns of any third party claim that any disposition of Covered Code and/or functionality wholly or partially infringes the third party's intellectual property rights, Recipient will promptly notify SGI of such claim.\n\n   8. Versions of the License. SGI may publish revised and/or new versions of the License from time to time, each with a distinguishing version number. Once Covered Code has been published under a particular version of the License, Recipient may, for the duration of the license, continue to use it under the terms of that version, or choose to use such Covered Code under the terms of any subsequent version published by SGI. Subject to the provisions of Sections 3 and 4 of this License, only SGI may modify the terms applicable to Covered Code created under this License.\n\n   9. DISCLAIMER OF WARRANTY. COVERED CODE IS PROVIDED \"AS IS.\" ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS ARE DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT. SGI ASSUMES NO RISK AS TO THE QUALITY AND PERFORMANCE OF THE SOFTWARE. SHOULD THE SOFTWARE PROVE DEFECTIVE IN ANY RESPECT, SGI ASSUMES NO COST OR LIABILITY FOR SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY IS AN ESSENTIAL PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT SUBJECT TO THIS DISCLAIMER.\n\n   10. LIMITATION OF LIABILITY. UNDER NO CIRCUMSTANCES NOR LEGAL THEORY, WHETHER TORT (INCLUDING, WITHOUT LIMITATION, NEGLIGENCE OR STRICT LIABILITY), CONTRACT, OR OTHERWISE, SHALL SGI OR ANY SGI LICENSOR BE LIABLE FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, LOSS OF DATA, COMPUTER FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER COMMERCIAL DAMAGES OR LOSSES, EVEN IF SUCH PARTY SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF LIABILITY SHALL NOT APPLY TO LIABILITY FOR DEATH OR PERSONAL INJURY RESULTING FROM SGI's NEGLIGENCE TO THE EXTENT APPLICABLE LAW PROHIBITS SUCH LIMITATION. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OR LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THAT EXCLUSION AND LIMITATION MAY NOT APPLY TO RECIPIENT.\n\n   11. Indemnity. Recipient shall be solely responsible for damages arising, directly or indirectly, out of its utilization of rights under this License. Recipient will defend, indemnify and hold harmless Silicon Graphics, Inc. from and against any loss, liability, damages, costs or expenses (including the payment of reasonable attorneys fees) arising out of Recipient's use, modification, reproduction and distribution of the Covered Code or out of any representation or warranty made by Recipient.\n\n   12. U.S. Government End Users. The Covered Code is a \"commercial item\" consisting of \"commercial computer software\" as such terms are defined in title 48 of the Code of Federal Regulations and all U.S. Government End Users acquire only the rights set forth in this License and are subject to the terms of this License.\n\n   13. Miscellaneous. This License represents the complete agreement concerning the its subject matter. If any provision of this License is held to be unenforceable, such provision shall be reformed so as to achieve as nearly as possible the same legal and economic effect as the original provision and the remainder of this License will remain in effect. This License shall be governed by and construed in accordance with the laws of the United States and the State of California as applied to agreements entered into and to be performed entirely within California between California residents. Any litigation relating to this License shall be subject to the exclusive jurisdiction of the Federal Courts of the Northern District of California (or, absent subject matter jurisdiction in such courts, the courts of the State of California), with venue lying exclusively in Santa Clara County, California, with the losing party responsible for costs, including without limitation, court costs and reasonable attorneys fees and expenses. The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded. Any law or regulation that provides that the language of a contract shall be construed against the drafter shall not apply to this License. Exhibit A\n\nLicense Applicability. Except to the extent portions of this file are made subject to an alternative license as permitted in the SGI Free Software License B, Version 1.1 (the \"License\"), the contents of this file are subject only to the provisions of the License. You may not use this file except in compliance with the License. You may obtain a copy of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:\n\nhttp://oss.sgi.com/projects/FreeB\n\nNote that, as provided in the License, the Software is distributed on an \"AS IS\" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.\n\nOriginal Code. The Original Code is: [ name of software , version number , and release date] , developed by Silicon Graphics, Inc. The Original Code is Copyright (c) [ dates of first publication, as appearing in the Notice in the Original Code] Silicon Graphics, Inc. Copyright in any portions created by third parties is as indicated elsewhere herein. All Rights Reserved. Additional Notice Provisions: [ such additional provisions, if any, as appear in the Notice in the Original Code under the heading \"Additional Notice Provisions\"] "],"licenseIds":["SGI-B-1.1"],"keywords":["1 1 02","1 02 22","02 22 2000","22 2000 1","1 3 hardware","3 hardware means","output 1 4","1 5 licensable","5 licensable means","herein 1 6","document 1 7","7 licensed patents","by sgi that","sgi that are","thereof 1 8","file containing previous","containing previous modifications","that is described","1 12 recipient","12 recipient patents","recipient patents means","recipient that are","thereof 1 13","1 13 sgi","13 sgi means","graphics inc 1","inc 1 14","1 14 sgi","14 sgi patents","sgi patents means","by sgi other","sgi other than","licensed patents 2","patents 2 license","2 1 sgi","1 sgi license","sgi license grant","by sgi alone","sgi alone and","under any licensable","any licensable patents","licensable patents to","by sgi recipient","sgi recipient accepts","aforementioned actions the","actions the patent","code if at","the time any","time any related","any related modification","related modification is","the modification causes","modification causes such","patent license in","license in section","1 ii shall","ii shall not","include the modification","the modification no","modification no patent","provided under sgi","under sgi patents","sgi patents for","patents for infringements","for infringements of","infringements of sgi","of sgi patents","sgi patents by","patents by modifications","by modifications not","sgi or combinations","combinations of original","and modifications not","sgi 2 2","2 2 recipient","2 recipient license","recipient license grant","property claims recipient","claims recipient hereby","recipient hereby grants","hereby grants sgi","grants sgi and","sgi and any","other recipients a","recipients a worldwide","under any recipient","any recipient patents","recipient patents to","sgi 2 3","2 2 are","by sgi 3","sgi 3 redistributions","3 redistributions 3","redistributions 3 1","3 1 retention","1 retention of","3 2 alternative","2 alternative license","recipient may so","may so long","long as without","as without derogation","original code distribute","code distribute the","by sgi it","sgi it is","it is emphasized","is emphasized that","emphasized that this","is a limited","a limited license","limited license and","license and regardless","the license form","license form employed","form employed by","employed by recipient","recipient in accordance","3 2 recipient","recipient may relicense","may relicense only","relicense only such","only such rights","rights in original","and modifications by","modifications by sgi","sgi as it","as it has","it has actually","has actually been","actually been granted","been granted by","granted by sgi","sgi in this","3 3 indemnity","3 indemnity recipient","non infringement there","infringement there are","there are various","are various worldwide","various worldwide laws","worldwide laws regulations","executive orders applicable","orders applicable to","applicable to dispositions","to dispositions of","code including without","without limitation export","limitation export re","countries and recipient","and recipient is","recipient is reminded","is reminded it","reminded it is","it is obliged","is obliged to","obliged to obey","to obey such","obey such laws","such laws regulations","executive orders recipient","orders recipient may","or contributorily any","contributorily any intellectual","services 1600 amphitheatre","1600 amphitheatre parkway","amphitheatre parkway mountain","version 1 1 02","1 1 02 22","1 02 22 2000","02 22 2000 1","22 2000 1 definitions","provisions 1 2 covered","or modifications or any","combination thereof 1 3","thereof 1 3 hardware","1 3 hardware means","3 hardware means any","provides output 1 4","output 1 4 larger","that combines covered code","license 1 5 licensable","1 5 licensable means","5 licensable means having","conveyed herein 1 6","herein 1 6 license","this document 1 7","document 1 7 licensed","1 7 licensed patents","7 licensed patents means","licensed patents means patent","licensable by sgi that","by sgi that are","sgi that are infringed","combination thereof 1 8","thereof 1 8 modifications","code and or addition","or addition to or","a file containing previous","file containing previous modifications"]},{"licenseTexts":["SGI FREE SOFTWARE LICENSE B\n\n(Version 2.0, Sept. 18, 2008) Copyright (C) [dates of first publication] Silicon Graphics, Inc. All Rights Reserved.\n\nPermission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the \"Software\"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:\n\nThe above copyright notice including the dates of first publication and either this permission notice or a reference to http://oss.sgi.com/projects/FreeB/ shall be included in all copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nExcept as contained in this notice, the name of Silicon Graphics, Inc. shall not be used in advertising or otherwise to promote the sale, use or other dealings in this Software without prior written authorization from Silicon Graphics, Inc."],"licenseIds":["SGI-B-2.0"],"keywords":["b version 2","2 0 sept","0 sept 18","sept 18 2008","18 2008 copyright","first publication silicon","publication silicon graphics","graphics inc all","including the dates","first publication and","publication and either","either this permission","notice or a","or a reference","reference to http","to http oss","projects freeb shall","freeb shall be","event shall silicon","shall silicon graphics","graphics inc be","name of silicon","of silicon graphics","graphics inc shall","authorization from silicon","from silicon graphics","license b version 2","b version 2 0","version 2 0 sept","2 0 sept 18","0 sept 18 2008","sept 18 2008 copyright","18 2008 copyright c","2008 copyright c dates","of first publication silicon","first publication silicon graphics","publication silicon graphics inc","silicon graphics inc all","graphics inc all rights","above copyright notice including","notice including the dates","including the dates of","the dates of first","of first publication and","first publication and either","publication and either this","and either this permission","either this permission notice","this permission notice or","permission notice or a","notice or a reference","or a reference to","a reference to http","reference to http oss","to http oss sgi","com projects freeb shall","projects freeb shall be","freeb shall be included","no event shall silicon","event shall silicon graphics","shall silicon graphics inc","silicon graphics inc be","graphics inc be liable","the name of silicon","name of silicon graphics","of silicon graphics inc","silicon graphics inc shall","graphics inc shall not","written authorization from silicon","authorization from silicon graphics","from silicon graphics inc","software license b version 2","license b version 2 0","b version 2 0 sept","version 2 0 sept 18","2 0 sept 18 2008","0 sept 18 2008 copyright","sept 18 2008 copyright c","18 2008 copyright c dates","2008 copyright c dates of","dates of first publication silicon","of first publication silicon graphics","first publication silicon graphics inc","publication silicon graphics inc all","silicon graphics inc all rights","graphics inc all rights reserved","the above copyright notice including","above copyright notice including the","copyright notice including the dates","notice including the dates of","including the dates of first","the dates of first publication","dates of first publication and","of first publication and either","first publication and either this","publication and either this permission","and either this permission notice","either this permission notice or","this permission notice or a","permission notice or a reference","notice or a reference to","or a reference to http","a reference to http oss","reference to http oss sgi","to http oss sgi com","sgi com projects freeb shall","com projects freeb shall be","projects freeb shall be included","freeb shall be included in","in no event shall silicon","no event shall silicon graphics","event shall silicon graphics inc","shall silicon graphics inc be","silicon graphics inc be liable","graphics inc be liable for","notice the name of silicon","the name of silicon graphics","name of silicon graphics inc","of silicon graphics inc shall","silicon graphics inc shall not","graphics inc shall not be","prior written authorization from silicon","written authorization from silicon graphics","authorization from silicon graphics inc"]},{"licenseTexts":["SOLDERPAD HARDWARE LICENSE version 0.5\n\nThis license is based closely on the Apache License Version 2.0, but is not approved or endorsed by the Apache Foundation. A copy of the non-modified Apache License 2.0 can be found at http://www.apache.org/licenses/LICENSE-2.0.\n\n\n\nAs this license is not currently OSI or FSF approved, the Licensor permits any Work licensed under this License, at the option of the Licensee, to be treated as licensed under the Apache License Version 2.0 (which is so approved).\n\n\n\nThis License is licensed under the terms of this License and in particular clause 7 below (Disclaimer of Warranties) applies in relation to its use.\n\n\n\nTERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n\n\n1. Definitions.\n\n\n\n\"License\" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.\n\n\n\n\"Licensor\" shall mean the Rights owner or entity authorized by the Rights owner that is granting the License.\n\n\n\n\"Legal Entity\" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, \"control\" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.\n\n\n\n\"You\" (or \"Your\") shall mean an individual or Legal Entity exercising permissions granted by this License.\n\n\n\n\"Rights\" means copyright and any similar right including design right (whether registered or unregistered), semiconductor topography (mask) rights and database extraction rights (but excluding Patents and Trademarks).\n\n\n\n\"Source\" form shall mean the preferred form for making modifications, including but not limited to source code, net lists, board layouts, CAD files, documentation source, and configuration files.\n\n\n\n\"Object\" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, the instantiation of a hardware design and conversions to other media types, including intermediate forms such as bytecodes, FPGA bitstreams, artwork and semiconductor topographies (mask works).\n\n\n\n\"Work\" shall mean the work of authorship, whether in Source form or other Object form, made available under the License, as indicated by a Rights notice that is included in or attached to the work (an example is provided in the Appendix below).\n\n\n\n\"Derivative Works\" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) or physically connect to or interoperate with the interfaces of, the Work and Derivative Works thereof.\n\n\n\n\"Contribution\" shall mean any design or work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the Rights owner or by an individual or Legal Entity authorized to submit on behalf of the Rights owner. For the purposes of this definition, \"submitted\" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the Rights owner as \"Not a Contribution.\"\n\n\n\n\"Contributor\" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.\n\n\n\n2. Grant of License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable license under the Rights to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form and do anything in relation to the Work as if the Rights did not exist.\n\n\n\n3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.\n\n\n\n4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:\n\n\n\nYou must give any other recipients of the Work or Derivative Works a copy of this License; and\n\n\n\nYou must cause any modified files to carry prominent notices stating that You changed the files; and\n\n\n\nYou must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and\n\n\n\nIf the Work includes a \"NOTICE\" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.\n\n\n\n5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.\n\n\n\n6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.\n\n\n\n7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.\n\n\n\n8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.\n\n\n\n9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.\n\n\n\nEND OF TERMS AND CONDITIONS\n\n\n\nAPPENDIX: How to apply this license to your work\n\nTo apply this license to your work, attach the following boilerplate notice, with the fields enclosed by brackets \"[]\" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same \"printed page\" as the copyright notice for easier identification within third-party archives.\n\n\n\nCopyright [yyyy] [name of copyright owner] Copyright and related rights are licensed under the Solderpad Hardware License, Version 0.5 (the \"License\"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://solderpad.org/licenses/SHL-0.5. Unless required by applicable law or agreed to in writing, software, hardware and materials distributed under this License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License."],"licenseIds":["SHL-0.5"],"keywords":["0 5 this","and database extraction","database extraction rights","extraction rights but","following conditions you","conditions you must","files and you","works and if","0 5 the","5 the license","shl 0 5","0 5 unless","5 unless required","version 0 5 this","0 5 this license","5 this license is","rights and database extraction","and database extraction rights","database extraction rights but","extraction rights but excluding","the following conditions you","following conditions you must","conditions you must give","and you must cause","the files and you","files and you must","and you must retain","derivative works and if","works and if the","version 0 5 the","0 5 the license","5 the license you","licenses shl 0 5","shl 0 5 unless","0 5 unless required","5 unless required by","license version 0 5 this","version 0 5 this license","0 5 this license is","5 this license is based","mask rights and database extraction","rights and database extraction rights","and database extraction rights but","database extraction rights but excluding","extraction rights but excluding patents","meet the following conditions you","the following conditions you must","following conditions you must give","conditions you must give any","license and you must cause","and you must cause any","changed the files and you","the files and you must","files and you must retain","and you must retain in","the derivative works and if","derivative works and if the","works and if the work","and if the work includes","license version 0 5 the","version 0 5 the license","0 5 the license you","5 the license you may","org licenses shl 0 5","licenses shl 0 5 unless","shl 0 5 unless required","0 5 unless required by","5 unless required by applicable"]},{"licenseTexts":["SOLDERPAD HARDWARE LICENSE version 0.51\n\nThis license is based closely on the Apache License Version 2.0, but is not approved or endorsed by the Apache Foundation. A copy of the non-modified Apache License 2.0 can be found at http://www.apache.org/licenses/LICENSE-2.0.\n\nAs this license is not currently OSI or FSF approved, the Licensor permits any Work licensed under this License, at the option of the Licensee, to be treated as licensed under the Apache License Version 2.0 (which is so approved).\n\nThis License is licensed under the terms of this License and in particular clause 7 below (Disclaimer of Warranties) applies in relation to its use. TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n   1. Definitions.\n\n      \n\n      \"License\" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.\n\n      \n\n      \"Licensor\" shall mean the Rights owner or entity authorized by the Rights owner that is granting the License.\n\n      \n\n      \"Legal Entity\" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, \"control\" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.\n\n      \n\n      \"You\" (or \"Your\") shall mean an individual or Legal Entity exercising permissions granted by this License.\n\n      \n\n      \"Rights\" means copyright and any similar right including design right (whether registered or unregistered), semiconductor topography (mask) rights and database rights (but excluding Patents and Trademarks).\n\n      \n\n      \"Source\" form shall mean the preferred form for making modifications, including but not limited to source code, net lists, board layouts, CAD files, documentation source, and configuration files.\n\n      \n\n      \"Object\" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, the instantiation of a hardware design and conversions to other media types, including intermediate forms such as bytecodes, FPGA bitstreams, artwork and semiconductor topographies (mask works).\n\n      \n\n      \"Work\" shall mean the work of authorship, whether in Source form or other Object form, made available under the License, as indicated by a Rights notice that is included in or attached to the work (an example is provided in the Appendix below).\n\n      \n\n      \"Derivative Works\" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) or physically connect to or interoperate with the interfaces of, the Work and Derivative Works thereof.\n\n      \n\n      \"Contribution\" shall mean any design or work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the Rights owner or by an individual or Legal Entity authorized to submit on behalf of the Rights owner. For the purposes of this definition, \"submitted\" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the Rights owner as \"Not a Contribution.\"\n\n      \n\n      \"Contributor\" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.\n\n   2. Grant of License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable license under the Rights to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form and do anything in relation to the Work as if the Rights did not exist.\n\n   3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.\n\n   4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:\n\n      1. You must give any other recipients of the Work or Derivative Works a copy of this License; and\n\n      2. You must cause any modified files to carry prominent notices stating that You changed the files; and\n\n      3. You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and\n\n      4. If the Work includes a \"NOTICE\" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.\n\n   5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.\n\n   6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.\n\n   7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.\n\n   8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.\n\n   9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS\n\nAPPENDIX: How to apply this license to your work\n\nTo apply this license to your work, attach the following boilerplate notice, with the fields enclosed by brackets \"[]\" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same \"printed page\" as the copyright notice for easier identification within third-party archives.\n\nCopyright [yyyy] [name of copyright owner] Copyright and related rights are licensed under the Solderpad Hardware License, Version 0.51 (the \"License\"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://solderpad.org/licenses/SHL-0.51. Unless required by applicable law or agreed to in writing, software, hardware and materials distributed under this License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License."],"licenseIds":["SHL-0.51"],"keywords":["0 51 this","51 this license","conditions 1 you","license and 2","and 2 you","files and 3","and 3 you","works and 4","and 4 if","4 if the","0 51 the","51 the license","shl 0 51","0 51 unless","51 unless required","version 0 51 this","0 51 this license","51 this license is","rights and database rights","and database rights but","database rights but excluding","following conditions 1 you","conditions 1 you must","1 you must give","this license and 2","license and 2 you","and 2 you must","2 you must cause","the files and 3","files and 3 you","and 3 you must","3 you must retain","derivative works and 4","works and 4 if","and 4 if the","4 if the work","version 0 51 the","0 51 the license","51 the license you","licenses shl 0 51","shl 0 51 unless","0 51 unless required","51 unless required by","license version 0 51 this","version 0 51 this license","0 51 this license is","51 this license is based","mask rights and database rights","rights and database rights but","and database rights but excluding","database rights but excluding patents","meet the following conditions 1","the following conditions 1 you","following conditions 1 you must","conditions 1 you must give","1 you must give any","of this license and 2","this license and 2 you","license and 2 you must","and 2 you must cause","2 you must cause any","changed the files and 3","the files and 3 you","files and 3 you must","and 3 you must retain","3 you must retain in","the derivative works and 4","derivative works and 4 if","works and 4 if the","and 4 if the work","4 if the work includes","license version 0 51 the","version 0 51 the license","0 51 the license you","51 the license you may","org licenses shl 0 51","licenses shl 0 51 unless","shl 0 51 unless required","0 51 unless required by","51 unless required by applicable"]},{"licenseTexts":["\n\nSUN INDUSTRY STANDARDS SOURCE LICENSE\n\nVersion 1.2\n\n   1.0 DEFINITIONS\n\n      1.1 Commercial Use means distribution or otherwise making the Original Code available to a third party.\n\n      1.2 Contributor Version means the combination of the Original Code, and the Modifications made by that particular Contributor.\n\n      1.3 Electronic Distribution Mechanism means a mechanism generally accepted in the software development community for the electronic transfer of data.\n\n      1.4 Executable means Original Code in any form other than Source Code.\n\n      1.5 Initial Developer means the individual or entity identified as the Initial Developer in the Source Code notice required by Exhibit A.\n\n      1.6 Larger Work means a work which combines Original Code or portions thereof with code not governed by the terms of this License.\n\n      1.7 License means this document.\n\n      1.8 Licensable means having the right to grant, to the maximum extent possible, whether at the time of the initial grant or subsequently acquired, any and all of the rights conveyed herein.\n\n      1.9 Modifications means any addition to or deletion from the substance or structure of either the Original Code or any previous Modifications. A Modification is:\n\n         A. Any addition to or deletion from the contents of a file containing Original Code or previous Modifications.\n\n         B. Any new file that contains any part of the Original Code or previous Modifications.\n\n      1.10 Original Code means Source Code of computer software code which is described in the Source Code notice required by Exhibit A as Original Code.\n\n      1.11 Patent Claims means any patent claim(s), now owned or hereafter acquired, including without limitation, method, process, and apparatus claims, in any patent Licensable by grantor.\n\n      1.12 Source Code means the preferred form of the Original Code for making modifications to it, including all modules it contains, plus any associated interface definition files, or scripts used to control compilation and installation of an Executable.\n\n      1.13 Standards means the standards identified in Exhibit B.\n\n      1.14 You (or Your) means an individual or a legal entity exercising rights under, and complying with all of the terms of, this License or a future version of this License issued under Section 6.1. For legal entities, You includes any entity which controls, is controlled by, or is under common control with You. For purposes of this definition, control means (a) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (b) ownership of more than fifty percent (50%) of the outstanding shares or beneficial ownership of such entity.\n\n   2.0 SOURCE CODE LICENSE\n\n      2.1 The Initial Developer Grant The Initial Developer hereby grants You a world-wide, royalty-free, non-exclusive license, subject to third party intellectual property claims:\n\n         \n\n         (a)under intellectual property rights (other than patent or trademark) Licensable by Initial Developer to use, reproduce, modify, display, perform, sublicense and distribute the Original Code (or portions thereof) with or without Modifications, and/or as part of a Larger Work; and\n\n         (b) under Patents Claims infringed by the making, using or selling of Original Code, to make, have made, use, practice, sell, and offer for sale, and/or otherwise dispose of the Original Code (or portions thereof).\n\n         (c) the licenses granted in this Section 2.1(a) and (b) are effective on the date Initial Developer first distributes Original Code under the terms of this License.\n\n         (d) Notwithstanding Section 2.1(b) above, no patent license is granted: 1) for code that You delete from the Original Code; 2) separate from the Original Code; or 3) for infringements caused by: i) the modification of the Original Code or ii) the combination of the Original Code with other software or devices, including but not limited to Modifications.\n\n   3.0 DISTRIBUTION OBLIGATIONS\n\n      3.1 Application of License. The Source Code version of Original Code may be distributed only under the terms of this License or a future version of this License released under Section 6.1, and You must include a copy of this License with every copy of the Source Code You distribute. You may not offer or impose any terms on any Source Code version that alters or restricts the applicable version of this License or the recipients rights hereunder. Your license for shipment of the Contributor Version is conditioned upon Your full compliance with this Section. The Modifications which You create must comply with all requirements set out by the Standards body in effect one hundred twenty (120) days before You ship the Contributor Version. In the event that the Modifications do not meet such requirements, You agree to publish either (i) any deviation from the Standards protocol resulting from implementation of Your Modifications and a reference implementation of Your Modifications or (ii) Your Modifications in Source Code form, and to make any such deviation and reference implementation or Modifications available to all third parties under the same terms a this license on a royalty free basis within thirty (30) days of Your first customer shipment of Your Modifications. Additionally, in the event that the Modifications you create do not meet the requirements set out in this Section, You agree to comply with the Standards requirements set out in Exhibit B.\n\n      3.2 Required Notices. You must duplicate the notice in Exhibit A in each file of the Source Code. If it is not possible to put such notice in a particular Source Code file due to its structure, then You must include such notice in a location (such as a relevant directory) where a user would be likely to look for such a notice. If You created one or more Modification(s) You may add Your name as a Contributor to the notice described in Exhibit A. You must also duplicate this License in any documentation for the Source Code where You describe recipients rights or ownership rights relating to Initial Code.\n\n      You may choose to offer, and to charge a fee for, warranty, support, indemnity or liability obligations to one or more recipients of Your version of the Code. However, You may do so only on Your own behalf, and not on behalf of the Initial Developer. You must make it absolutely clear than any such warranty, support, indemnity or liability obligation is offered by You alone, and You hereby agree to indemnify the Initial Developer for any liability incurred by the Initial Developer as a result of warranty, support, indemnity or liability terms You offer.\n\n      3.3 Distribution of Executable Versions. You may distribute Original Code in Executable and Source form only if the requirements of Sections 3.1 and 3.2 have been met for that Original Code, and if You include a notice stating that the Source Code version of the Original Code is available under the terms of this License. The notice must be conspicuously included in any notice in an Executable or Source versions, related documentation or collateral in which You describe recipients rights relating to the Original Code. You may distribute the Executable and Source versions of Your version of the Code or ownership rights under a license of Your choice, which may contain terms different from this License, provided that You are in compliance with the terms of this License. If You distribute the Executable and Source versions under a different license You must make it absolutely clear that any terms which differ from this License are offered by You alone, not by the Initial Developer. You hereby agree to indemnify the Initial Developer for any liability incurred by the Initial Developer as a result of any such terms You offer.\n\n      3.4 Larger Works. You may create a Larger Work by combining Original Code with other code not governed by the terms of this License and distribute the Larger Work as a single product. In such a case, You must make sure the requirements of this License are fulfilled for the Original Code.\n\n   4.0 INABILITY TO COMPLY DUE TO STATUTE OR REGULATION\n\n   If it is impossible for You to comply with any of the terms of this License with respect to some or all of the Original Code due to statute, judicial order, or regulation then You must: (a) comply with the terms of this License to the maximum extent possible; and (b) describe the limitations and the code they affect. Such description must be included in the LEGAL file described in Section 3.2 and must be included with all distributions of the Source Code. Except to the extent prohibited by statute or regulation, such description must be sufficiently detailed for a recipient of ordinary skill to be able to understand it.\n\n   5.0 APPLICATION OF THIS LICENSE\n\n   This License applies to code to which the Initial Developer has attached the notice in Exhibit A and to related Modifications as set out in Section 3.1.\n\n   6.0 VERSIONS OF THE LICENSE\n\n      6.1 New Versions. Sun may publish revised and/or new versions of the License from time to time. Each version will be given a distinguishing version number.\n\n      6.2 Effect of New Versions. Once Original Code has been published under a particular version of the License, You may always continue to use it under the terms of that version. You may also choose to use such Original Code under the terms of any subsequent version of the License published by Sun. No one other than Sun has the right to modify the terms applicable to Original Code.\n\n   7.0 DISCLAIMER OF WARRANTY\n\n   ORIGINAL CODE IS PROVIDED UNDER THIS LICENSE ON AN AS IS BASIS, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES THAT THE ORIGINAL CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE ORIGINAL CODE IS WITH YOU. SHOULD ANY ORIGINAL CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT THE INITIAL DEVELOPER) ASSUME THE COST OF ANY NECESSARY SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. NO USE OF ANY ORIGINAL CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER.\n\n   8.0 TERMINATION\n\n      8.1 This License and the rights granted hereunder will terminate automatically if You fail to comply with terms herein and fail to cure such breach within 30 days of becoming aware of the breach. All sublicenses to the Original Code which are properly granted shall survive any termination of this License. Provisions which, by their nature, must remain in effect beyond the termination of this License shall survive. 8.2 In the event of termination under Section 8.1 above, all end user license agreements (excluding distributors and resellers) which have been validly granted by You or any distributor hereunder prior to termination shall survive termination. EXHIBIT A - Sun Industry Standards Source License\n\n\"The contents of this file are subject to the Sun Industry Standards Source License Version 1.2 (the License); You\n\nmay not use this file except in compliance with the License.\"\n\n\"You may obtain a copy of the License at gridengine.sunsource.net/license.html\"\n\n\"Software distributed under the License is distributed on an AS IS basis, WITHOUT WARRANTY OF ANY KIND, either express or\n\nimplied. See the License for the specific language governing rights and limitations under the License.\"\n\n\"The Original Code is Grid Engine.\"\n\n\"The Initial Developer of the Original Code is:\n\nSun Microsystems, Inc.\"\n\n\"Portions created by: Sun Microsystems, Inc. are Copyright (C) 2001 Sun Microsystems, Inc.\"\n\n\"All Rights Reserved.\"\n\n\"Contributor(s): __________________________________\"\n\nEXHIBIT B - Standards\n\n   1.0 Requirements for project Standards. The requirements for project Standards are version-dependent and are defined at: Grid Engine standards.\n\n   2.0 Additional requirements. The additional requirements pursuant to Section 3.1 are defined as:\n\n      2.1 Naming Conventions. If any of your Modifications do not meet the requirements of the Standard, then you must change the product name so that Grid Engine, gridengine, gridengine.sunsource, and similar naming conventions are not used.\n\n      2.2 Compliance Claims. If any of your Modifications do not meet the requirements of the Standards you may not claim, directly or indirectly, that your implementation of the Standards is compliant."],"licenseIds":["SISSL-1.2"],"keywords":["2 1 0","same terms a","your modifications additionally","modifications additionally in","additionally in the","you create do","create do not","the requirements set","section you agree","with the standards","the standards requirements","standards requirements set","exhibit b 3","survive termination exhibit","termination exhibit a","a sun industry","the sun industry","license at gridengine","at gridengine sunsource","gridengine sunsource net","sunsource net license","net license html","license html software","code is grid","is grid engine","grid engine the","engine the initial","created by sun","microsystems inc are","c 2001 sun","2001 sun microsystems","b standards 1","standards 1 0","1 0 requirements","0 requirements for","project standards the","standards the requirements","project standards are","standards are version","are version dependent","version dependent and","dependent and are","and are defined","defined at grid","at grid engine","grid engine standards","engine standards 2","standards 2 0","2 0 additional","0 additional requirements","additional requirements the","requirements the additional","the additional requirements","additional requirements pursuant","requirements pursuant to","3 1 are","1 are defined","are defined as","defined as 2","as 2 1","2 1 naming","1 naming conventions","naming conventions if","conventions if any","the standard then","standard then you","must change the","change the product","the product name","product name so","name so that","so that grid","that grid engine","grid engine gridengine","engine gridengine gridengine","gridengine gridengine sunsource","gridengine sunsource and","sunsource and similar","and similar naming","similar naming conventions","naming conventions are","conventions are not","not used 2","used 2 2","2 2 compliance","2 compliance claims","compliance claims if","claims if any","the standards you","standards you may","not claim directly","claim directly or","or indirectly that","indirectly that your","that your implementation","your implementation of","implementation of the","the standards is","standards is compliant","1 2 1 0","2 1 0 definitions","the same terms a","same terms a this","a this license on","of your modifications additionally","your modifications additionally in","modifications additionally in the","additionally in the event","that the modifications you","the modifications you create","modifications you create do","you create do not","create do not meet","meet the requirements set","the requirements set out","out in this section","in this section you","this section you agree","section you agree to","comply with the standards","with the standards requirements","the standards requirements set","standards requirements set out","out in exhibit b","in exhibit b 3","exhibit b 3 2","b 3 2 required","shall survive termination exhibit","survive termination exhibit a","termination exhibit a sun","exhibit a sun industry","a sun industry standards","standards source license the","to the sun industry","the sun industry standards","the license at gridengine","license at gridengine sunsource","at gridengine sunsource net","gridengine sunsource net license","sunsource net license html","net license html software","license html software distributed","original code is grid","code is grid engine","is grid engine the","grid engine the initial","engine the initial developer","portions created by sun","created by sun microsystems","sun microsystems inc are","microsystems inc are copyright","copyright c 2001 sun","c 2001 sun microsystems","2001 sun microsystems inc","exhibit b standards 1","b standards 1 0","standards 1 0 requirements","1 0 requirements for","0 requirements for project","for project standards the","project standards the requirements","standards the requirements for","the requirements for project","for project standards are","project standards are version","standards are version dependent","are version dependent and","version dependent and are","dependent and are defined","and are defined at","are defined at grid","defined at grid engine","at grid engine standards","grid engine standards 2","engine standards 2 0","standards 2 0 additional","2 0 additional requirements","0 additional requirements the","additional requirements the additional","requirements the additional requirements","the additional requirements pursuant","additional requirements pursuant to","requirements pursuant to section","to section 3 1","section 3 1 are","3 1 are defined","1 are defined as","are defined as 2","defined as 2 1","as 2 1 naming","2 1 naming conventions","1 naming conventions if","naming conventions if any","conventions if any of","requirements of the standard","of the standard then","the standard then you","standard then you must","then you must change","you must change the"]},{"licenseTexts":["Sun Industry Standards Source License - Version 1.1\n\n   1.0 DEFINITIONS\n\n      1.1 \"Commercial Use\" means distribution or otherwise making the Original Code available to a third party.\n\n      1.2 \"Contributor Version\" means the combination of the Original Code, and the Modifications made by that particular Contributor.\n\n      1.3 \"Electronic Distribution Mechanism\" means a mechanism generally accepted in the software development community for the electronic transfer of data.\n\n      1.4 \"Executable\" means Original Code in any form other than Source Code.\n\n      1.5 \"Initial Developer\" means the individual or entity identified as the Initial Developer in the Source Code notice required by Exhibit A.\n\n      1.6 \"Larger Work\" means a work which combines Original Code or portions thereof with code not governed by the terms of this License.\n\n      1.7 \"License\" means this document.\n\n      1.8 \"Licensable\" means having the right to grant, to the maximum extent possible, whether at the time of the initial grant or subsequently acquired, any and all of the rights conveyed herein.\n\n      1.9 \"Modifications\" means any addition to or deletion from the substance or structure of either the Original Code or any previous Modifications. A Modification is:\n\n         A. Any addition to or deletion from the contents of a file containing Original Code or previous Modifications.\n\n         B. Any new file that contains any part of the Original Code or previous Modifications.\n\n      1.10 \"Original Code\" means Source Code of computer software code which is described in the Source Code notice required by Exhibit A as Original Code.\n\n      1.11 \"Patent Claims\" means any patent claim(s), now owned or hereafter acquired, including without limitation, method, process, and apparatus claims, in any patent Licensable by grantor.\n\n      1.12 \"Source Code\" means the preferred form of the Original Code for making modifications to it, including all modules it contains, plus any associated interface definition files, or scripts used to control compilation and installation of an Executable.\n\n      1.13 \"Standards\" means the standards identified in Exhibit B.\n\n      1.14 \"You\" (or \"Your\") means an individual or a legal entity exercising rights under, and complying with all of the terms of, this License or a future version of this License issued under Section 6.1. For legal entities, \"You'' includes any entity which controls, is controlled by, or is under common control with You. For purposes of this definition, \"control'' means (a) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (b) ownership of more than fifty percent (50%) of the outstanding shares or beneficial ownership of such entity.\n\n   2.0 SOURCE CODE LICENSE\n\n      2.1 The Initial Developer Grant The Initial Developer hereby grants You a world-wide, royalty-free, non-exclusive license, subject to third party intellectual property claims:\n\n         (a) under intellectual property rights (other than patent or trademark) Licensable by Initial Developer to use, reproduce, modify, display, perform, sublicense and distribute the Original Code (or portions thereof) with or without Modifications, and/or as part of a Larger Work; and\n\n         (b) under Patents Claims infringed by the making, using or selling of Original Code, to make, have made, use, practice, sell, and offer for sale, and/or otherwise dispose of the Original Code (or portions thereof).\n\n         (c) the licenses granted in this Section 2.1(a) and (b) are effective on the date Initial Developer first distributes Original Code under the terms of this License.\n\n         (d) Notwithstanding Section 2.1(b) above, no patent license is granted: 1) for code that You delete from the Original Code; 2) separate from the Original Code; or 3) for infringements caused by: i) the modification of the Original Code or ii) the combination of the Original Code with other software or devices, including but not limited to Modifications.\n\n   3.0 DISTRIBUTION OBLIGATIONS\n\n      3.1 Application of License. The Source Code version of Original Code may be distributed only under the terms of this License or a future version of this License released under Section 6.1, and You must include a copy of this License with every copy of the Source Code You distribute. You may not offer or impose any terms on any Source Code version that alters or restricts the applicable version of this License or the recipients' rights hereunder. Your license for shipment of the Contributor Version is conditioned upon Your full compliance with this Section. The Modifications which You create must comply with all requirements set out by the Standards body in effect one hundred twenty (120) days before You ship the Contributor Version. In the event that the Modifications do not meet such requirements, You agree to publish either (i) any deviation from the Standards protocol resulting from implementation of Your Modifications and a reference implementation of Your Modifications or (ii) Your Modifications in Source Code form, and to make any such deviation and reference implementation or Modifications available to all third parties under the same terms as this license on a royalty free basis within thirty (30) days of Your first customer shipment of Your Modifications.\n\n      3.2 Required Notices. You must duplicate the notice in Exhibit A in each file of the Source Code. If it is not possible to put such notice in a particular Source Code file due to its structure, then You must include such notice in a location (such as a relevant directory) where a user would be likely to look for such a notice. If You created one or more Modification(s) You may add Your name as a Contributor to the notice described in Exhibit A. You must also duplicate this License in any documentation for the Source Code where You describe recipients' rights or ownership rights relating to Initial Code. You may choose to offer, and to charge a fee for, warranty, support, indemnity or liability obligations to one or more recipients of Your version of the Code. However, You may do so only on Your own behalf, and not on behalf of the Initial Developer. You must make it absolutely clear than any such warranty, support, indemnity or liability obligation is offered by You alone, and You hereby agree to indemnify the Initial Developer for any liability incurred by the Initial Developer as a result of warranty, support, indemnity or liability terms You offer.\n\n      3.3 Distribution of Executable Versions. You may distribute Original Code in Executable and Source form only if the requirements of Sections 3.1 and 3.2 have been met for that Original Code, and if You include a notice stating that the Source Code version of the Original Code is available under the terms of this License. The notice must be conspicuously included in any notice in an Executable or Source versions, related documentation or collateral in which You describe recipients' rights relating to the Original Code. You may distribute the Executable and Source versions of Your version of the Code or ownership rights under a license of Your choice, which may contain terms different from this License, provided that You are in compliance with the terms of this License. If You distribute the Executable and Source versions under a different license You must make it absolutely clear that any terms which differ from this License are offered by You alone, not by the Initial Developer. You hereby agree to indemnify the Initial Developer for any liability incurred by the Initial Developer as a result of any such terms You offer.\n\n      3.4 Larger Works. You may create a Larger Work by combining Original Code with other code not governed by the terms of this License and distribute the Larger Work as a single product. In such a case, You must make sure the requirements of this License are fulfilled for the Original Code.\n\n   4.0 INABILITY TO COMPLY DUE TO STATUTE OR REGULATION\n\n   If it is impossible for You to comply with any of the terms of this License with respect to some or all of the Original Code due to statute, judicial order, or regulation then You must: (a) comply with the terms of this License to the maximum extent possible; and (b) describe the limitations and the code they affect. Such description must be included in the LEGAL file described in Section 3.2 and must be included with all distributions of the Source Code. Except to the extent prohibited by statute or regulation, such description must be sufficiently detailed for a recipient of ordinary skill to be able to understand it.\n\n   5.0 APPLICATION OF THIS LICENSE\n\n   This License applies to code to which the Initial Developer has attached the notice in Exhibit A and to related Modifications as set out in Section 3.1.\n\n   6.0 VERSIONS OF THE LICENSE\n\n      6.1 New Versions. Sun may publish revised and/or new versions of the License from time to time. Each version will be given a distinguishing version number.\n\n      6.2 Effect of New Versions. Once Original Code has been published under a particular version of the License, You may always continue to use it under the terms of that version. You may also choose to use such Original Code under the terms of any subsequent version of the License published by Sun. No one other than Sun has the right to modify the terms applicable to Original Code.\n\n   7.0 DISCLAIMER OF WARRANTY\n\n   ORIGINAL CODE IS PROVIDED UNDER THIS LICENSE ON AN \"AS IS\" BASIS, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES THAT THE ORIGINAL CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE ORIGINAL CODE IS WITH YOU. SHOULD ANY ORIGINAL CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT THE INITIAL DEVELOPER) ASSUME THE COST OF ANY NECESSARY SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. NO USE OF ANY ORIGINAL CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER.\n\n   8.0 TERMINATION\n\n      8.1 This License and the rights granted hereunder will terminate automatically if You fail to comply with terms herein and fail to cure such breach within 30 days of becoming aware of the breach. All sublicenses to the Original Code which are properly granted shall survive any termination of this License. Provisions which, by their nature, must remain in effect beyond the termination of this License shall survive.\n\n      8.2 In the event of termination under Section 8.1 above, all end user license agreements (excluding distributors and resellers) which have been validly granted by You or any distributor hereunder prior to termination shall survive termination.\n\n   9.0 LIMIT OF LIABILITY\n\n   UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER TORT (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL YOU, THE INITIAL DEVELOPER, ANY OTHER CONTRIBUTOR, OR ANY DISTRIBUTOR OF ORIGINAL CODE, OR ANY SUPPLIER OF ANY OF SUCH PARTIES, BE LIABLE TO ANY PERSON FOR ANY INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, COMPUTER FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER COMMERCIAL DAMAGES OR LOSSES, EVEN IF SUCH PARTY SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF LIABILITY SHALL NOT APPLY TO LIABILITY FOR DEATH OR PERSONAL INJURY RESULTING FROM SUCH PARTY'S NEGLIGENCE TO THE EXTENT APPLICABLE LAW PROHIBITS SUCH LIMITATION. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OR LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THIS EXCLUSION AND LIMITATION MAY NOT APPLY TO YOU.\n\n   10.0 U.S. GOVERNMENT END USERS\n\n   U.S. Government: If this Software is being acquired by or on behalf of the U.S. Government or by a U.S. Government prime contractor or subcontractor (at any tier), then the Government's rights in the Software and accompanying documentation shall be only as set forth in this license; this is in accordance with 48 C.F.R. 227.7201 through 227.7202-4 (for Department of Defense (DoD) acquisitions) and with 48 C.F.R. 2.101 and 12.212 (for non-DoD acquisitions).\n\n   11.0 MISCELLANEOUS\n\n   This License represents the complete agreement concerning subject matter hereof. If any provision of this License is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable. This License shall be governed by California law provisions (except to the extent applicable law, if any, provides otherwise), excluding its conflict-of-law provisions. With respect to disputes in which at least one party is a citizen of, or an entity chartered or registered to do business in the United States of America, any litigation relating to this License shall be subject to the jurisdiction of the Federal Courts of the Northern District of California, with venue lying in Santa Clara County, California, with the losing party responsible for costs, including without limitation, court costs and reasonable attorneys' fees and expenses. The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded. Any law or regulation which provides that the language of a contract shall be construed against the drafter shall not apply to this License. EXHIBIT A - Sun Standards License\n\n\"The contents of this file are subject to the Sun Standards License Version 1.1 (the \"License\"); You may not use this file except in compliance with the License. You may obtain a copy of the License at _______________________________ .\n\nSoftware distributed under the License is distributed on an \"AS IS\" basis, WITHOUT WARRANTY OF ANY KIND, either\n\nexpress or implied. See the License for the specific language governing rights and limitations under the License.\n\nThe Original Code is ______________________________________ .\n\nThe Initial Developer of the Original Code is: Sun Microsystems, Inc. .\n\nPortions created by: _______________________________________\n\nare Copyright (C): _______________________________________\n\nAll Rights Reserved.\n\nContributor(s): _______________________________________\n\nEXHIBIT B - Standards\n\nThe Standard is defined as the following:\n\nOpenOffice.org XML File Format Specification, located at http://xml.openoffice.org\n\nOpenOffice.org Application Programming Interface Specification, located at\n\nhttp://api.openoffice.org"],"licenseIds":["SISSL"],"keywords":["modifications 3 2","termination 9 0","9 0 limit","0 limit of","limit of liability","distributor of original","10 0 u","0 u s","end users u","users u s","s government if","government if this","if this software","software is being","is being acquired","being acquired by","acquired by or","government or by","by a u","s government prime","government prime contractor","prime contractor or","contractor or subcontractor","or subcontractor at","subcontractor at any","at any tier","any tier then","tier then the","then the government","the government s","government s rights","accompanying documentation shall","documentation shall be","shall be only","be only as","only as set","license this is","this is in","is in accordance","accordance with 48","r 227 7201","227 7201 through","7201 through 227","7202 4 for","4 for department","defense dod acquisitions","dod acquisitions and","acquisitions and with","and with 48","2 101 and","101 and 12","12 212 for","212 for non","for non dod","non dod acquisitions","dod acquisitions 11","acquisitions 11 0","11 0 miscellaneous","0 miscellaneous this","a sun standards","standards license the","the sun standards","standards license version","license at software","at software distributed","b standards the","standards the standard","the standard is","standard is defined","the following openoffice","following openoffice org","openoffice org xml","org xml file","xml file format","file format specification","format specification located","at http xml","http xml openoffice","xml openoffice org","openoffice org openoffice","org openoffice org","openoffice org application","org application programming","programming interface specification","interface specification located","at http api","http api openoffice","api openoffice org","1 1 1 0","1 1 0 definitions","as this license on","your modifications 3 2","modifications 3 2 required","survive termination 9 0","termination 9 0 limit","9 0 limit of","0 limit of liability","limit of liability under","any distributor of original","distributor of original code","you 10 0 u","10 0 u s","0 u s government","government end users u","end users u s","users u s government","u s government if","s government if this","government if this software","if this software is","this software is being","software is being acquired","is being acquired by","being acquired by or","acquired by or on","s government or by","government or by a","or by a u","by a u s","u s government prime","s government prime contractor","government prime contractor or","prime contractor or subcontractor","contractor or subcontractor at","or subcontractor at any","subcontractor at any tier","at any tier then","any tier then the","tier then the government","then the government s","the government s rights","government s rights in","and accompanying documentation shall","accompanying documentation shall be","documentation shall be only","shall be only as","be only as set","only as set forth","this license this is","license this is in","this is in accordance","is in accordance with","in accordance with 48","accordance with 48 c","f r 227 7201","r 227 7201 through","227 7201 through 227","7201 through 227 7202","227 7202 4 for","7202 4 for department","4 for department of","of defense dod acquisitions","defense dod acquisitions and","dod acquisitions and with","acquisitions and with 48","and with 48 c","r 2 101 and","2 101 and 12","101 and 12 212","and 12 212 for","12 212 for non","212 for non dod","for non dod acquisitions","non dod acquisitions 11","dod acquisitions 11 0","acquisitions 11 0 miscellaneous","11 0 miscellaneous this","0 miscellaneous this license","license exhibit a sun","exhibit a sun standards","a sun standards license","sun standards license the","standards license the contents","to the sun standards","the sun standards license","sun standards license version","standards license version 1","the license at software","license at software distributed","at software distributed under","exhibit b standards the","b standards the standard","standards the standard is","the standard is defined","standard is defined as","as the following openoffice","the following openoffice org","following openoffice org xml","openoffice org xml file","org xml file format","xml file format specification","file format specification located","format specification located at","located at http xml","at http xml openoffice","http xml openoffice org","xml openoffice org openoffice","openoffice org openoffice org","org openoffice org application","openoffice org application programming"]},{"licenseTexts":["STANDARD ML OF NEW JERSEY COPYRIGHT NOTICE, LICENSE AND DISCLAIMER. Copyright (c) 2001-2011 by The Fellowship of SML/NJ\n\nCopyright (c) 1989-2001 by Lucent Technologies\n\nPermission to use, copy, modify, and distribute this software and its documentation for any purpose and without fee is hereby granted, provided that the above copyright notice appear in all copies and that both the copyright notice and this permission notice and warranty disclaimer appear in supporting documentation, and that the name of Lucent Technologies, Bell Labs or any Lucent entity not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission.\n\nLucent disclaims all warranties with regard to this software, including all implied warranties of merchantability and fitness. In no event shall Lucent be liable for any special, indirect or consequential damages or any damages whatsoever resulting from loss of use, data or profits, whether in an action of contract, negligence or other tortious action, arising out of or in connection with the use or performance of this software."],"licenseIds":["StandardML-NJ","SMLNJ"],"keywords":["standard ml of","ml of new","of new jersey","new jersey copyright","jersey copyright notice","copyright notice license","notice license and","disclaimer copyright c","c 2001 2011","2001 2011 by","2011 by the","by the fellowship","the fellowship of","fellowship of sml","of sml nj","sml nj copyright","nj copyright c","c 1989 2001","1989 2001 by","2001 by lucent","by lucent technologies","lucent technologies permission","technologies permission to","notice and warranty","and warranty disclaimer","warranty disclaimer appear","disclaimer appear in","name of lucent","lucent technologies bell","technologies bell labs","bell labs or","labs or any","or any lucent","any lucent entity","lucent entity not","entity not be","prior permission lucent","permission lucent disclaims","lucent disclaims all","event shall lucent","shall lucent be","lucent be liable","standard ml of new","ml of new jersey","of new jersey copyright","new jersey copyright notice","jersey copyright notice license","copyright notice license and","notice license and disclaimer","license and disclaimer copyright","and disclaimer copyright c","disclaimer copyright c 2001","copyright c 2001 2011","c 2001 2011 by","2001 2011 by the","2011 by the fellowship","by the fellowship of","the fellowship of sml","fellowship of sml nj","of sml nj copyright","sml nj copyright c","nj copyright c 1989","copyright c 1989 2001","c 1989 2001 by","1989 2001 by lucent","2001 by lucent technologies","by lucent technologies permission","lucent technologies permission to","technologies permission to use","permission notice and warranty","notice and warranty disclaimer","and warranty disclaimer appear","warranty disclaimer appear in","disclaimer appear in supporting","the name of lucent","name of lucent technologies","of lucent technologies bell","lucent technologies bell labs","technologies bell labs or","bell labs or any","labs or any lucent","or any lucent entity","any lucent entity not","lucent entity not be","entity not be used","written prior permission lucent","prior permission lucent disclaims","permission lucent disclaims all","lucent disclaims all warranties","no event shall lucent","event shall lucent be","shall lucent be liable","lucent be liable for","standard ml of new jersey","ml of new jersey copyright","of new jersey copyright notice","new jersey copyright notice license","jersey copyright notice license and","copyright notice license and disclaimer","notice license and disclaimer copyright","license and disclaimer copyright c","and disclaimer copyright c 2001","disclaimer copyright c 2001 2011","copyright c 2001 2011 by","c 2001 2011 by the","2001 2011 by the fellowship","2011 by the fellowship of","by the fellowship of sml","the fellowship of sml nj","fellowship of sml nj copyright","of sml nj copyright c","sml nj copyright c 1989","nj copyright c 1989 2001","copyright c 1989 2001 by","c 1989 2001 by lucent","1989 2001 by lucent technologies","2001 by lucent technologies permission","by lucent technologies permission to","lucent technologies permission to use","technologies permission to use copy","and this permission notice and","this permission notice and warranty","permission notice and warranty disclaimer","notice and warranty disclaimer appear","and warranty disclaimer appear in","warranty disclaimer appear in supporting","disclaimer appear in supporting documentation","that the name of lucent","the name of lucent technologies","name of lucent technologies bell","of lucent technologies bell labs","lucent technologies bell labs or","technologies bell labs or any","bell labs or any lucent","labs or any lucent entity","or any lucent entity not","any lucent entity not be","lucent entity not be used","entity not be used in","specific written prior permission lucent","written prior permission lucent disclaims","prior permission lucent disclaims all","permission lucent disclaims all warranties","lucent disclaims all warranties with","in no event shall lucent","no event shall lucent be","event shall lucent be liable","shall lucent be liable for","lucent be liable for any"]},{"licenseTexts":["Secure Messaging Protocol (SMP) Libraries [ACL, CML, SFL]\n\nDistribution Rights\n\nAll source code for the SMP is being provided at no cost and with no financial limitations regarding its use and distribution. Organizations can use the SMP without paying any royalties or licensing fees. The SMP was originally developed by the U.S. Government. BAE Systems is enhancing and supporting the SMP under contract to the U.S. Government. The U.S. Government is furnishing the SMP software at no cost to the vendor subject to the conditions of the SMP Public License provided with the SMP software.\n\n29 May 2002\n\nSecure Messaging Protocol (SMP) Public License\n\nThe United States Government/Department of Defense/National Security Agency/Office of Network Security (collectively \"the U.S. Government\") hereby grants permission to any person obtaining a copy of the SMP source and object files (the \"SMP Software\") and associated documentation files (the \"SMP Documentation\"), or any portions thereof, to do the following, subject to the following license conditions:\n\nYou may, free of charge and without additional permission from the U.S. Government, use, copy, modify, sublicense and otherwise distribute the SMP Software or components of the SMP Software, with or without modifications developed by you and/or by others.\n\nYou may, free of charge and without additional permission from the U.S. Government, distribute copies of the SMP Documentation, with or without modifications developed by you and/or by others, at no charge or at a charge that covers the cost of reproducing such copies, provided that this SMP Public License is retained.\n\nFurthermore, if you distribute the SMP Software or parts of the SMP Software, with or without modifications developed by you and/or others, then you must either make available the source code to all portions of the SMP Software (exclusive of any modifications made by you and/or by others) upon request, or instead you may notify anyone requesting the SMP Software source code that it is freely available from the U.S. Government.\n\nTransmission of this SMP Public License must accompany whatever portions of the SMP Software you redistribute.\n\nThe SMP Software is provided without warranty or guarantee of any nature, express or implied, including without limitation the warranties of merchantability and fitness for a particular purpose.\n\nThe U.S. Government cannot be held liable for any damages either directly or indirectly caused by the use of the SMP Software.\n\nIt is not permitted to copy, sublicense, distribute or transfer any of the SMP Software except as expressly indicated herein. Any attempts to do otherwise will be considered a violation of this License and your rights to the SMP Software will be voided.\n\nThe SMP uses the Enhanced SNACC (eSNACC) Abstract Syntax Notation One (ASN.1) C++ Library to ASN.1 encode and decode security-related data objects. The eSNACC ASN.1 C++ Library is covered by the ENHANCED SNACC SOFTWARE PUBLIC LICENSE. None of the GNU public licenses apply to the eSNACC ASN.1 C++ Library. The eSNACC Compiler is not distributed as part of the SMP. Copyright © 1997-2002 National Security Agency"],"licenseIds":["SMPPL"],"keywords":["protocol smp libraries","smp libraries acl","libraries acl cml","acl cml sfl","cml sfl distribution","sfl distribution rights","distribution rights all","rights all source","for the smp","the smp is","smp is being","being provided at","provided at no","no cost and","cost and with","with no financial","no financial limitations","financial limitations regarding","limitations regarding its","regarding its use","and distribution organizations","distribution organizations can","organizations can use","can use the","use the smp","the smp without","smp without paying","without paying any","paying any royalties","any royalties or","royalties or licensing","or licensing fees","licensing fees the","fees the smp","the smp was","smp was originally","was originally developed","originally developed by","s government bae","government bae systems","bae systems is","systems is enhancing","is enhancing and","enhancing and supporting","and supporting the","supporting the smp","the smp under","smp under contract","under contract to","contract to the","to the u","government the u","government is furnishing","is furnishing the","furnishing the smp","smp software at","software at no","no cost to","to the vendor","the vendor subject","vendor subject to","the smp public","public license provided","with the smp","smp software 29","software 29 may","29 may 2002","may 2002 secure","2002 secure messaging","protocol smp public","license the united","states government department","government department of","of defense national","defense national security","security agency office","agency office of","office of network","of network security","network security collectively","security collectively the","collectively the u","s government hereby","government hereby grants","hereby grants permission","the smp source","smp source and","and object files","object files the","smp software and","smp documentation or","or any portions","any portions thereof","portions thereof to","thereof to do","the following subject","following subject to","following license conditions","license conditions you","s government use","government use copy","sublicense and otherwise","and otherwise distribute","otherwise distribute the","software or components","or components of","by others you","s government distribute","government distribute copies","smp documentation with","by others at","others at no","no charge or","charge or at","a charge that","charge that covers","that covers the","covers the cost","cost of reproducing","of reproducing such","reproducing such copies","such copies provided","copies provided that","that this smp","is retained furthermore","retained furthermore if","furthermore if you","software or parts","and or others","or others then","others then you","must either make","either make available","code to all","smp software exclusive","software exclusive of","exclusive of any","by others upon","others upon request","upon request or","request or instead","or instead you","instead you may","you may notify","may notify anyone","notify anyone requesting","anyone requesting the","requesting the smp","smp software source","code that it","it is freely","s government transmission","government transmission of","transmission of this","of this smp","public license must","license must accompany","must accompany whatever","accompany whatever portions","whatever portions of","smp software you","software you redistribute","redistribute the smp","smp software is","is provided without","provided without warranty","guarantee of any","any nature express","nature express or","purpose the u","s government cannot","government cannot be","cannot be held","any damages either","damages either directly","or indirectly caused","indirectly caused by","smp software it","smp software except","as expressly indicated","expressly indicated herein","indicated herein any","herein any attempts","any attempts to","attempts to do","to do otherwise","do otherwise will","otherwise will be","considered a violation","to the smp","smp software will","will be voided","be voided the","voided the smp","the smp uses","smp uses the","uses the enhanced","enhanced snacc esnacc","snacc esnacc abstract","esnacc abstract syntax"]},{"licenseTexts":["STORAGE NETWORKING INDUSTRY ASSOCIATION\n\nPUBLIC LICENSE\n\nVersion 1.1\n\n   1. Definitions.\n\n   1.1 \"Commercial Use\" means distribution or otherwise making the Covered Code available to a third party.\n\n   1.2 \"Contributor\" means each entity that creates or contributes to the creation of Modifications.\n\n   1.3 \"Contributor Version\" means the combination of the Original Code, prior Modifications used by a Contributor, and the Modifications made by that particular Contributor.\n\n   1.4 \"Covered Code\" means the Original Code or Modifications or the combination of the Original Code and Modifications, in each case including portions thereof.\n\n   1.5 \"Electronic Distribution Mechanism\" means a mechanism generally accepted in the software development community for the electronic transfer of data.\n\n   1.6 \"Executable\" means Covered Code in any form other than Source Code.\n\n   1.7 \"Initial Developer\" means the individual or entity identified as the Initial Developer in the Source Code notice required by Exhibit A.\n\n   1.8 \"Larger Work\" means a work which combines Covered Code or portions thereof with code not governed by the terms of this License.\n\n   1.9 \"License\" means this document.\n\n   1.10 \"Licensable\" means having the right to grant, to the maximum extent possible, whether at the time of the initial grant or subsequently acquired, any and all of the rights conveyed herein.\n\n   1.11 \"Modifications\" means any addition to or deletion from the substance or structure of either the Original Code or any previous Modifications. When Covered Code is released as a series of files, a Modification is:\n\n   A. Any addition to or deletion from the contents of a file containing Original Code or previous Modifications.\n\n   B. Any new file that contains any part of the Original Code or previous Modifications.\n\n   1.12 \"Original Code\" means Source Code of computer software code which is described in the Source Code notice required by Exhibit A as Original Code, and which, at the time of its release under this License is not already Covered Code governed by this License.\n\n   1.13 \"Patent Claims\" means any patent claim(s), now owned or hereafter acquired, including without limitation, method, process, and apparatus claims, in any patent Licensable by grantor.\n\n   1.14 \"Source Code\" means the preferred form of the Covered Code for making modifications to it, including all modules it contains, plus any associated interface definition files, scripts used to control compilation and installation of an Executable, or source code differential comparisons against either the Original Code or another well known, available Covered Code of the Contributor's choice. The Source Code can be in a compressed or archival form, provided the appropriate decompression or de-archiving software is widely available for no charge.\n\n   1.15 \"You\" (or \"Your\") means an individual or a legal entity exercising rights under, and complying with all of the terms of, this License or a future version of this License issued under Section 6.1. For legal entities, \"You\" includes any entity which controls, is controlled by, or is under common control with You. For purposes of this definition, \"control\" means (a) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (b) ownership of more than fifty percent (50%) of the outstanding shares or beneficial ownership of such entity\n\n   2. Source Code License.\n\n   2.1 The Initial Developer Grant. The Initial Developer hereby grants You a world-wide, royalty-free, non-exclusive license, subject to third party intellectual property claims:\n\n   (a) under intellectual property rights (other than patent or trademark) Licensable by Initial Developer to use, reproduce, modify, display, perform, sublicense and distribute the Original Code (or portions thereof) with or without Modifications, and/or as part of a Larger Work; and\n\n   (b) under Patents Claims infringed by the making, using or selling of Original Code, to make, have made, use, practice, sell, and offer for sale, and/or otherwise dispose of the Original Code (or portions thereof).\n\n   (c) the licenses granted in this Section 2.1(a) and (b) are effective on the date Initial Developer first distributes Original Code under the terms of this License.\n\n   (d) Notwithstanding Section 2.1(b) above, no patent license is granted: 1) for code that You delete from the Original Code; 2) separate from the Original Code; or 3) for infringements caused by: i) the modification of the Original Code or ii) the combination of the Original Code with other software or devices.\n\n   2.2 Contributor Grant. Subject to third party intellectual property claims, each Contributor hereby grants You a world-wide, royalty-free, non-exclusive license\n\n   (a) under intellectual property rights (other than patent or trademark) Licensable by Contributor, to use, reproduce, modify, display, perform, sublicense and distribute the Modifications created by such Contributor (or portions thereof) either on an unmodified basis, with other Modifications, as Covered Code and/or as part of a Larger Work; and\n\n   (b) under Patent Claims infringed by the making, using, or selling of Modifications made by that Contributor either alone and/or in combination with its Contributor Version (or portions of such combination), to make, use, sell, offer for sale, have made, and/or otherwise dispose of: 1) Modifications made by that Contributor (or portions thereof); and 2) the combination of Modifications made by that Contributor with its Contributor Version (or portions of such combination).\n\n   (c) the licenses granted in Sections 2.2(a) and 2.2(b) are effective on the date Contributor first makes Commercial Use of the Covered Code.\n\n   (d) Notwithstanding Section 2.2(b) above, no patent license is granted: 1) for any code that Contributor has deleted from the Contributor Version; 2) separate from the Contributor Version; 3) for infringements caused by: i) third party modifications of Contributor Version or ii) the combination of Modifications made by that Contributor with other software (except as part of the Contributor Version) or other devices; or 4) under Patent Claims infringed by Covered Code in the absence of Modifications made by that Contributor.\n\n   3. Distribution Obligations.\n\n   3.1 Application of License. The Modifications which You create or to which You contribute are governed by the terms of this License, including without limitation Section 2.2. The Source Code version of Covered Code may be distributed only under the terms of this License or a future version of this License released under Section 6.1, and You must include a copy of this License with every copy of the Source Code You distribute. You may not offer or impose any terms on any Source Code version that alters or restricts the applicable version of this License or the recipients' rights hereunder. However, You may include an additional document offering the additional rights described in Section 3.5.\n\n   3.2 Availability of Source Code. Any Modification which You create or to which You contribute must be made available in Source Code form under the terms of this License either on the same media as an Executable version or via an accepted Electronic Distribution Mechanism to anyone to whom you made an Executable version available; and if made available via Electronic Distribution Mechanism, must remain available for at least twelve (12) months after the date it initially became available, or at least six (6) months after a subsequent version of that particular Modification has been made available to such recipients. You are responsible for ensuring that the Source Code version remains available even if the Electronic Distribution Mechanism is maintained by a third party.\n\n   3.3 Description of Modifications. You must cause all Covered Code to which You contribute to contain a file documenting the changes You made to create that Covered Code and the date of any change. You must include a prominent statement that the Modification is derived, directly or indirectly, from Original Code provided by the Initial Developer and including the name of the Initial Developer in (a) the Source Code, and (b) in any notice in an Executable version or related documentation in which You describe the origin or ownership of the Covered Code.\n\n   3.4 Intellectual Property Matters.\n\n   (a) Third Party Claims. If Contributor has actual knowledge that a license under a third party's intellectual property rights is required to exercise the rights granted by such Contributor under Sections 2.1 or 2.2, Contributor must include a text file with the Source Code distribution titled \"LEGAL\" which describes the claim and the party making the claim in sufficient detail that a recipient will know whom to contact. If Contributor obtains such knowledge after the Modification is made available as described in Section 3.2, Contributor shall promptly modify the LEGAL file in all copies Contributor makes available thereafter.\n\n   (b) Contributor API's. If Contributor's Modifications include an application programming interface and Contributor has actual knowledge of patent licenses which are reasonably necessary to implement that API, Contributor must also include this information in the LEGAL file.\n\n   (c) Representations. Contributor represents that, except as disclosed pursuant to Section 3.4(a) above, Contributor believes that Contributor's Modifications are Contributor's original creation(s) and/or Contributor has sufficient rights to grant the rights conveyed by this License.\n\n   3.5 Required Notices. You must duplicate the notice in Exhibit A in each file of the Source Code. If it is not possible to put such notice in a particular Source Code file due to its structure, then You must include such notice in a location (such as a relevant directory) where a user would be most likely to look for such a notice. If You created one or more Modification(s) You may add your name as a Contributor to the notice described in Exhibit A. You must also duplicate this License in any documentation for the Source Code where You describe recipients' rights or ownership rights relating to Covered Code. You may choose to offer, and to charge a fee for, warranty, support, indemnity or liability obligations to one or more recipients of Covered Code. However, You may do so only on Your own behalf, and not on behalf of the Initial Developer or any Contributor. You must make it absolutely clear that any such warranty, support, indemnity or liability obligation is offered by You alone, and You hereby agree to indemnify the Initial Developer and every Contributor for any liability (excluding any liability arising from intellectual property claims relating to the Covered Code) incurred by the Initial Developer or such Contributor as a result of warranty, support, indemnity or liability terms You offer.\n\n   3.6 Distribution of Executable Versions. You may distribute Covered Code in Executable form only if the requirements of Section 3.1-3.5 have been met for that Covered Code, and if You include a notice stating that the Source Code version of the Covered Code is available under the terms of this License, including a description of how and where You have fulfilled the obligation of Section 3.2. The notice must be conspicuously included in any notice in an Executable version, related documentation or collateral in which You describe recipients' rights relating to the Covered Code. You may distribute the Executable version of Covered Code or ownership rights under a license of Your choice, which may contain terms different from this License, provided that You are in compliance with the terms of this License and that the license for the Executable version does not attempt to limit or alter the recipient's rights in the Source Code version from the rights set forth in this License. If You distribute the Executable version under a different license You must make it absolutely clear that any terms which differ from this License are offered by You alone, not by the Initial Developer or any Contributor. You hereby agree to indemnify the Initial Developer and every Contributor for any liability (excluding any liability arising from intellectual property claims relating to the Covered Code) incurred by the Initial Developer or such Contributor as a result of any such terms You offer.\n\n   3.7 Larger Works. You may create a Larger Work by combining Covered Code with other code not governed by the terms of this License and distribute the Larger Work as a single product. In such a case, You must make sure the requirements of this License are fulfilled for the Covered Code.\n\n   4. Inability to Comply Due to Statute or Regulation. If it is impossible for You to comply with any of the terms of this License with respect to some or all of the Covered Code due to statute, judicial order, or regulation then You must: (a) comply with the terms of this License to the maximum extent possible; and (b) describe the limitations and the code they affect. Such description must be included in the LEGAL file described in Section 3.4 and must be included with all distributions of the Source Code. Except to the extent prohibited by statute or regulation, such description must be sufficiently detailed for a recipient of ordinary skill to be able to understand it.\n\n   5. Application of this License. This License applies to code to which the Initial Developer has attached the notice in Exhibit A and to related Covered Code.\n\n   6. Versions of the License.\n\n   6.1 New Versions. The Storage Networking Industry Association (the \"SNIA\") may publish revised and/or new versions of the License from time to time. Each version will be given a distinguishing version number.\n\n   6.2 Effect of New Versions. Once Covered Code has been published under a particular version of the License, You may always continue to use it under the terms of that version. You may also choose to use such Covered Code under the terms of any subsequent version of the License published by the SNIA. No one other than the SNIA has the right to modify the terms applicable to Covered Code created under this License.\n\n   6.3 Derivative Works. If You create or use a modified version of this License (which you may only do in order to apply it to code which is not already Covered Code governed by this License), You must (a) rename Your license so that the phrases \"Storage Networking Industry Association,\" \"SNIA,\" or any confusingly similar phrase do not appear in your license (except to note that your license differs from this License) and (b) otherwise make it clear that Your version of the license contains terms which differ from the SNIA Public License. (Filling in the name of the Initial Developer, Original Code or Contributor in the notice described in Exhibit A shall not of themselves be deemed to be modifications of this License.)\n\n   7. DISCLAIMER OF WARRANTY. COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN \"AS IS\" BASIS, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER.\n\n   8. TERMINATION.\n\n   8.1 This License and the rights granted hereunder will terminate automatically if You fail to comply with terms herein and fail to cure such breach within a reasonable time after becoming aware of the breach. All sublicenses to the Covered Code which are properly granted shall survive any termination of this License. Provisions which, by their nature, must remain in effect beyond the termination of this License shall survive.\n\n   8.2 If You initiate litigation by asserting a patent infringement claim (excluding declaratory judgment actions) against Initial Developer or a Contributor (the Initial Developer or Contributor against whom You file such action is referred to as \"Participant\") alleging that: o (a) such Participant's Contributor Version directly or indirectly infringes any patent, then any and all rights granted by such Participant to You under Sections 2.1 and/or 2.2 of this License shall, upon 60 days notice from Participant terminate prospectively, unless if within 60 days after receipt of notice You either: (i) agree in writing to pay Participant a mutually agreeable reasonable royalty for Your past and future use of Modifications made by such Participant, or (ii) withdraw Your litigation claim with respect to the Contributor Version against such Participant. If within 60 days of notice, a reasonable royalty and payment arrangement are not mutually agreed upon in writing by the parties or the litigation claim is not withdrawn, the rights granted by Participant to You under Sections 2.1 and/or 2.2 automatically terminate at the expiration of the 60 day notice period specified above.\n\n   8.3 If You assert a patent infringement claim against Participant alleging that such Participant's Contributor Version directly or indirectly infringes any patent where such claim is resolved (such as by license or settlement) prior to the initiation of patent infringement litigation, then the reasonable value of the licenses granted by such Participant under Sections 2.1 or 2.2 shall be taken into account in determining the amount or value of any payment or license.\n\n   8.4 In the event of termination under Sections 8.1 or 8.2 above, all end user license agreements (excluding distributors and resellers) which have been validly granted by You or any distributor hereunder prior to termination shall survive termination.\n\n   9. LIMITATION OF LIABILITY. UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER TORT (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL YOU, THE INITIAL DEVELOPER, ANY OTHER CONTRIBUTOR, OR ANY DISTRIBUTOR OF COVERED CODE, OR ANY SUPPLIER OF ANY OF SUCH PARTIES, BE LIABLE TO ANY PERSON FOR ANY INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, COMPUTER FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER COMMERCIAL DAMAGES OR LOSSES, EVEN IF SUCH PARTY SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF LIABILITY SHALL NOT APPLY TO LIABILITY FOR DEATH OR PERSONAL INJURY RESULTING FROM SUCH PARTY'S NEGLIGENCE TO THE EXTENT APPLICABLE LAW PROHIBITS SUCH LIMITATION. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OR LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THIS EXCLUSION AND LIMITATION MAY NOT APPLY TO YOU.\n\n   10. U.S. GOVERNMENT END USERS. The Covered Code is a \"commercial item,\" as that term is defined in 48 C.F.R. 2.101 (Oct. 1995), consisting of \"commercial computer software\" and \"commercial computer software documentation,\" as such terms are used in 48 C.F.R. 12.212 (Sept. 1995). Consistent with 48 C.F.R. 12.212 and 48 C.F.R. 227.7202-1 through 227.7202-4 (June 1995), all U.S. Government End Users acquire Covered Code with only those rights set forth herein.\n\n   11. MISCELLANEOUS This License represents the complete agreement concerning subject matter hereof. If any provision of this License is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable. This License shall be governed by California law provisions (except to the extent applicable law, if any, provides otherwise), excluding its conflict-of-law provisions. The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded. Any law or regulation which provides that the language of a contract shall be construed against the drafter shall not apply to this License.\n\n   12. RESPONSIBILITY FOR CLAIMS. As between Initial Developer and the Contributors, each party is responsible for claims and damages arising, directly or indirectly, out of its utilization of rights under this License and You agree to work with Initial Developer and Contributors to distribute such responsibility on an equitable basis. Nothing herein is intended or shall be deemed to constitute any admission of liability.\n\n   13. MULTIPLE-LICENSED CODE. Initial Developer may designate portions of the Covered Code as \"Multiple-Licensed\". \"Multiple-Licensed\" means that the Initial Developer permits you to utilize portions of the Covered Code under Your choice of this License or the alternative licenses, if any, specified by the Initial Developer in the file described in Exhibit A.\n\n   14. ACCEPTANCE. This License is accepted by You if You retain, use, or distribute the Covered Code for any purpose. EXHIBIT A The SNIA Public License.\n\nThe contents of this file are subject to the SNIA Public License Version 1.0 (the \"License\"); you may not use this file except in compliance with the License. You may obtain a copy of the License at\n\nwww.snia.org/smi/developers/cim/\n\nSoftware distributed under the License is distributed on an \"AS IS\" basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the specific language governing rights and limitations under the License.\n\nThe Original Code is .\n\nThe Initial Developer of the Original Code is [COMPLETE THIS] .\n\nContributor(s): ______________________________________.\n\nRead more about this license at http://www.snia.org/smi/developers/open_source/"],"licenseIds":["SNIA"],"keywords":["industry association public","association public license","1 5 electronic","5 electronic distribution","data 1 6","6 executable means","1 7 initial","7 initial developer","1 8 larger","8 larger work","1 9 license","9 license means","document 1 10","1 10 licensable","10 licensable means","herein 1 11","1 11 modifications","11 modifications means","modifications 1 12","1 12 original","12 original code","license 1 13","1 13 patent","13 patent claims","grantor 1 14","1 14 source","14 source code","charge 1 15","1 15 you","15 you or","available thereafter b","thereafter b contributor","b contributor api","contributor api s","api s if","s if contributor","actual knowledge of","would be most","be most likely","most likely to","fulfilled the obligation","obligation of section","versions the storage","the storage networking","industry association the","association the snia","the snia may","snia may publish","by the snia","the snia no","snia no one","than the snia","the snia has","snia has the","the phrases storage","phrases storage networking","industry association snia","association snia or","snia or any","from the snia","breach within a","alleging that o","that o a","o a such","specified above 8","above 8 3","choice of this","a 14 acceptance","14 acceptance this","license is accepted","accepted by you","by you if","if you retain","you retain use","retain use or","any purpose exhibit","purpose exhibit a","a the snia","to the snia","license at www","at www snia","smi developers cim","developers cim software","cim software distributed","code is complete","is complete this","complete this contributor","this contributor s","contributor s read","s read more","read more about","more about this","about this license","http www snia","smi developers open","developers open source","networking industry association public","industry association public license","association public license version","2 contributor means each","modifications 1 3 contributor","thereof 1 5 electronic","1 5 electronic distribution","5 electronic distribution mechanism","of data 1 6","data 1 6 executable","1 6 executable means","6 executable means covered","source code 1 7","code 1 7 initial","1 7 initial developer","7 initial developer means","a 1 8 larger","1 8 larger work","8 larger work means","license 1 9 license","1 9 license means","9 license means this","this document 1 10","document 1 10 licensable","1 10 licensable means","10 licensable means having","conveyed herein 1 11","herein 1 11 modifications","1 11 modifications means","11 modifications means any","previous modifications 1 12","modifications 1 12 original","1 12 original code","12 original code means","this license 1 13","license 1 13 patent","1 13 patent claims","13 patent claims means","by grantor 1 14","grantor 1 14 source","1 14 source code","14 source code means","no charge 1 15","charge 1 15 you","1 15 you or","15 you or your","if contributor has actual","has actual knowledge that","actual knowledge that a","makes available thereafter b","available thereafter b contributor","thereafter b contributor api","b contributor api s","contributor api s if","api s if contributor","s if contributor s","and contributor has actual","has actual knowledge of","actual knowledge of patent","user would be most","would be most likely","be most likely to","most likely to look","have fulfilled the obligation","fulfilled the obligation of","the obligation of section","obligation of section 3","new versions the storage","versions the storage networking","the storage networking industry","networking industry association the","industry association the snia","association the snia may","the snia may publish","snia may publish revised","published by the snia","by the snia no","the snia no one","snia no one other","other than the snia","than the snia has","the snia has the","snia has the right","that the phrases storage","the phrases storage networking","phrases storage networking industry","networking industry association snia","industry association snia or","association snia or any","snia or any confusingly","differ from the snia","from the snia public","snia public license filling","such breach within a","breach within a reasonable","reasonable time after becoming","participant alleging that o","alleging that o a","that o a such","o a such participant","period specified above 8","specified above 8 3","above 8 3 if","your choice of this"]},{"licenseTexts":["SUN PUBLIC LICENSE Version 1.0\n\n   1. Definitions.\n\n      1.0.1. \"Commercial Use\" means distribution or otherwise making the Covered Code available to a third party.\n\n      1.1. \"Contributor\" means each entity that creates or contributes to the creation of Modifications.\n\n      1.2. \"Contributor Version\" means the combination of the Original Code, prior Modifications used by a Contributor, and the Modifications made by that particular Contributor.\n\n      1.3. \"Covered Code\" means the Original Code or Modifications or the combination of the Original Code and Modifications, in each case including portions thereof and corresponding documentation released with the source code.\n\n      1.4. \"Electronic Distribution Mechanism\" means a mechanism generally accepted in the software development community for the electronic transfer of data.\n\n      1.5. \"Executable\" means Covered Code in any form other than Source Code.\n\n      1.6. \"Initial Developer\" means the individual or entity identified as the Initial Developer in the Source Code notice required by Exhibit A.\n\n      1.7. \"Larger Work\" means a work which combines Covered Code or portions thereof with code not governed by the terms of this License.\n\n      1.8. \"License\" means this document.\n\n      1.8.1. \"Licensable\" means having the right to grant, to the maximum extent possible, whether at the time of the initial grant or subsequently acquired, any and all of the rights conveyed herein.\n\n      1.9. \"Modifications\" means any addition to or deletion from the substance or structure of either the Original Code or any previous Modifications. When Covered Code is released as a series of files, a Modification is:\n\n         A. Any addition to or deletion from the contents of a file containing Original Code or previous Modifications.\n\n         B. Any new file that contains any part of the Original Code or previous Modifications.\n\n      1.10. \"Original Code\"../ means Source Code of computer software code which is described in the Source Code notice required by Exhibit A as Original Code, and which, at the time of its release under this License is not already Covered Code governed by this License.\n\n      1.10.1. \"Patent Claims\" means any patent claim(s), now owned or hereafter acquired, including without limitation, method, process, and apparatus claims, in any patent Licensable by grantor.\n\n      1.11. \"Source Code\"../ means the preferred form of the Covered Code for making modifications to it, including all modules it contains, plus any associated documentation, interface definition files, scripts used to control compilation and installation of an Executable, or source code differential comparisons against either the Original Code or another well known, available Covered Code of the Contributor's choice. The Source Code can be in a compressed or archival form, provided the appropriate decompression or de-archiving software is widely available for no charge.\n\n      1.12. \"You\" (or \"Your\") means an individual or a legal entity exercising rights under, and complying with all of the terms of, this License or a future version of this License issued under Section 6.1. For legal entities, \"You\" includes any entity which controls, is controlled by, or is under common control with You. For purposes of this definition, \"control\"../ means (a) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (b) ownership of more than fifty percent (50%) of the outstanding shares or beneficial ownership of such entity.\n\n   2. Source Code License.\n\n      2.1 The Initial Developer Grant. The Initial Developer hereby grants You a world-wide, royalty-free, non-exclusive license, subject to third party intellectual property claims:\n\n         (a) under intellectual property rights (other than patent or trademark) Licensable by Initial Developer to use, reproduce, modify, display, perform, sublicense and distribute the Original Code (or portions thereof) with or without Modifications, and/or as part of a Larger Work; and\n\n         (b) under Patent Claims infringed by the making, using or selling of Original Code, to make, have made, use, practice, sell, and offer for sale, and/or otherwise dispose of the Original Code (or portions thereof).\n\n         (c) the licenses granted in this Section 2.1(a) and (b) are effective on the date Initial Developer first distributes Original Code under the terms of this License.\n\n         (d) Notwithstanding Section 2.1(b) above, no patent license is granted: 1) for code that You delete from the Original Code; 2) separate from the Original Code; or 3) for infringements caused by:\n\n            i) the modification of the Original Code or\n\n            ii) the combination of the Original Code with other software or devices.\n\n      2.2. Contributor Grant. Subject to third party intellectual property claims, each Contributor hereby grants You a world-wide, royalty-free, non-exclusive license\n\n         (a) under intellectual property rights (other than patent or trademark) Licensable by Contributor, to use, reproduce, modify, display, perform, sublicense and distribute the Modifications created by such Contributor (or portions thereof) either on an unmodified basis, with other Modifications, as Covered Code and/or as part of a Larger Work; and\n\n         b) under Patent Claims infringed by the making, using, or selling of Modifications made by that Contributor either alone and/or in combination with its Contributor Version (or portions of such combination), to make, use, sell, offer for sale, have made, and/or otherwise dispose of: 1) Modifications made by that Contributor (or portions thereof); and 2) the combination of Modifications made by that Contributor with its Contributor Version (or portions of such combination).\n\n         (c) the licenses granted in Sections 2.2(a) and 2.2(b) are effective on the date Contributor first makes Commercial Use of the Covered Code.\n\n         (d) notwithstanding Section 2.2(b) above, no patent license is granted: 1) for any code that Contributor has deleted from the Contributor Version; 2) separate from the Contributor Version; 3) for infringements caused by: i) third party modifications of Contributor Version or ii) the combination of Modifications made by that Contributor with other software (except as part of the Contributor Version) or other devices; or 4) under Patent Claims infringed by Covered Code in the absence of Modifications made by that Contributor.\n\n   3. Distribution Obligations.\n\n      3.1. Application of License. The Modifications which You create or to which You contribute are governed by the terms of this License, including without limitation Section 2.2. The Source Code version of Covered Code may be distributed only under the terms of this License or a future version of this License released under Section 6.1, and You must include a copy of this License with every copy of the Source Code You distribute. You may not offer or impose any terms on any Source Code version that alters or restricts the applicable version of this License or the recipients' rights hereunder. However, You may include an additional document offering the additional rights described in Section 3.5.\n\n      3.2. Availability of Source Code. Any Modification which You create or to which You contribute must be made available in Source Code form under the terms of this License either on the same media as an Executable version or via an accepted Electronic Distribution Mechanism to anyone to whom you made an Executable version available; and if made available via Electronic Distribution Mechanism, must remain available for at least twelve (12) months after the date it initially became available, or at least six (6) months after a subsequent version of that particular Modification has been made available to such recipients. You are responsible for ensuring that the Source Code version remains available even if the Electronic Distribution Mechanism is maintained by a third party.\n\n      3.3. Description of Modifications. You must cause all Covered Code to which You contribute to contain a file documenting the changes You made to create that Covered Code and the date of any change. You must include a prominent statement that the Modification is derived, directly or indirectly, from Original Code provided by the Initial Developer and including the name of the Initial Developer in (a) the Source Code, and (b) in any notice in an Executable version or related documentation in which You describe the origin or ownership of the Covered Code.\n\n      3.4. Intellectual Property Matters.\n\n         (a) Third Party Claims. If Contributor has knowledge that a license under a third party's intellectual property rights is required to exercise the rights granted by such Contributor under Sections 2.1 or 2.2, Contributor must include a text file with the Source Code distribution titled \"../LEGAL'' which describes the claim and the party making the claim in sufficient detail that a recipient will know whom to contact. If Contributor obtains such knowledge after the Modification is made available as described in Section 3.2, Contributor shall promptly modify the LEGAL file in all copies Contributor makes available thereafter and shall take other steps (such as notifying appropriate mailing lists or newsgroups) reasonably calculated to inform those who received the Covered Code that new knowledge has been obtained.\n\n         (b) Contributor APIs. If Contributor's Modifications include an application programming interface (\"API\"../) and Contributor has knowledge of patent licenses which are reasonably necessary to implement that API, Contributor must also include this information in the LEGAL file.\n\n         (c) Representations. Contributor represents that, except as disclosed pursuant to Section 3.4(a) above, Contributor believes that Contributor's Modifications are Contributor's original creation(s) and/or Contributor has sufficient rights to grant the rights conveyed by this License.\n\n      3.5. Required Notices. You must duplicate the notice in Exhibit A in each file of the Source Code. If it is not possible to put such notice in a particular Source Code file due to its structure, then You must include such notice in a location (such as a relevant directory) where a user would be likely to look for such a notice. If You created one or more Modification(s) You may add your name as a Contributor to the notice described in Exhibit A. You must also duplicate this License in any documentation for the Source Code where You describe recipients' rights or ownership rights relating to Covered Code. You may choose to offer, and to charge a fee for, warranty, support, indemnity or liability obligations to one or more recipients of Covered Code. However, You may do so only on Your own behalf, and not on behalf of the Initial Developer or any Contributor. You must make it absolutely clear than any such warranty, support, indemnity or liability obligation is offered by You alone, and You hereby agree to indemnify the Initial Developer and every Contributor for any liability incurred by the Initial Developer or such Contributor as a result of warranty, support, indemnity or liability terms You offer.\n\n      3.6. Distribution of Executable Versions. You may distribute Covered Code in Executable form only if the requirements of Section 3.1-3.5 have been met for that Covered Code, and if You include a notice stating that the Source Code version of the Covered Code is available under the terms of this License, including a description of how and where You have fulfilled the obligations of Section 3.2. The notice must be conspicuously included in any notice in an Executable version, related documentation or collateral in which You describe recipients' rights relating to the Covered Code. You may distribute the Executable version of Covered Code or ownership rights under a license of Your choice, which may contain terms different from this License, provided that You are in compliance with the terms of this License and that the license for the Executable version does not attempt to limit or alter the recipient's rights in the Source Code version from the rights set forth in this License. If You distribute the Executable version under a different license You must make it absolutely clear that any terms which differ from this License are offered by You alone, not by the Initial Developer or any Contributor. You hereby agree to indemnify the Initial Developer and every Contributor for any liability incurred by the Initial Developer or such Contributor as a result of any such terms You offer.\n\n      3.7. Larger Works. You may create a Larger Work by combining Covered Code with other code not governed by the terms of this License and distribute the Larger Work as a single product. In such a case, You must make sure the requirements of this License are fulfilled for the Covered Code.\n\n   4. Inability to Comply Due to Statute or Regulation.\n\n   If it is impossible for You to comply with any of the terms of this License with respect to some or all of the Covered Code due to statute, judicial order, or regulation then You must: (a) comply with the terms of this License to the maximum extent possible; and (b) describe the limitations and the code they affect. Such description must be included in the LEGAL file described in Section 3.4 and must be included with all distributions of the Source Code. Except to the extent prohibited by statute or regulation, such description must be sufficiently detailed for a recipient of ordinary skill to be able to understand it.\n\n   5. Application of this License.\n\n   This License applies to code to which the Initial Developer has attached the notice in Exhibit A and to related Covered Code.\n\n   6. Versions of the License.\n\n      6.1. New Versions. Sun Microsystems, Inc. (\"Sun\") may publish revised and/or new versions of the License from time to time. Each version will be given a distinguishing version number.\n\n      6.2. Effect of New Versions. Once Covered Code has been published under a particular version of the License, You may always continue to use it under the terms of that version. You may also choose to use such Covered Code under the terms of any subsequent version of the License published by Sun. No one other than Sun has the right to modify the terms applicable to Covered Code created under this License.\n\n      6.3. Derivative Works. If You create or use a modified version of this License (which you may only do in order to apply it to code which is not already Covered Code governed by this License), You must: (a) rename Your license so that the phrases \"Sun,\" \"Sun Public License,\" or \"SPL\"../ or any confusingly similar phrase do not appear in your license (except to note that your license differs from this License) and (b) otherwise make it clear that Your version of the license contains terms which differ from the Sun Public License. (Filling in the name of the Initial Developer, Original Code or Contributor in the notice described in Exhibit A shall not of themselves be deemed to be modifications of this License.)\n\n   7. DISCLAIMER OF WARRANTY.\n\n   COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN \"../AS IS'' BASIS, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER.\n\n   8. TERMINATION.\n\n      8.1. This License and the rights granted hereunder will terminate automatically if You fail to comply with terms herein and fail to cure such breach within 30 days of becoming aware of the breach. All sublicenses to the Covered Code which are properly granted shall survive any termination of this License. Provisions which, by their nature, must remain in effect beyond the termination of this License shall survive.\n\n      8.2. If You initiate litigation by asserting a patent infringement claim (excluding declaratory judgment actions) against Initial Developer or a Contributor (the Initial Developer or Contributor against whom You file such action is referred to as \"Participant\") alleging that:\n\n         (a) such Participant's Contributor Version directly or indirectly infringes any patent, then any and all rights granted by such Participant to You under Sections 2.1 and/or 2.2 of this License shall, upon 60 days notice from Participant terminate prospectively, unless if within 60 days after receipt of notice You either: (i) agree in writing to pay Participant a mutually agreeable reasonable royalty for Your past and future use of Modifications made by such Participant, or (ii) withdraw Your litigation claim with respect to the Contributor Version against such Participant. If within 60 days of notice, a reasonable royalty and payment arrangement are not mutually agreed upon in writing by the parties or the litigation claim is not withdrawn, the rights granted by Participant to You under Sections 2.1 and/or 2.2 automatically terminate at the expiration of the 60 day notice period specified above.\n\n         (b) any software, hardware, or device, other than such Participant's Contributor Version, directly or indirectly infringes any patent, then any rights granted to You by such Participant under Sections 2.1(b) and 2.2(b) are revoked effective as of the date You first made, used, sold, distributed, or had made, Modifications made by that Participant.\n\n      8.3. If You assert a patent infringement claim against Participant alleging that such Participant's Contributor Version directly or indirectly infringes any patent where such claim is resolved (such as by license or settlement) prior to the initiation of patent infringement litigation, then the reasonable value of the licenses granted by such Participant under Sections 2.1 or 2.2 shall be taken into account in determining the amount or value of any payment or license.\n\n      8.4. In the event of termination under Sections 8.1 or 8.2 above, all end user license agreements (excluding distributors and resellers) which have been validly granted by You or any distributor hereunder prior to termination shall survive termination.\n\n   9. LIMITATION OF LIABILITY.\n\n   UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER TORT (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL YOU, THE INITIAL DEVELOPER, ANY OTHER CONTRIBUTOR, OR ANY DISTRIBUTOR OF COVERED CODE, OR ANY SUPPLIER OF ANY OF SUCH PARTIES, BE LIABLE TO ANY PERSON FOR ANY INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, COMPUTER FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER COMMERCIAL DAMAGES OR LOSSES, EVEN IF SUCH PARTY SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF LIABILITY SHALL NOT APPLY TO LIABILITY FOR DEATH OR PERSONAL INJURY RESULTING FROM SUCH PARTY'S NEGLIGENCE TO THE EXTENT APPLICABLE LAW PROHIBITS SUCH LIMITATION. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OR LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THIS EXCLUSION AND LIMITATION MAY NOT APPLY TO YOU.\n\n   10. U.S. GOVERNMENT END USERS.\n\n   The Covered Code is a \"commercial item,\" as that term is defined in 48 C.F.R. 2.101 (Oct. 1995), consisting of \"commercial computer software\" and \"commercial computer software documentation,\"../ as such terms are used in 48 C.F.R. 12.212 (Sept. 1995). Consistent with 48 C.F.R. 12.212 and 48 C.F.R. 227.7202-1 through 227.7202-4 (June 1995), all U.S. Government End Users acquire Covered Code with only those rights set forth herein.\n\n   11. MISCELLANEOUS.\n\n   This License represents the complete agreement concerning subject matter hereof. If any provision of this License is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable. This License shall be governed by California law provisions (except to the extent applicable law, if any, provides otherwise), excluding its conflict-of-law provisions. With respect to disputes in which at least one party is a citizen of, or an entity chartered or registered to do business in the United States of America, any litigation relating to this License shall be subject to the jurisdiction of the Federal Courts of the Northern District of California, with venue lying in Santa Clara County, California, with the losing party responsible for costs, including without limitation, court costs and reasonable attorneys' fees and expenses. The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded. Any law or regulation which provides that the language of a contract shall be construed against the drafter shall not apply to this License.\n\n   12. RESPONSIBILITY FOR CLAIMS.\n\n   As between Initial Developer and the Contributors, each party is responsible for claims and damages arising, directly or indirectly, out of its utilization of rights under this License and You agree to work with Initial Developer and Contributors to distribute such responsibility on an equitable basis. Nothing herein is intended or shall be deemed to constitute any admission of liability.\n\n   13. MULTIPLE-LICENSED CODE.\n\n   Initial Developer may designate portions of the Covered Code as ?Multiple-Licensed?. ?Multiple-Licensed? means that the Initial Developer permits you to utilize portions of the Covered Code under Your choice of the alternative licenses, if any, specified by the Initial Developer in the file described in Exhibit A. Exhibit A -Sun Public License Notice.\n\nThe contents of this file are subject to the Sun Public License Version 1.0 (the License); you may not use this file except in compliance with the License. A copy of the License is available at http://www.sun.com/\n\nThe Original Code is _________________ . The Initial Developer of the Original Code is ___________ . Portions created by ______ are Copyright (C) _________ . All Rights Reserved.\n\nContributor(s): ______________________________________ .\n\nAlternatively, the contents of this file may be used under the terms of the _____ license (the ?[___] License? ), in which case the provisions of [______] License are applicable instead of those above. If you wish to allow use of your version of this file only under the terms of the [____] License and not to allow others to use your version of this file under the SPL, indicate your decision by deleting the provisions above and replace them with the notice and other provisions required by the [___] License. If you do not delete the provisions above, a recipient may use your version of this file under either the SPL or the [___] License.\n\n[NOTE: The text of this Exhibit A may differ slightly from the text of the notices in the Source Code files of the Original Code. You should use the text of this Exhibit A rather than the text found in the Original Code Source Code for Your Modifications.]"],"licenseIds":["SPL-1.0"],"keywords":["thereof and corresponding","and corresponding documentation","corresponding documentation released","documentation released with","released with the","code 1 4","api and contributor","inc sun may","the phrases sun","phrases sun sun","sun sun public","license or spl","or spl or","from the sun","of the alternative","a sun public","public license notice","notice the contents","license is available","http www sun","www sun com","sun com the","com the original","under the spl","the spl indicate","spl indicate your","either the spl","including portions thereof and","portions thereof and corresponding","thereof and corresponding documentation","and corresponding documentation released","corresponding documentation released with","documentation released with the","released with the source","the source code 1","source code 1 4","code 1 4 electronic","plus any associated documentation","interface api and contributor","api and contributor has","microsystems inc sun may","inc sun may publish","that the phrases sun","the phrases sun sun","phrases sun sun public","sun sun public license","sun public license or","public license or spl","license or spl or","or spl or any","differ from the sun","from the sun public","sun public license filling","choice of the alternative","of the alternative licenses","a exhibit a sun","exhibit a sun public","a sun public license","sun public license notice","public license notice the","license notice the contents","notice the contents of","to the sun public","with the license a","the license is available","license is available at","is available at http","at http www sun","http www sun com","www sun com the","sun com the original","com the original code","file under the spl","under the spl indicate","the spl indicate your","spl indicate your decision","under either the spl","either the spl or","spl or the license","case including portions thereof and","including portions thereof and corresponding","portions thereof and corresponding documentation","thereof and corresponding documentation released","and corresponding documentation released with","corresponding documentation released with the","documentation released with the source","released with the source code","with the source code 1","the source code 1 4","source code 1 4 electronic","code 1 4 electronic distribution","contains plus any associated documentation","plus any associated documentation interface","documentation interface definition files scripts","programming interface api and contributor","interface api and contributor has","api and contributor has knowledge","versions sun microsystems inc sun","sun microsystems inc sun may","microsystems inc sun may publish","inc sun may publish revised","so that the phrases sun","that the phrases sun sun","the phrases sun sun public","phrases sun sun public license","sun sun public license or","sun public license or spl","public license or spl or","license or spl or any","or spl or any confusingly","which differ from the sun","differ from the sun public","from the sun public license","the sun public license filling","sun public license filling in","your choice of the alternative","choice of the alternative licenses","of the alternative licenses if","exhibit a exhibit a sun","a exhibit a sun public","exhibit a sun public license","a sun public license notice","sun public license notice the","public license notice the contents","license notice the contents of","notice the contents of this","subject to the sun public","to the sun public license","the sun public license version","compliance with the license a","with the license a copy","of the license is available","the license is available at","license is available at http","is available at http www","available at http www sun","at http www sun com","http www sun com the","www sun com the original","sun com the original code","com the original code is","this file under the spl","file under the spl indicate","under the spl indicate your","the spl indicate your decision","spl indicate your decision by","file under either the spl","under either the spl or","either the spl or the","the spl or the license","spl or the license note"]},{"licenseTexts":["Copyright (c) 1995 Tatu Ylonen \u003cylo@cs.hut.fi\u003e, Espoo, Finland All rights reserved\n\nAs far as I am concerned, the code I have written for this software can be used freely for any purpose. Any derived versions of this software must be clearly marked as such, and if the derived work is incompatible with the protocol description in the RFC file, it must be called by a name other than \"ssh\" or \"Secure Shell\".\n\n[Tatu continues]\n\nHowever, I am not implying to give any licenses to any patents or copyrights held by third parties, and the software includes parts that are not under my direct control. As far as I know, all included source code is used in accordance with the relevant license agreements and can be used freely for any purpose (the GNU license being the most restrictive); see below for details.\n\n[However, none of that term is relevant at this point in time. All of these restrictively licenced software components which he talks about have been removed from OpenSSH, i.e.,\n\n   - RSA is no longer included, found in the OpenSSL library\n\n   - IDEA is no longer included, its use is deprecated\n\n   - DES is now external, in the OpenSSL library\n\n   - GMP is no longer used, and instead we call BN code from OpenSSL\n\n   - Zlib is now external, in a library\n\n   - The make-ssh-known-hosts script is no longer included\n\n   - TSS has been removed\n\n   - MD5 is now external, in the OpenSSL library\n\n   - RC4 support has been replaced with ARC4 support from OpenSSL\n\n   - Blowfish is now external, in the OpenSSL library\n\n[The licence continues]\n\nNote that any information and cryptographic algorithms used in this software are publicly available on the Internet and at any major bookstore, scientific library, and patent office worldwide. More information can be found e.g. at \"http://www.cs.hut.fi/crypto\".\n\nThe legal status of this program is some combination of all these permissions and restrictions. Use only at your own responsibility. You will be responsible for any legal consequences yourself; I am not making any claims whether possessing or using this is legal or not in your country, and I am not taking any responsibility on your behalf.\n\nNO WARRANTY\n\nBECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM \"AS IS\" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.\n\nIN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES."],"licenseIds":["SSH-OpenSSH"],"keywords":["c 1995 tatu","1995 tatu ylonen","tatu ylonen ylo","ylonen ylo cs","ylo cs hut","hut fi espoo","fi espoo finland","espoo finland all","finland all rights","rights reserved as","reserved as far","secure shell tatu","shell tatu continues","tatu continues however","continues however i","however i am","am not implying","not implying to","implying to give","give any licenses","any licenses to","patents or copyrights","or copyrights held","copyrights held by","held by third","third parties and","the software includes","software includes parts","includes parts that","parts that are","not under my","under my direct","my direct control","direct control as","control as far","as i know","i know all","know all included","all included source","included source code","with the relevant","the relevant license","relevant license agreements","license agreements and","agreements and can","purpose the gnu","the gnu license","gnu license being","license being the","being the most","the most restrictive","most restrictive see","restrictive see below","see below for","below for details","for details however","details however none","however none of","none of that","of that term","term is relevant","is relevant at","relevant at this","at this point","this point in","point in time","in time all","time all of","of these restrictively","these restrictively licenced","restrictively licenced software","licenced software components","software components which","components which he","which he talks","he talks about","talks about have","about have been","have been removed","removed from openssh","from openssh i","openssh i e","i e rsa","e rsa is","rsa is no","longer included found","included found in","openssl library idea","library idea is","idea is no","longer included its","included its use","use is deprecated","is deprecated des","deprecated des is","des is now","openssl library gmp","library gmp is","gmp is no","no longer used","longer used and","used and instead","and instead we","instead we call","we call bn","call bn code","bn code from","code from openssl","from openssl zlib","openssl zlib is","zlib is now","external in a","library the make","the make ssh","make ssh known","ssh known hosts","known hosts script","hosts script is","script is no","longer included tss","included tss has","tss has been","been removed md5","removed md5 is","md5 is now","openssl library rc4","library rc4 support","rc4 support has","has been replaced","been replaced with","replaced with arc4","with arc4 support","arc4 support from","support from openssl","from openssl blowfish","openssl blowfish is","blowfish is now","openssl library the","library the licence","the licence continues","licence continues note","continues note that","note that any","that any information","any information and","information and cryptographic","and cryptographic algorithms","cryptographic algorithms used","algorithms used in","software are publicly","are publicly available","publicly available on","available on the","internet and at","and at any","at any major","any major bookstore","major bookstore scientific","bookstore scientific library","scientific library and","library and patent","and patent office","patent office worldwide","office worldwide more","worldwide more information","more information can","information can be","be found e","found e g","e g at","g at http","www cs hut","hut fi crypto","fi crypto the","crypto the legal","the legal status","legal status of","program is some","is some combination","some combination of","combination of all","of all these","all these permissions","these permissions and","permissions and restrictions","and restrictions use","restrictions use only","use only at","only at your","your own responsibility","own responsibility you","responsibility you will","any legal consequences","legal consequences yourself","consequences yourself i","yourself i am","am not making","not making any","making any claims","any claims whether"]},{"licenseTexts":["As far as I am concerned, the code I have written for this software can be used freely for any purpose. Any derived versions of this software must be clearly marked as such, and if the derived work is incompatible with the protocol description in the RFC file, it must be called by a name other than \"ssh\" or \"Secure Shell\"."],"licenseIds":["SSH-short"],"keywords":null},{"licenseTexts":["Server Side Public License\n\nVERSION 1, OCTOBER 16, 2018\n\nCopyright © 2018 MongoDB, Inc.\n\nEveryone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.\n\nTERMS AND CONDITIONS\n\n   0. Definitions.\n\n   \"This License\" refers to Server Side Public License.\n\n   \"Copyright\" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks.\n\n   \"The Program\" refers to any copyrightable work licensed under this License. Each licensee is addressed as \"you\". \"Licensees\" and \"recipients\" may be individuals or organizations.\n\n   To \"modify\" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy. The resulting work is called a \"modified version\" of the earlier work or a work \"based on\" the earlier work.\n\n   A \"covered work\" means either the unmodified Program or a work based on the Program.\n\n   To \"propagate\" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy. Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well.\n\n   To \"convey\" a work means any kind of propagation that enables other parties to make or receive copies. Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying.\n\n   An interactive user interface displays \"Appropriate Legal Notices\" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License. If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion.\n\n   1. Source Code.\n\n   The \"source code\" for a work means the preferred form of the work for making modifications to it. \"Object code\" means any non-source form of a work.\n\n   A \"Standard Interface\" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language.\n\n   The \"System Libraries\" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form. A \"Major Component\", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it.\n\n   The \"Corresponding Source\" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities. However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work. For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work.\n\n   The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source.\n\n   The Corresponding Source for a work in source code form is that same work.\n\n   2. Basic Permissions.\n\n   All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met. This License explicitly affirms your unlimited permission to run the unmodified Program, subject to section 13. The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work. This License acknowledges your rights of fair use or other equivalent, as provided by copyright law.\n\n   Subject to section 13, you may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force. You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright. Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you.\n\n   Conveying under any other circumstances is permitted solely under the conditions stated below. Sublicensing is not allowed; section 10 makes it unnecessary.\n\n   3. Protecting Users' Legal Rights From Anti-Circumvention Law.\n\n   No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures.\n\n   When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures.\n\n   4. Conveying Verbatim Copies.\n\n   You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program.\n\n   You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee.\n\n   5. Conveying Modified Source Versions.\n\n   You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions:\n\n      a) The work must carry prominent notices stating that you modified it, and giving a relevant date.\n\n      b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7. This requirement modifies the requirement in section 4 to \"keep intact all notices\".\n\n      c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy. This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged. This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it.\n\n      d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so.\n\n   A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an \"aggregate\" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit. Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate.\n\n   6. Conveying Non-Source Forms.\n\n   You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways:\n\n      a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange.\n\n      b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge.\n\n      c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source. This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b.\n\n      d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge. You need not require recipients to copy the Corresponding Source along with the object code. If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source. Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements.\n\n      e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d.\n\n   A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work.\n\n   A \"User Product\" is either (1) a \"consumer product\", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling. In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage. For a particular product received by a particular user, \"normally used\" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product. A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product.\n\n   \"Installation Information\" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source. The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made.\n\n   If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information. But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM).\n\n   The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed. Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network.\n\n   Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying.\n\n   7. Additional Terms.\n\n   \"Additional permissions\" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law. If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions.\n\n   When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it. (Additional permissions may be written to require their own removal in certain cases when you modify the work.) You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission.\n\n   Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms:\n\n      a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or\n\n      b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or\n\n      c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or\n\n      d) Limiting the use for publicity purposes of names of licensors or authors of the material; or\n\n      e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or\n\n      f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors.\n\n   All other non-permissive additional terms are considered \"further restrictions\" within the meaning of section 10. If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term. If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying.\n\n   If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms.\n\n   Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way.\n\n   8. Termination.\n\n   You may not propagate or modify a covered work except as expressly provided under this License. Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11).\n\n   However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation.\n\n   Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice.\n\n   Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License. If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10.\n\n   9. Acceptance Not Required for Having Copies.\n\n   You are not required to accept this License in order to receive or run a copy of the Program. Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance. However, nothing other than this License grants you permission to propagate or modify any covered work. These actions infringe copyright if you do not accept this License. Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so.\n\n   10. Automatic Licensing of Downstream Recipients.\n\n   Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License. You are not responsible for enforcing compliance by third parties with this License.\n\n   An \"entity transaction\" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations. If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts.\n\n   You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License. For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it.\n\n   11. Patents.\n\n   A \"contributor\" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based. The work thus licensed is called the contributor's \"contributor version\".\n\n   A contributor's \"essential patent claims\" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version. For purposes of this definition, \"control\" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License.\n\n   Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version.\n\n   In the following three paragraphs, a \"patent license\" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement). To \"grant\" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party.\n\n   If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients. \"Knowingly relying\" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid.\n\n   If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it.\n\n   A patent license is \"discriminatory\" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License. You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007.\n\n   Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law.\n\n   12. No Surrender of Others' Freedom.\n\n   If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot use, propagate or convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not use, propagate or convey it at all. For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program.\n\n   13. Offering the Program as a Service.\n\n   If you make the functionality of the Program or a modified version available to third parties as a service, you must make the Service Source Code available via network download to everyone at no charge, under the terms of this License. Making the functionality of the Program or modified version available to third parties as a service includes, without limitation, enabling third parties to interact with the functionality of the Program or modified version remotely through a computer network, offering a service the value of which entirely or primarily derives from the value of the Program or modified version, or offering a service that accomplishes for users the primary purpose of the Program or modified version.\n\n   \"Service Source Code\" means the Corresponding Source for the Program or the modified version, and the Corresponding Source for all programs that you use to make the Program or modified version available as a service, including, without limitation, management software, user interfaces, application program interfaces, automation software, monitoring software, backup software, storage software and hosting software, all such that a user could run an instance of the service using the Service Source Code you make available.\n\n   14. Revised Versions of this License.\n\n   MongoDB, Inc. may publish revised and/or new versions of the Server Side Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.\n\n   Each version is given a distinguishing version number. If the Program specifies that a certain numbered version of the Server Side Public License \"or any later version\" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by MongoDB, Inc. If the Program does not specify a version number of the Server Side Public License, you may choose any version ever published by MongoDB, Inc.\n\n   If the Program specifies that a proxy can decide which future versions of the Server Side Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program.\n\n   Later license versions may give you additional or different permissions. However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version.\n\n   15. Disclaimer of Warranty.\n\n   THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM \"AS IS\" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.\n\n   16. Limitation of Liability.\n\n   IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\n   17. Interpretation of Sections 15 and 16.\n\n   If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee."],"licenseIds":["SSPL-1.0"],"keywords":["version 1 october","1 october 16","october 16 2018","16 2018 copyright","2018 copyright 2018","copyright 2018 mongodb","2018 mongodb inc","mongodb inc everyone","inc everyone is","not allowed terms","allowed terms and","refers to server","to server side","unmodified program subject","section 13 the","13 the output","copyright law subject","law subject to","section 13 you","13 you may","cannot use propagate","not use propagate","or convey it","program 13 offering","13 offering the","offering the program","a service if","make the functionality","a service you","service you must","make the service","code available via","available via network","via network download","network download to","download to everyone","to everyone at","everyone at no","this license making","license making the","making the functionality","a service includes","service includes without","without limitation enabling","limitation enabling third","enabling third parties","parties to interact","interact with the","with the functionality","modified version remotely","version remotely through","computer network offering","network offering a","a service the","service the value","value of which","of which entirely","which entirely or","entirely or primarily","or primarily derives","primarily derives from","derives from the","from the value","version or offering","or offering a","service that accomplishes","that accomplishes for","accomplishes for users","for users the","users the primary","the primary purpose","primary purpose of","modified version service","version service source","version and the","for all programs","all programs that","programs that you","you use to","use to make","make the program","version available as","available as a","without limitation management","limitation management software","management software user","software user interfaces","user interfaces application","interfaces application program","application program interfaces","program interfaces automation","interfaces automation software","automation software monitoring","software monitoring software","monitoring software backup","software backup software","backup software storage","software storage software","storage software and","software and hosting","and hosting software","hosting software all","software all such","all such that","such that a","that a user","a user could","user could run","could run an","run an instance","an instance of","instance of the","of the service","the service using","service using the","using the service","code you make","make available 14","available 14 revised","this license mongodb","license mongodb inc","mongodb inc may","side public license version","license version 1 october","version 1 october 16","1 october 16 2018","october 16 2018 copyright","16 2018 copyright 2018","2018 copyright 2018 mongodb","copyright 2018 mongodb inc","2018 mongodb inc everyone","mongodb inc everyone is","inc everyone is permitted","is not allowed terms","not allowed terms and","allowed terms and conditions","license refers to server","refers to server side","to server side public","side public license copyright","the unmodified program subject","unmodified program subject to","program subject to section","to section 13 the","section 13 the output","13 the output from","by copyright law subject","copyright law subject to","law subject to section","to section 13 you","section 13 you may","13 you may make","if you cannot use","you cannot use propagate","cannot use propagate or","propagate or convey a","or convey a covered","may not use propagate","not use propagate or","propagate or convey it","or convey it at","the program 13 offering","program 13 offering the","13 offering the program","offering the program as","the program as a","program as a service","as a service if","a service if you","service if you make","you make the functionality","make the functionality of","program or a modified","a modified version available","as a service you","a service you must","service you must make","must make the service","make the service source","service source code available","source code available via","code available via network","available via network download","via network download to","network download to everyone","download to everyone at","to everyone at no","everyone at no charge","no charge under the","of this license making","this license making the","license making the functionality","making the functionality of","as a service includes","a service includes without","service includes without limitation","includes without limitation enabling","without limitation enabling third","limitation enabling third parties","enabling third parties to"]},{"licenseTexts":["The authors hereby grant permission to use, copy, modify, distribute, and license this software and its documentation for any purpose, provided that existing copyright notices are retained in all copies and that this notice is included verbatim in any distributions. No written agreement, license, or royalty fee is required for any of the authorized uses. Modifications to this software may be copyrighted by their authors and need not follow the licensing terms described here, provided that the new terms are clearly indicated on the first page of each file where they apply.\n\nIN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION, OR ANY DERIVATIVES THEREOF, EVEN IF THE AUTHORS HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT. THIS SOFTWARE IS PROVIDED ON AN \"AS IS\" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.\n\nGOVERNMENT USE: If you are acquiring this software on behalf of the U.S. government, the Government shall have only \"Restricted Rights\" in the software and related documentation as defined in the Federal Acquisition Regulations (FARs) in Clause 52.227.19 (c) (2). If you are acquiring the software on behalf of the Department of Defense, the software shall be classified as \"Commercial Computer Software\" and the Government shall have only \"Restricted Rights\" as defined in Clause 252.227-7013 (c) (1) of DFARs. Notwithstanding the foregoing, the authors grant the U.S. Government and others acting in its behalf permission to use and distribute the software in accordance with the terms specified in this license.\n\nBY INSTALLING THIS SOFTWARE, YOU ACKNOWLEDGE THAT YOU HAVE READ THIS AGREEMENT, THAT YOU UNDERSTAND IT, AND THAT YOU AGREE TO BE BOUND BY ITS TERMS AND CONDITIONS."],"licenseIds":["SWL"],"keywords":["license by installing","by installing this","installing this software","software you acknowledge","acknowledge that you","have read this","read this agreement","this agreement that","agreement that you","you understand it","understand it and","that you agree","bound by its","by its terms","in this license by","this license by installing","license by installing this","by installing this software","installing this software you","this software you acknowledge","software you acknowledge that","you acknowledge that you","acknowledge that you have","you have read this","have read this agreement","read this agreement that","this agreement that you","agreement that you understand","that you understand it","you understand it and","understand it and that","it and that you","and that you agree","that you agree to","you agree to be","be bound by its","bound by its terms","by its terms and","specified in this license by","in this license by installing","this license by installing this","license by installing this software","by installing this software you","installing this software you acknowledge","this software you acknowledge that","software you acknowledge that you","you acknowledge that you have","acknowledge that you have read","that you have read this","you have read this agreement","have read this agreement that","read this agreement that you","this agreement that you understand","agreement that you understand it","that you understand it and","you understand it and that","understand it and that you","it and that you agree","and that you agree to","that you agree to be","you agree to be bound","to be bound by its","be bound by its terms","bound by its terms and","by its terms and conditions"]},{"licenseTexts":["Copyright (C) 2000-2002 werken digital.\n\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   1. Redistributions of source code must retain the above copyright notice, this list of conditions, and the following disclaimer.\n\n   2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions, and the disclaimer that follows these conditions in the documentation and/or other materials provided with the distribution.\n\n   3. The name \"SAXPath\" must not be used to endorse or promote products derived from this software without prior written permission. For written permission, please contact license@saxpath.org.\n\n   4. Products derived from this software may not be called \"SAXPath\", nor may \"SAXPath\" appear in their name, without prior written permission from the SAXPath Project Management (pm@saxpath.org).\n\nIn addition, we request (but do not require) that you include in the end-user documentation provided with the redistribution and/or in the software itself an acknowledgement equivalent to the following:\n\n\"This product includes software developed by the SAXPath Project (http://www.saxpath.org/).\"\n\nAlternatively, the acknowledgment may be graphical using the logos available at http://www.saxpath.org/\n\nTHIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE SAXPath AUTHORS OR THE PROJECT CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."],"licenseIds":["Saxpath"],"keywords":["2000 2002 werken","2002 werken digital","werken digital all","digital all rights","the disclaimer that","disclaimer that follows","that follows these","follows these conditions","these conditions in","the name saxpath","name saxpath must","saxpath must not","contact license saxpath","license saxpath org","saxpath org 4","be called saxpath","called saxpath nor","saxpath nor may","nor may saxpath","may saxpath appear","saxpath appear in","from the saxpath","saxpath project management","project management pm","management pm saxpath","pm saxpath org","saxpath org in","addition we request","we request but","request but do","in the end","user documentation provided","the redistribution and","redistribution and or","software itself an","itself an acknowledgement","an acknowledgement equivalent","acknowledgement equivalent to","equivalent to the","the following this","following this product","by the saxpath","saxpath project http","saxpath org alternatively","org alternatively the","alternatively the acknowledgment","the acknowledgment may","acknowledgment may be","may be graphical","be graphical using","graphical using the","using the logos","the logos available","saxpath org this","shall the saxpath","the saxpath authors","saxpath authors or","authors or the","or the project","the project contributors","project contributors be","c 2000 2002 werken","2000 2002 werken digital","2002 werken digital all","werken digital all rights","digital all rights reserved","and the disclaimer that","the disclaimer that follows","disclaimer that follows these","that follows these conditions","follows these conditions in","these conditions in the","3 the name saxpath","the name saxpath must","name saxpath must not","saxpath must not be","please contact license saxpath","contact license saxpath org","license saxpath org 4","saxpath org 4 products","not be called saxpath","be called saxpath nor","called saxpath nor may","saxpath nor may saxpath","nor may saxpath appear","may saxpath appear in","saxpath appear in their","permission from the saxpath","from the saxpath project","the saxpath project management","saxpath project management pm","project management pm saxpath","management pm saxpath org","pm saxpath org in","saxpath org in addition","org in addition we","in addition we request","addition we request but","we request but do","request but do not","require that you include","include in the end","in the end user","end user documentation provided","user documentation provided with","documentation provided with the","provided with the redistribution","with the redistribution and","the redistribution and or","redistribution and or in","and or in the","the software itself an","software itself an acknowledgement","itself an acknowledgement equivalent","an acknowledgement equivalent to","acknowledgement equivalent to the","equivalent to the following","to the following this","the following this product","following this product includes","developed by the saxpath","by the saxpath project","the saxpath project http","saxpath project http www","project http www saxpath","www saxpath org alternatively","saxpath org alternatively the","org alternatively the acknowledgment","alternatively the acknowledgment may","the acknowledgment may be","acknowledgment may be graphical","may be graphical using","be graphical using the","graphical using the logos","using the logos available","the logos available at","at http www saxpath","www saxpath org this","saxpath org this software","event shall the saxpath","shall the saxpath authors","the saxpath authors or","saxpath authors or the","authors or the project","or the project contributors","the project contributors be","project contributors be liable","copyright c 2000 2002 werken","c 2000 2002 werken digital","2000 2002 werken digital all","2002 werken digital all rights","werken digital all rights reserved","digital all rights reserved redistribution","conditions and the disclaimer that","and the disclaimer that follows","the disclaimer that follows these","disclaimer that follows these conditions","that follows these conditions in","follows these conditions in the","these conditions in the documentation","distribution 3 the name saxpath","3 the name saxpath must","the name saxpath must not","name saxpath must not be","saxpath must not be used","permission please contact license saxpath","please contact license saxpath org","contact license saxpath org 4","license saxpath org 4 products","saxpath org 4 products derived","may not be called saxpath","not be called saxpath nor","be called saxpath nor may","called saxpath nor may saxpath","saxpath nor may saxpath appear","nor may saxpath appear in","may saxpath appear in their","saxpath appear in their name","written permission from the saxpath","permission from the saxpath project","from the saxpath project management","the saxpath project management pm","saxpath project management pm saxpath","project management pm saxpath org","management pm saxpath org in","pm saxpath org in addition","saxpath org in addition we","org in addition we request","in addition we request but","addition we request but do","we request but do not","request but do not require","not require that you include","require that you include in","you include in the end","include in the end user","in the end user documentation","the end user documentation provided","end user documentation provided with","user documentation provided with the"]},{"licenseTexts":["SENDMAIL LICENSE The following license terms and conditions apply, unless a redistribution agreement or other license is obtained from Proofpoint, Inc., 892 Ross Street, Sunnyvale, CA, 94089, USA, or by electronic mail at sendmail-license@proofpoint.com.\n\nLicense Terms:\n\nUse, Modification and Redistribution (including distribution of any modified or derived work) in source and binary forms is permitted only if each of the following conditions is met:\n\n   1. Redistributions qualify as \"freeware\" or \"Open Source Software\" under one of the following terms:\n\n   (a) Redistributions are made at no charge beyond the reasonable cost of materials and delivery.\n\n   (b) Redistributions are accompanied by a copy of the Source Code or by an irrevocable offer to provide a copy of the Source Code for up to three years at the cost of materials and delivery. Such redistributions must allow further use, modification, and redistribution of the Source Code under substantially the same terms as this license. For the purposes of redistribution \"Source Code\" means the complete compilable and linkable source code of sendmail and associated libraries and utilities in the sendmail distribution including all modifications.\n\n   2. Redistributions of Source Code must retain the copyright notices as they appear in each Source Code file, these license terms, and the disclaimer/limitation of liability set forth as paragraph 6 below.\n\n   3. Redistributions in binary form must reproduce the Copyright Notice, these license terms, and the disclaimer/limitation of liability set forth as paragraph 6 below, in the documentation and/or other materials provided with the distribution. For the purposes of binary distribution the \"Copyright Notice\" refers to the following language:\n\n   \"Copyright (c) 1998-2014 Proofpoint, Inc. All rights reserved.\"\n\n   4. Neither the name of Proofpoint, Inc. nor the University of California nor names of their contributors may be used to endorse or promote products derived from this software without specific prior written permission. The name \"sendmail\" is a trademark of Proofpoint, Inc.\n\n   5. All redistributions must comply with the conditions imposed by the University of California on certain embedded code, which copyright Notice and conditions for redistribution are as follows:\n\n   (a) Copyright (c) 1988, 1993 The Regents of the University of California. All rights reserved.\n\n   (b) Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   (i) Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n   (ii) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   (iii) Neither the name of the University nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.\n\n   6. Disclaimer/Limitation of Liability: THIS SOFTWARE IS PROVIDED BY SENDMAIL, INC. AND CONTRIBUTORS \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SENDMAIL, INC., THE REGENTS OF THE UNIVERSITY OF CALIFORNIA OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. $Revision: 8.23 $, Last updated $Date: 2014-01-26 20:10:01 $, Document 139848.1"],"licenseIds":["Sendmail-8.23"],"keywords":["obtained from proofpoint","from proofpoint inc","proofpoint inc 892","inc 892 ross","892 ross street","ross street sunnyvale","street sunnyvale ca","sunnyvale ca 94089","ca 94089 usa","94089 usa or","mail at sendmail","at sendmail license","sendmail license proofpoint","license proofpoint com","proofpoint com license","of sendmail and","sendmail and associated","and associated libraries","associated libraries and","libraries and utilities","and utilities in","utilities in the","in the sendmail","the sendmail distribution","sendmail distribution including","distribution including all","c 1998 2014","1998 2014 proofpoint","2014 proofpoint inc","proofpoint inc all","name of proofpoint","proofpoint inc nor","trademark of proofpoint","proofpoint inc 5","revision 8 23","8 23 last","23 last updated","updated date 2014","date 2014 01","2014 01 26","01 26 20","26 20 10","20 10 01","10 01 document","01 document 139848","is obtained from proofpoint","obtained from proofpoint inc","from proofpoint inc 892","proofpoint inc 892 ross","inc 892 ross street","892 ross street sunnyvale","ross street sunnyvale ca","street sunnyvale ca 94089","sunnyvale ca 94089 usa","ca 94089 usa or","94089 usa or by","electronic mail at sendmail","mail at sendmail license","at sendmail license proofpoint","sendmail license proofpoint com","license proofpoint com license","proofpoint com license terms","code of sendmail and","of sendmail and associated","sendmail and associated libraries","and associated libraries and","associated libraries and utilities","libraries and utilities in","and utilities in the","utilities in the sendmail","in the sendmail distribution","the sendmail distribution including","sendmail distribution including all","distribution including all modifications","copyright c 1998 2014","c 1998 2014 proofpoint","1998 2014 proofpoint inc","2014 proofpoint inc all","proofpoint inc all rights","the name of proofpoint","name of proofpoint inc","of proofpoint inc nor","proofpoint inc nor the","a trademark of proofpoint","trademark of proofpoint inc","of proofpoint inc 5","proofpoint inc 5 all","damages revision 8 23","revision 8 23 last","8 23 last updated","23 last updated date","last updated date 2014","updated date 2014 01","date 2014 01 26","2014 01 26 20","01 26 20 10","26 20 10 01","20 10 01 document","10 01 document 139848","01 document 139848 1","license is obtained from proofpoint","is obtained from proofpoint inc","obtained from proofpoint inc 892","from proofpoint inc 892 ross","proofpoint inc 892 ross street","inc 892 ross street sunnyvale","892 ross street sunnyvale ca","ross street sunnyvale ca 94089","street sunnyvale ca 94089 usa","sunnyvale ca 94089 usa or","ca 94089 usa or by","94089 usa or by electronic","by electronic mail at sendmail","electronic mail at sendmail license","mail at sendmail license proofpoint","at sendmail license proofpoint com","sendmail license proofpoint com license","license proofpoint com license terms","proofpoint com license terms use","source code of sendmail and","code of sendmail and associated","of sendmail and associated libraries","sendmail and associated libraries and","and associated libraries and utilities","associated libraries and utilities in","libraries and utilities in the","and utilities in the sendmail","utilities in the sendmail distribution","in the sendmail distribution including","the sendmail distribution including all","sendmail distribution including all modifications","distribution including all modifications 2","language copyright c 1998 2014","copyright c 1998 2014 proofpoint","c 1998 2014 proofpoint inc","1998 2014 proofpoint inc all","2014 proofpoint inc all rights","proofpoint inc all rights reserved","neither the name of proofpoint","the name of proofpoint inc","name of proofpoint inc nor","of proofpoint inc nor the","proofpoint inc nor the university","is a trademark of proofpoint","a trademark of proofpoint inc","trademark of proofpoint inc 5","of proofpoint inc 5 all","proofpoint inc 5 all redistributions","such damages revision 8 23","damages revision 8 23 last","revision 8 23 last updated","8 23 last updated date","23 last updated date 2014","last updated date 2014 01","updated date 2014 01 26","date 2014 01 26 20","2014 01 26 20 10","01 26 20 10 01","26 20 10 01 document","20 10 01 document 139848","10 01 document 139848 1"]},{"licenseTexts":["SENDMAIL LICENSE The following license terms and conditions apply, unless a redistribution agreement or other license is obtained from Sendmail, Inc., 6475 Christie Ave, Third Floor, Emeryville, CA 94608, USA, or by electronic mail at license@sendmail.com.\n\nLicense Terms:\n\nUse, Modification and Redistribution (including distribution of any modified or derived work) in source and binary forms is permitted only if each of the following conditions is met:\n\n   1. Redistributions qualify as \"freeware\" or \"Open Source Software\" under one of the following terms:\n\n   (a) Redistributions are made at no charge beyond the reasonable cost of materials and delivery.\n\n   (b) Redistributions are accompanied by a copy of the Source Code or by an irrevocable offer to provide a copy of the Source Code for up to three years at the cost of materials and delivery. Such redistributions must allow further use, modification, and redistribution of the Source Code under substantially the same terms as this license. For the purposes of redistribution \"Source Code\" means the complete compilable and linkable source code of sendmail including all modifications.\n\n   2. Redistributions of Source Code must retain the copyright notices as they appear in each Source Code file, these license terms, and the disclaimer/limitation of liability set forth as paragraph 6 below.\n\n   3. Redistributions in binary form must reproduce the Copyright Notice, these license terms, and the disclaimer/limitation of liability set forth as paragraph 6 below, in the documentation and/or other materials provided with the distribution. For the purposes of binary distribution the \"Copyright Notice\" refers to the following language:\n\n   \"Copyright (c) 1998-2010 Sendmail, Inc. All rights reserved.\"\n\n   4. Neither the name of Sendmail, Inc. nor the University of California nor names of their contributors may be used to endorse or promote products derived from this software without specific prior written permission. The name \"sendmail\" is a trademark of Sendmail, Inc.\n\n   5. All redistributions must comply with the conditions imposed by the University of California on certain embedded code, which copyright Notice and conditions for redistribution are as follows:\n\n   (a) Copyright (c) 1988, 1993 The Regents of the University of California. All rights reserved.\n\n   (b) Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   (i) Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n   (ii) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   (iii) Neither the name of the University nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.\n\n   6. Disclaimer/Limitation of Liability: THIS SOFTWARE IS PROVIDED BY SENDMAIL, INC. AND CONTRIBUTORS \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SENDMAIL, INC., THE REGENTS OF THE UNIVERSITY OF CALIFORNIA OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. $Revision: 8.16 $, Last updated $Date: 2010/10/25 23:11:19 $, Document 139848.1"],"licenseIds":["Sendmail"],"keywords":["obtained from sendmail","from sendmail inc","sendmail inc 6475","inc 6475 christie","6475 christie ave","christie ave third","ave third floor","third floor emeryville","floor emeryville ca","emeryville ca 94608","ca 94608 usa","94608 usa or","mail at license","at license sendmail","license sendmail com","sendmail com license","of sendmail including","sendmail including all","c 1998 2010","1998 2010 sendmail","2010 sendmail inc","sendmail inc all","name of sendmail","sendmail inc nor","trademark of sendmail","sendmail inc 5","revision 8 16","8 16 last","16 last updated","updated date 2010","date 2010 10","2010 10 25","10 25 23","25 23 11","23 11 19","11 19 document","19 document 139848","is obtained from sendmail","obtained from sendmail inc","from sendmail inc 6475","sendmail inc 6475 christie","inc 6475 christie ave","6475 christie ave third","christie ave third floor","ave third floor emeryville","third floor emeryville ca","floor emeryville ca 94608","emeryville ca 94608 usa","ca 94608 usa or","94608 usa or by","electronic mail at license","mail at license sendmail","at license sendmail com","license sendmail com license","sendmail com license terms","code of sendmail including","of sendmail including all","sendmail including all modifications","copyright c 1998 2010","c 1998 2010 sendmail","1998 2010 sendmail inc","2010 sendmail inc all","sendmail inc all rights","the name of sendmail","name of sendmail inc","of sendmail inc nor","sendmail inc nor the","a trademark of sendmail","trademark of sendmail inc","of sendmail inc 5","sendmail inc 5 all","damages revision 8 16","revision 8 16 last","8 16 last updated","16 last updated date","last updated date 2010","updated date 2010 10","date 2010 10 25","2010 10 25 23","10 25 23 11","25 23 11 19","23 11 19 document","11 19 document 139848","19 document 139848 1","license is obtained from sendmail","is obtained from sendmail inc","obtained from sendmail inc 6475","from sendmail inc 6475 christie","sendmail inc 6475 christie ave","inc 6475 christie ave third","6475 christie ave third floor","christie ave third floor emeryville","ave third floor emeryville ca","third floor emeryville ca 94608","floor emeryville ca 94608 usa","emeryville ca 94608 usa or","ca 94608 usa or by","94608 usa or by electronic","by electronic mail at license","electronic mail at license sendmail","mail at license sendmail com","at license sendmail com license","license sendmail com license terms","sendmail com license terms use","source code of sendmail including","code of sendmail including all","of sendmail including all modifications","sendmail including all modifications 2","language copyright c 1998 2010","copyright c 1998 2010 sendmail","c 1998 2010 sendmail inc","1998 2010 sendmail inc all","2010 sendmail inc all rights","sendmail inc all rights reserved","neither the name of sendmail","the name of sendmail inc","name of sendmail inc nor","of sendmail inc nor the","sendmail inc nor the university","is a trademark of sendmail","a trademark of sendmail inc","trademark of sendmail inc 5","of sendmail inc 5 all","sendmail inc 5 all redistributions","such damages revision 8 16","damages revision 8 16 last","revision 8 16 last updated","8 16 last updated date","16 last updated date 2010","last updated date 2010 10","updated date 2010 10 25","date 2010 10 25 23","2010 10 25 23 11","10 25 23 11 19","25 23 11 19 document","23 11 19 document 139848","11 19 document 139848 1"]},{"licenseTexts":["Simple Public License (SimPL) Preamble\n\nThis Simple Public License 2.0 (SimPL 2.0 for short) is a plain language implementation of GPL 2.0. The words are different, but the goal is the same - to guarantee for all users the freedom to share and change software. If anyone wonders about the meaning of the SimPL, they should interpret it as consistent with GPL 2.0. Simple Public License (SimPL) 2.0\n\nThe SimPL applies to the software's source and object code and comes with any rights that I have in it (other than trademarks). You agree to the SimPL by copying, distributing, or making a derivative work of the software.\n\nYou get the royalty free right to:\n\n   - Use the software for any purpose;\n\n   - Make derivative works of it (this is called a \"Derived Work\");\n\n   - Copy and distribute it and any Derived Work.\n\nIf you distribute the software or a Derived Work, you must give back to the community by:\n\n   - Prominently noting the date of any changes you make;\n\n   - Leaving other people's copyright notices, warranty disclaimers, and license terms in place;\n\n   - Providing the source code, build scripts, installation scripts, and interface definitions in a form that is easy to get and best to modify;\n\n   - Licensing it to everyone under SimPL, or substantially similar terms (such as GPL 2.0), without adding further restrictions to the rights provided;\n\n   - Conspicuously announcing that it is available under that license.\n\nThere are some things that you must shoulder:\n\n   - You get NO WARRANTIES. None of any kind;\n\n   - If the software damages you in any way, you may only recover direct damages up to the amount you paid for it (that is zero if you did not pay anything). You may not recover any other damages, including those called \"consequential damages.\" (The state or country where you live may not allow you to limit your liability in this way, so this may not apply to you);\n\nThe SimPL continues perpetually, except that your license rights end automatically if:\n\n   - You do not abide by the \"give back to the community\" terms (your licensees get to keep their rights if they abide);\n\n   - Anyone prevents you from distributing the software under the terms of the SimPL.\n\nLicense for the License\n\nYou may do anything that you want with the SimPL text; it's a license form to use in any way that you find helpful. To avoid confusion, however, if you change the terms in any way then you may not call your license the Simple Public License or the SimPL (but feel free to acknowledge that your license is \"based on the Simple Public License\")."],"licenseIds":["SimPL-2.0"],"keywords":["license simpl preamble","simpl preamble this","preamble this simple","this simple public","2 0 simpl","0 simpl 2","0 for short","for short is","short is a","is a plain","a plain language","plain language implementation","language implementation of","implementation of gpl","of gpl 2","0 the words","the words are","words are different","are different but","different but the","but the goal","goal is the","the same to","same to guarantee","to guarantee for","guarantee for all","all users the","users the freedom","and change software","change software if","software if anyone","if anyone wonders","anyone wonders about","wonders about the","about the meaning","meaning of the","the simpl they","simpl they should","they should interpret","should interpret it","interpret it as","it as consistent","as consistent with","consistent with gpl","with gpl 2","2 0 simple","0 simple public","license simpl 2","0 the simpl","the simpl applies","simpl applies to","software s source","s source and","code and comes","and comes with","comes with any","with any rights","rights that i","that i have","i have in","have in it","in it other","other than trademarks","than trademarks you","trademarks you agree","to the simpl","the simpl by","simpl by copying","or making a","making a derivative","software you get","get the royalty","the royalty free","free right to","any purpose make","purpose make derivative","works of it","of it this","it this is","this is called","called a derived","derived work copy","work copy and","distribute it and","and any derived","software or a","must give back","the community by","community by prominently","by prominently noting","prominently noting the","noting the date","any changes you","changes you make","you make leaving","make leaving other","leaving other people","other people s","people s copyright","s copyright notices","copyright notices warranty","notices warranty disclaimers","warranty disclaimers and","disclaimers and license","and license terms","terms in place","in place providing","place providing the","build scripts installation","scripts installation scripts","installation scripts and","scripts and interface","and interface definitions","interface definitions in","definitions in a","that is easy","is easy to","easy to get","to get and","get and best","and best to","best to modify","to modify licensing","modify licensing it","licensing it to","it to everyone","to everyone under","everyone under simpl","under simpl or","simpl or substantially","or substantially similar","substantially similar terms","similar terms such","terms such as","such as gpl","as gpl 2","2 0 without","0 without adding","without adding further","adding further restrictions","further restrictions to","the rights provided","rights provided conspicuously","provided conspicuously announcing","conspicuously announcing that","announcing that it","that license there","license there are","there are some","are some things","some things that","things that you","you must shoulder","must shoulder you","shoulder you get","you get no","get no warranties","no warranties none","warranties none of","none of any","any kind if","kind if the","the software damages","software damages you","damages you in","way you may","may only recover","only recover direct","recover direct damages","direct damages up","damages up to","to the amount","the amount you","amount you paid","you paid for","paid for it","for it that","it that is","that is zero","is zero if","zero if you","if you did","you did not","did not pay","not pay anything","pay anything you","anything you may","may not recover","not recover any","recover any other","damages including those","including those called","those called consequential","called consequential damages","consequential damages the","damages the state","the state or","state or country","or country where","country where you"]},{"licenseTexts":["The Sleepycat License Copyright (c) 1990-1999 Sleepycat Software. All rights reserved.\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n   - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   - Redistributions in any form must be accompanied by information on how to obtain complete source code for the DB software and any accompanying software that uses the DB software. The source code must either be included in the distribution or be available for no more than the cost of distribution plus a nominal fee, and must be freely redistributable under reasonable conditions. For an executable file, complete source code means the source code for all modules it contains. It does not include source code for modules or files that typically accompany the major components of the operating system on which the executable file runs.\n\nTHIS SOFTWARE IS PROVIDED BY SLEEPYCAT SOFTWARE ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE DISCLAIMED. IN NO EVENT SHALL SLEEPYCAT SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. Copyright (c) 1990, 1993, 1994, 1995 The Regents of the University of California. All rights reserved.\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n   - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   - Neither the name of the University nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. Copyright (c) 1995, 1996 The President and Fellows of Harvard University. All rights reserved.\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n   - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   - Neither the name of the University nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY HARVARD AND ITS CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL HARVARD OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."],"licenseIds":["Sleepycat"],"keywords":["the sleepycat license","sleepycat license copyright","c 1990 1999","1990 1999 sleepycat","1999 sleepycat software","sleepycat software all","for the db","db software and","uses the db","db software the","provided by sleepycat","by sleepycat software","sleepycat software as","event shall sleepycat","shall sleepycat software","sleepycat software be","c 1990 1993","1990 1993 1994","1993 1994 1995","1994 1995 the","1995 the regents","1995 1996 the","1996 the president","the president and","president and fellows","and fellows of","fellows of harvard","of harvard university","harvard university all","provided by harvard","by harvard and","harvard and its","event shall harvard","shall harvard or","harvard or its","the sleepycat license copyright","sleepycat license copyright c","copyright c 1990 1999","c 1990 1999 sleepycat","1990 1999 sleepycat software","1999 sleepycat software all","sleepycat software all rights","code for the db","for the db software","the db software and","db software and any","that uses the db","uses the db software","the db software the","db software the source","is provided by sleepycat","provided by sleepycat software","by sleepycat software as","sleepycat software as is","no event shall sleepycat","event shall sleepycat software","shall sleepycat software be","sleepycat software be liable","damage copyright c 1990","copyright c 1990 1993","c 1990 1993 1994","1990 1993 1994 1995","1993 1994 1995 the","1994 1995 the regents","1995 the regents of","damage copyright c 1995","c 1995 1996 the","1995 1996 the president","1996 the president and","the president and fellows","president and fellows of","and fellows of harvard","fellows of harvard university","of harvard university all","harvard university all rights","is provided by harvard","provided by harvard and","by harvard and its","harvard and its contributors","no event shall harvard","event shall harvard or","shall harvard or its","harvard or its contributors","the sleepycat license copyright c","sleepycat license copyright c 1990","license copyright c 1990 1999","copyright c 1990 1999 sleepycat","c 1990 1999 sleepycat software","1990 1999 sleepycat software all","1999 sleepycat software all rights","sleepycat software all rights reserved","source code for the db","code for the db software","for the db software and","the db software and any","db software and any accompanying","software that uses the db","that uses the db software","uses the db software the","the db software the source","db software the source code","software is provided by sleepycat","is provided by sleepycat software","provided by sleepycat software as","by sleepycat software as is","sleepycat software as is and","in no event shall sleepycat","no event shall sleepycat software","event shall sleepycat software be","shall sleepycat software be liable","sleepycat software be liable for","such damage copyright c 1990","damage copyright c 1990 1993","copyright c 1990 1993 1994","c 1990 1993 1994 1995","1990 1993 1994 1995 the","1993 1994 1995 the regents","1994 1995 the regents of","1995 the regents of the","such damage copyright c 1995","damage copyright c 1995 1996","copyright c 1995 1996 the","c 1995 1996 the president","1995 1996 the president and","1996 the president and fellows","the president and fellows of","president and fellows of harvard","and fellows of harvard university","fellows of harvard university all","of harvard university all rights","harvard university all rights reserved","software is provided by harvard","is provided by harvard and","provided by harvard and its","by harvard and its contributors","harvard and its contributors as","in no event shall harvard","no event shall harvard or","event shall harvard or its","shall harvard or its contributors","harvard or its contributors be"]},{"licenseTexts":["Copyright (c) 1986 by University of Toronto. Written by Henry Spencer. Not derived from licensed software.\n\nPermission is granted to anyone to use this software for any purpose on any computer system, and to redistribute it freely, subject to the following restrictions:\n\n   1. The author is not responsible for the consequences of use of this software, no matter how awful, even if they arise from defects in it.\n\n   2. The origin of this software must not be misrepresented, either by explicit claim or by omission.\n\n   3. Altered versions must be plainly marked as such, and must not be misrepresented as being the original software."],"licenseIds":["Spencer-86"],"keywords":["copyright c 1986","c 1986 by","1986 by university","by university of","university of toronto","of toronto written","toronto written by","written by henry","by henry spencer","henry spencer not","spencer not derived","derived from licensed","from licensed software","licensed software permission","arise from defects","from defects in","defects in it","by omission 3","omission 3 altered","copyright c 1986 by","c 1986 by university","1986 by university of","by university of toronto","university of toronto written","of toronto written by","toronto written by henry","written by henry spencer","by henry spencer not","henry spencer not derived","spencer not derived from","not derived from licensed","derived from licensed software","from licensed software permission","licensed software permission is","they arise from defects","arise from defects in","from defects in it","defects in it 2","or by omission 3","by omission 3 altered","omission 3 altered versions","copyright c 1986 by university","c 1986 by university of","1986 by university of toronto","by university of toronto written","university of toronto written by","of toronto written by henry","toronto written by henry spencer","written by henry spencer not","by henry spencer not derived","henry spencer not derived from","spencer not derived from licensed","not derived from licensed software","derived from licensed software permission","from licensed software permission is","licensed software permission is granted","if they arise from defects","they arise from defects in","arise from defects in it","from defects in it 2","defects in it 2 the","claim or by omission 3","or by omission 3 altered","by omission 3 altered versions","omission 3 altered versions must"]},{"licenseTexts":["Copyright 1992, 1993, 1994 Henry Spencer. All rights reserved.\n\nThis software is not subject to any license of the American Telephone and Telegraph Company or of the Regents of the University of California.\n\nPermission is granted to anyone to use this software for any purpose on any computer system, and to alter it and redistribute it, subject to the following restrictions:\n\n   1. The author is not responsible for the consequences of use of this software, no matter how awful, even if they arise from flaws in it.\n\n   2. The origin of this software must not be misrepresented, either by explicit claim or by omission. Since few users ever read sources, credits must appear in the documentation.\n\n   3. Altered versions must be plainly marked as such, and must not be misrepresented as being the original software. Since few users ever read sources, credits must appear in the documentation.\n\n   4. This notice may not be removed or altered."],"licenseIds":["Spencer-94"],"keywords":["1993 1994 henry","1994 henry spencer","to any license","the american telephone","american telephone and","telephone and telegraph","and telegraph company","telegraph company or","company or of","of the regents","california permission is","redistribute it subject","it subject to","arise from flaws","from flaws in","flaws in it","by omission since","omission since few","documentation 3 altered","original software since","software since few","the documentation 4","documentation 4 this","4 this notice","1992 1993 1994 henry","1993 1994 henry spencer","1994 henry spencer all","software is not subject","not subject to any","subject to any license","to any license of","any license of the","license of the american","of the american telephone","the american telephone and","american telephone and telegraph","telephone and telegraph company","and telegraph company or","telegraph company or of","company or of the","or of the regents","of the regents of","of california permission is","california permission is granted","system and to alter","and redistribute it subject","redistribute it subject to","it subject to the","they arise from flaws","arise from flaws in","from flaws in it","flaws in it 2","or by omission since","by omission since few","omission since few users","in the documentation 3","the documentation 3 altered","documentation 3 altered versions","the original software since","original software since few","software since few users","in the documentation 4","the documentation 4 this","documentation 4 this notice","4 this notice may","copyright 1992 1993 1994 henry","1992 1993 1994 henry spencer","1993 1994 henry spencer all","1994 henry spencer all rights","spencer all rights reserved this","reserved this software is not","this software is not subject","software is not subject to","is not subject to any","not subject to any license","subject to any license of","to any license of the","any license of the american","license of the american telephone","of the american telephone and","the american telephone and telegraph","american telephone and telegraph company","telephone and telegraph company or","and telegraph company or of","telegraph company or of the","company or of the regents","or of the regents of","of the regents of the","university of california permission is","of california permission is granted","california permission is granted to","computer system and to alter","system and to alter it","it and redistribute it subject","and redistribute it subject to","redistribute it subject to the","it subject to the following","if they arise from flaws","they arise from flaws in","arise from flaws in it","from flaws in it 2","flaws in it 2 the","claim or by omission since","or by omission since few","by omission since few users","omission since few users ever","appear in the documentation 3","in the documentation 3 altered","the documentation 3 altered versions","documentation 3 altered versions must","being the original software since","the original software since few","original software since few users","software since few users ever","appear in the documentation 4","in the documentation 4 this","the documentation 4 this notice","documentation 4 this notice may","4 this notice may not"]},{"licenseTexts":["Copyright (c) 1998, 1999 Henry Spencer. All rights reserved.\n\nDevelopment of this software was funded, in part, by Cray Research Inc., UUNET Communications Services Inc., Sun Microsystems Inc., and Scriptics Corporation, none of whom are responsible for the results. The author thanks all of them.\n\nRedistribution and use in source and binary forms - with or without modification - are permitted for any purpose, provided that redistributions in source form retain this entire copyright notice and indicate the origin and nature of any modifications.\n\nI'd appreciate being given credit for this package in the documentation of software which uses it, but that is not a requirement.\n\nTHIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL HENRY SPENCER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."],"licenseIds":["Spencer-99"],"keywords":["1998 1999 henry","1999 henry spencer","rights reserved development","reserved development of","software was funded","was funded in","funded in part","in part by","part by cray","by cray research","cray research inc","research inc uunet","inc uunet communications","uunet communications services","communications services inc","services inc sun","inc sun microsystems","inc and scriptics","and scriptics corporation","scriptics corporation none","corporation none of","none of whom","of whom are","whom are responsible","for the results","the results the","results the author","the author thanks","author thanks all","thanks all of","all of them","of them redistribution","them redistribution and","are permitted for","permitted for any","provided that redistributions","that redistributions in","source form retain","form retain this","retain this entire","notice and indicate","and indicate the","indicate the origin","the origin and","origin and nature","and nature of","nature of any","any modifications i","modifications i d","i d appreciate","d appreciate being","appreciate being given","being given credit","given credit for","credit for this","package in the","documentation of software","of software which","which uses it","uses it but","it but that","but that is","a requirement this","requirement this software","event shall henry","shall henry spencer","henry spencer be","spencer be liable","c 1998 1999 henry","1998 1999 henry spencer","1999 henry spencer all","all rights reserved development","rights reserved development of","reserved development of this","development of this software","of this software was","this software was funded","software was funded in","was funded in part","funded in part by","in part by cray","part by cray research","by cray research inc","cray research inc uunet","research inc uunet communications","inc uunet communications services","uunet communications services inc","communications services inc sun","services inc sun microsystems","inc sun microsystems inc","microsystems inc and scriptics","inc and scriptics corporation","and scriptics corporation none","scriptics corporation none of","corporation none of whom","none of whom are","of whom are responsible","whom are responsible for","are responsible for the","responsible for the results","for the results the","the results the author","results the author thanks","the author thanks all","author thanks all of","thanks all of them","all of them redistribution","of them redistribution and","them redistribution and use","modification are permitted for","are permitted for any","permitted for any purpose","purpose provided that redistributions","provided that redistributions in","that redistributions in source","in source form retain","source form retain this","form retain this entire","retain this entire copyright","entire copyright notice and","copyright notice and indicate","notice and indicate the","and indicate the origin","indicate the origin and","the origin and nature","origin and nature of","and nature of any","nature of any modifications","of any modifications i","any modifications i d","modifications i d appreciate","i d appreciate being","d appreciate being given","appreciate being given credit","being given credit for","given credit for this","credit for this package","for this package in","this package in the","package in the documentation","in the documentation of","the documentation of software","documentation of software which","of software which uses","software which uses it","which uses it but","uses it but that","it but that is","but that is not","not a requirement this","a requirement this software","requirement this software is","no event shall henry","event shall henry spencer","shall henry spencer be","henry spencer be liable","spencer be liable for","copyright c 1998 1999 henry","c 1998 1999 henry spencer","1998 1999 henry spencer all","1999 henry spencer all rights","spencer all rights reserved development","all rights reserved development of","rights reserved development of this","reserved development of this software","development of this software was","of this software was funded","this software was funded in","software was funded in part","was funded in part by","funded in part by cray","in part by cray research","part by cray research inc","by cray research inc uunet","cray research inc uunet communications","research inc uunet communications services","inc uunet communications services inc","uunet communications services inc sun","communications services inc sun microsystems","services inc sun microsystems inc","inc sun microsystems inc and","sun microsystems inc and scriptics","microsystems inc and scriptics corporation","inc and scriptics corporation none","and scriptics corporation none of","scriptics corporation none of whom","corporation none of whom are","none of whom are responsible","of whom are responsible for","whom are responsible for the","are responsible for the results","responsible for the results the","for the results the author","the results the author thanks","results the author thanks all","the author thanks all of","author thanks all of them","thanks all of them redistribution","all of them redistribution and","of them redistribution and use"]},{"licenseTexts":["SUGARCRM PUBLIC LICENSE Applies to Sugar Open Source Edition v1 through v4. Please note that these releases are no longer supported or distributed.\n\nVersion 1.1.3\n\nThe SugarCRM Public License Version (\"SPL\") consists of the Mozilla Public License Version 1.1, modified to be specific to SugarCRM, with the Additional Terms in Exhibit B. The original Mozilla Public License 1.1 can be found at: http://www.mozilla.org/MPL/MPL-1.1.html\n\n   1. Definitions.\n\n      1.1. \"Contributor\" means each entity that creates or contributes to the creation of Modifications.\n\n      1.2. \"Contributor Version\" means the combination of the Original Code, prior Modifications used by a Contributor, and the Modifications made by that particular Contributor.\n\n      1.3. \"Covered Code\" means the Original Code or Modifications or the combination of the Original Code and Modifications, in each case including portions thereof.\n\n      1.4. \"Electronic Distribution Mechanism\" means a mechanism generally accepted in the software development community for the electronic transfer of data.\n\n      1.5. \"Executable\" means Covered Code in any form other than Source Code.\n\n      1.6. \"Initial Developer\" means the individual or entity identified as the Initial Developer in the Source Code notice required by Exhibit A.\n\n      1.7. \"Larger Work\" means a work which combines Covered Code or portions thereof with code not governed by the terms of this License.\n\n      1.8. \"License\" means this document.\n\n      1.8.1. \"Licensable\" means having the right to grant, to the maximum extent possible, whether at the time of the initial grant or subsequently acquired, any and all of the rights conveyed herein.\n\n      1.9. \"Modifications\" means any addition to or deletion from the substance or structure of either the Original Code or any previous Modifications. When Covered Code is released as a series of files, a Modification is:\n\n         B. Any new file that contains any part of the Original Code or previous Modifications.\n\n         A. Any addition to or deletion from the contents of a file containing Original Code or previous Modifications.\n\n      1.10. \"Original Code\" means Source Code of computer software code which is described in the Source Code notice required by Exhibit A as Original Code, and which, at the time of its release under this License is not already Covered Code governed by this License.\n\n      1.10.1. \"Patent Claims\" means any patent claim(s), now owned or hereafter acquired, including without limitation, method, process, and apparatus claims, in any patent Licensable by grantor.\n\n      1.11. \"Source Code\" means the preferred form of the Covered Code for making modifications to it, including all modules it contains, plus any associated interface definition files, scripts used to control compilation and installation of an Executable, or source code differential comparisons against either the Original Code or another well known, available Covered Code of the Contributor's choice. The Source Code can be in a compressed or archival form, provided the appropriate decompression or de-archiving software is widely available for no charge.\n\n      1.12. \"You\" (or \"Your\") means an individual or a legal entity exercising rights under, and complying with all of the terms of, this License or a future version of this License issued under Section 6.1. For legal entities, \"You\" includes any entity which controls, is controlled by, or is under common control with You. For purposes of this definition, \"control\" means (a) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (b) ownership of more than fifty percent (50%) of the outstanding shares or beneficial ownership of such entity.\n\n   2. Source Code License.\n\n      2.2. Contributor Grant.\n\n      Subject to third party intellectual property claims, each Contributor hereby grants You a world-wide, royalty-free, non-exclusive license\n\n         (b) under Patent Claims infringed by the making, using, or selling of Modifications made by that Contributor either alone and/or in combination with its Contributor Version (or portions of such combination), to make, use, sell, offer for sale, have made, and/or otherwise dispose of: 1) Modifications made by that Contributor (or portions thereof); and 2) the combination of Modifications made by that Contributor with its Contributor Version (or portions of such combination).\n\n         (c) the licenses granted in Sections 2.2(a) and 2.2(b) are effective on the date Contributor first makes Commercial Use of the Covered Code.\n\n         (d) Notwithstanding Section 2.2(b) above, no patent license is granted: 1) for any code that Contributor has deleted from the Contributor Version; 2) separate from the Contributor Version; 3) for infringements caused by: i) third party modifications of Contributor Version or ii) the combination of Modifications made by that Contributor with other software (except as part of the Contributor Version) or other devices; or 4) under Patent Claims infringed by Covered Code in the absence of Modifications made by that Contributor.\n\n         (a) under intellectual property rights (other than patent or trademark) Licensable by Contributor, to use, reproduce, modify, display, perform, sublicense and distribute the Modifications created by such Contributor (or portions thereof) either on an unmodified basis, with other Modifications, as Covered Code and/or as part of a Larger Work; and\n\n   3. Distribution Obligations.\n\n      3.2. Availability of Source Code. Any Modification which You create or to which You contribute must be made available in Source Code form under the terms of this License either on the same media as an Executable version or via an accepted Electronic Distribution Mechanism to anyone to whom you made an Executable version available; and if made available via Electronic Distribution Mechanism, must remain available for at least twelve (12) months after the date it initially became available, or at least six (6) months after a subsequent version of that particular Modification has been made available to such recipients. You are responsible for ensuring that the Source Code version remains available even if the Electronic Distribution Mechanism is maintained by a third party.\n\n      3.3. Description of Modifications. You must cause all Covered Code to which You contribute to contain a file documenting the changes You made to create that Covered Code and the date of any change. You must include a prominent statement that the Modification is derived, directly or indirectly, from Original Code provided by the Initial Developer and including the name of the Initial Developer in (a) the Source Code, and (b) in any notice in an Executable version or related documentation in which You describe the origin or ownership of the Covered Code.\n\n      3.4. Intellectual Property Matters\n\n         (b) Contributor APIs. If Contributor's Modifications include an application programming interface and Contributor has knowledge of patent licenses which are reasonably necessary to implement that API, Contributor must also include this information in the LEGAL file.\n\n         (a) Third Party Claims. If Contributor has knowledge that a license under a third party's intellectual property rights is required to exercise the rights granted by such Contributor under Sections 2.1 or 2.2, Contributor must include a text file with the Source Code distribution titled \"LEGAL\" which describes the claim and the party making the claim in sufficient detail that a recipient will know whom to contact. If Contributor obtains such knowledge after the Modification is made available as described in Section 3.2, Contributor shall promptly modify the LEGAL file in all copies Contributor makes available thereafter and shall take other steps (such as notifying appropriate mailing lists or newsgroups) reasonably calculated to inform those who received the Covered Code that new knowledge has been obtained.\n\n         (c) Representations. Contributor represents that, except as disclosed pursuant to Section 3.4(a) above, Contributor believes that Contributor's Modifications are Contributor's original creation(s) and/or Contributor has sufficient rights to grant the rights conveyed by this License.\n\n      3.5. Required Notices. You must duplicate the notice in Exhibit A in each file of the Source Code. If it is not possible to put such notice in a particular Source Code file due to its structure, then You must include such notice in a location (such as a relevant directory) where a user would be likely to look for such a notice. If You created one or more Modification(s) You may add your name as a Contributor to the notice described in Exhibit A. You must also duplicate this License in any documentation for the Source Code where You describe recipients' rights or ownership rights relating to Covered Code. You may choose to offer, and to charge a fee for, warranty, support, indemnity or liability obligations to one or more recipients of Covered Code. However, You may do so only on Your own behalf, and not on behalf of the Initial Developer or any Contributor. You must make it absolutely clear than any such warranty, support, indemnity or liability obligation is offered by You alone, and You hereby agree to indemnify the Initial Developer and every Contributor for any liability incurred by the Initial Developer or such Contributor as a result of warranty, support, indemnity or liability terms You offer.\n\n      3.6. Distribution of Executable Versions. You may distribute Covered Code in Executable form only if the requirements of Section 3.1-3.5 have been met for that Covered Code, and if You include a notice stating that the Source Code version of the Covered Code is available under the terms of this License, including a description of how and where You have fulfilled the obligations of Section 3.2. The notice must be conspicuously included in any notice in an Executable version, related documentation or collateral in which You describe recipients' rights relating to the Covered Code. You may distribute the Executable version of Covered Code or ownership rights under a license of Your choice, which may contain terms different from this License, provided that You are in compliance with the terms of this License and that the license for the Executable version does not attempt to limit or alter the recipient's rights in the Source Code version from the rights set forth in this License. If You distribute the Executable version under a different license You must make it absolutely clear that any terms which differ from this License are offered by You alone, not by the Initial Developer or any Contributor. You hereby agree to indemnify the Initial Developer and every Contributor for any liability incurred by the Initial Developer or such Contributor as a result of any such terms You offer.\n\n      3.7. Larger Works. You may create a Larger Work by combining Covered Code with other code not governed by the terms of this License and distribute the Larger Work as a single product. In such a case, You must make sure the requirements of this License are fulfilled for the Covered Code.\n\n   4. Inability to Comply Due to Statute or Regulation.\n\n   If it is impossible for You to comply with any of the terms of this License with respect to some or all of the Covered Code due to statute, judicial order, or regulation then You must: (a) comply with the terms of this License to the maximum extent possible; and (b) describe the limitations and the code they affect. Such description must be included in the LEGAL file described in Section 3.4 and must be included with all distributions of the Source Code. Except to the extent prohibited by statute or regulation, such description must be sufficiently detailed for a recipient of ordinary skill to be able to understand it.\n\n   5. Application of this License.\n\n   This License applies to code to which the Initial Developer has attached the notice in Exhibit A and to related Covered Code.\n\n   6. Versions of the License.\n\n      6.2. Effect of New Versions. Once Covered Code has been published under a particular version of the License, You may always continue to use it under the terms of that version. You may also choose to use such Covered Code under the terms of any subsequent version of the License published by SugarCRM. No one other than SugarCRM has the right to modify the terms applicable to Covered Code created under this License.\n\n      6.3. Derivative Works. If You create or use a modified version of this License (which you may only do in order to apply it to code which is not already Covered Code governed by this License), You must (a) rename Your license so that the phrases \"SugarCRM\", \"SPL\" or any confusingly similar phrase do not appear in your license (except to note that your license differs from this License) and (b) otherwise make it clear that Your version of the license contains terms which differ from the SugarCRM Public License. (Filling in the name of the Initial Developer, Original Code or Contributor in the notice described in Exhibit A shall not of themselves be deemed to be modifications of this License.)\n\n   7. DISCLAIMER OF WARRANTY.\n\n   COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN \"AS IS\" BASIS, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER.\n\n   8. TERMINATION.\n\n      8.2. If You initiate litigation by asserting a patent infringement claim (excluding declatory judgment actions) against Initial Developer or a Contributor (the Initial Developer or Contributor against whom You file such action is referred to as \"Participant\") alleging that:\n\n         (a) such Participant's Contributor Version directly or indirectly infringes any patent, then any and all rights granted by such Participant to You under Sections 2.1 and/or 2.2 of this License shall, upon 60 days notice from Participant terminate prospectively, unless if within 60 days after receipt of notice You either: (i) agree in writing to pay Participant a mutually agreeable reasonable royalty for Your past and future use of Modifications made by such Participant, or (ii) withdraw Your litigation claim with respect to the Contributor Version against such Participant. If within 60 days of notice, a reasonable royalty and payment arrangement are not mutually agreed upon in writing by the parties or the litigation claim is not withdrawn, the rights granted by Participant to You under Sections 2.1 and/or 2.2 automatically terminate at the expiration of the 60 day notice period specified above.\n\n         (b) any software, hardware, or device, other than such Participant's Contributor Version, directly or indirectly infringes any patent, then any rights granted to You by such Participant under Sections 2.1(b) and 2.2(b) are revoked effective as of the date You first made, used, sold, distributed, or had made, Modifications made by that Participant.\n\n      8.3. If You assert a patent infringement claim against Participant alleging that such Participant's Contributor Version directly or indirectly infringes any patent where such claim is resolved (such as by license or settlement) prior to the initiation of patent infringement litigation, then the reasonable value of the licenses granted by such Participant under Sections 2.1 or 2.2 shall be taken into account in determining the amount or value of any payment or license.\n\n      8.4. In the event of termination under Sections 8.1 or 8.2 above, all end user license agreements (excluding distributors and resellers) which have been validly granted by You or any distributor hereunder prior to termination shall survive termination.\n\n   9. LIMITATION OF LIABILITY.\n\n   UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER TORT (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL YOU, THE INITIAL DEVELOPER, ANY OTHER CONTRIBUTOR, OR ANY DISTRIBUTOR OF COVERED CODE, OR ANY SUPPLIER OF ANY OF SUCH PARTIES, BE LIABLE TO ANY PERSON FOR ANY INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, COMPUTER FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER COMMERCIAL DAMAGES OR LOSSES, EVEN IF SUCH PARTY SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF LIABILITY SHALL NOT APPLY TO LIABILITY FOR DEATH OR PERSONAL INJURY RESULTING FROM SUCH PARTY'S NEGLIGENCE TO THE EXTENT APPLICABLE LAW PROHIBITS SUCH LIMITATION. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OR LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THIS EXCLUSION AND LIMITATION MAY NOT APPLY TO YOU.\n\n   10. U.S. GOVERNMENT END USERS.\n\n   The Covered Code is a \"commercial item,\" as that term is defined in 48 C.F.R. 2.101 (Oct. 1995), consisting of \"commercial computer software\" and \"commercial computer software documentation,\" as such terms are used in 48 C.F.R. 12.212 (Sept. 1995). Consistent with 48 C.F.R. 12.212 and 48 C.F.R. 227.7202-1 through 227.7202-4 (June 1995), all U.S. Government End Users acquire Covered Code with only those rights set forth herein.\n\n   11. MISCELLANEOUS.\n\n   This License represents the complete agreement concerning subject matter hereof. If any provision of this License is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable. This License shall be governed by California law provisions (except to the extent applicable law, if any, provides otherwise), excluding its conflict-of-law provisions. With respect to disputes in which at least one party is a citizen of, or an entity chartered or registered to do business in the United States of America, any litigation relating to this License shall be subject to the jurisdiction of the Federal Courts of the Northern District of California, with venue lying in Santa Clara County, California, with the losing party responsible for costs, including without limitation, court costs and reasonable attorneys' fees and expenses. The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded. Any law or regulation which provides that the language of a contract shall be construed against the drafter shall not apply to this License.\n\n   12. RESPONSIBILITY FOR CLAIMS.\n\n   As between Initial Developer and the Contributors, each party is responsible for claims and damages arising, directly or indirectly, out of its utilization of rights under this License and You agree to work with Initial Developer and Contributors to distribute such responsibility on an equitable basis. Nothing herein is intended or shall be deemed to constitute any admission of liability.\n\n   13. MULTIPLE-LICENSED CODE.\n\n   Initial Developer may designate portions of the Covered Code as \"Multiple-Licensed\". \"Multiple-Licensed\" means that the Initial Developer permits you to utilize portions of the Covered Code under Your choice of the SPL or the alternative licenses, if any, specified by the Initial Developer in the file described in Exhibit A. SugarCRM Public License 1.1.3 - Exhibit A\n\nThe contents of this file are subject to the SugarCRM Public License Version 1.1.3 (\"License\"); You may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.sugarcrm.com/SPL Software distributed under the License is distributed on an \"AS IS\" basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the specific language governing rights and limitations under the License.\n\nThe Original Code is: SugarCRM Open Source\n\nThe Initial Developer of the Original Code is SugarCRM, Inc.\n\nPortions created by SugarCRM are Copyright (C) 2004 SugarCRM, Inc.;\n\nAll Rights Reserved.\n\nContributor(s): ______________________________________.\n\n[NOTE: The text of this Exhibit A may differ slightly from the text of the notices in the Source Code files of the Original Code. You should use the text of this Exhibit A rather than the text found in the Original Code Source Code for Your Modifications.]\n\nSugarCRM Public License 1.1.3 - Exhibit B\n\nAdditional Terms applicable to the SugarCRM Public License.\n\n   I. Effect.,\n\n   These additional terms described in this SugarCRM Public License - Additional Terms shall apply to the Covered Code under this License.\n\n   II. SugarCRM and logo.\n\n   This License does not grant any rights to use the trademarks \"SugarCRM\" and the \"SugarCRM\" logos even if such marks are included in the Original Code or Modifications.\n\n   However, in addition to the other notice obligations, all copies of the Covered Code in Executable and Source Code form distributed must, as a form of attribution of the original author, include on each user interface screen (i) the \"Powered by SugarCRM\" logo and (ii) the copyright notice in the same form as the latest version of the Covered Code distributed by SugarCRM, Inc. at the time of distribution of such copy. In addition, the \"Powered by SugarCRM\" logo must be visible to all users and be located at the very bottom center of each user interface screen. Notwithstanding the above, the dimensions of the \"Powered By SugarCRM\" logo must be at least 106 x 23 pixels. When users click on the \"Powered by SugarCRM\" logo it must direct them back to http://www.sugarforge.org. In addition, the copyright notice must remain visible to all users at all times at the bottom of the user interface screen. When users click on the copyright notice, it must direct them back to http://www.sugarcrm.com"],"licenseIds":["SugarCRM-1.1.3"],"keywords":["applies to sugar","to sugar open","sugar open source","open source edition","source edition v1","edition v1 through","v1 through v4","through v4 please","v4 please note","note that these","that these releases","these releases are","releases are no","no longer supported","longer supported or","supported or distributed","or distributed version","distributed version 1","3 the sugarcrm","license version spl","version spl consists","spl consists of","1 1 modified","1 modified to","specific to sugarcrm","to sugarcrm with","sugarcrm with the","additional terms in","terms in exhibit","b the original","the original mozilla","original mozilla public","1 1 can","1 can be","org mpl mpl","mpl mpl 1","mpl 1 1","1 1 html","1 html 1","html 1 definitions","modification is b","is b any","modifications a any","exclusive license b","license b under","that contributor a","contributor a under","work and 3","and 3 distribution","obligations 3 2","property matters b","matters b contributor","legal file a","file a third","been obtained c","obtained c representations","license 6 2","published by sugarcrm","by sugarcrm no","sugarcrm no one","other than sugarcrm","than sugarcrm has","sugarcrm has the","the phrases sugarcrm","phrases sugarcrm spl","sugarcrm spl or","from the sugarcrm","termination 8 2","of the spl","exhibit a sugarcrm","a sugarcrm public","3 exhibit a","1 3 license","3 license you","sugarcrm com spl","com spl software","spl software distributed","is sugarcrm open","sugarcrm open source","open source the","source the initial","is sugarcrm inc","sugarcrm inc portions","created by sugarcrm","by sugarcrm are","sugarcrm are copyright","c 2004 sugarcrm","2004 sugarcrm inc","sugarcrm inc all","your modifications sugarcrm","modifications sugarcrm public","3 exhibit b","exhibit b additional","b additional terms","in this sugarcrm","this sugarcrm public","public license additional","additional terms shall","terms shall apply","license ii sugarcrm","ii sugarcrm and","sugarcrm and logo","the trademarks sugarcrm","trademarks sugarcrm and","sugarcrm and the","and the sugarcrm","the sugarcrm logos","sugarcrm logos even","logos even if","or modifications however","modifications however in","however in addition","the other notice","other notice obligations","notice obligations all","obligations all copies","code form distributed","form distributed must","distributed must as","must as a","as a form","form of attribution","of attribution of","original author include","author include on","include on each","on each user","interface screen i","screen i the","i the powered","sugarcrm logo and","logo and ii","ii the copyright","form as the","as the latest","covered code distributed","code distributed by","distributed by sugarcrm","by sugarcrm inc","sugarcrm inc at","inc at the","time of distribution","of such copy","such copy in","copy in addition","addition the powered","must be visible","be visible to","all users and","users and be","and be located","be located at","the very bottom","very bottom center","bottom center of","center of each","of each user","interface screen notwithstanding","screen notwithstanding the","above the dimensions","the dimensions of","dimensions of the","of the powered","must be at","be at least","at least 106","least 106 x","106 x 23","x 23 pixels","23 pixels when","pixels when users","on the powered","sugarcrm logo it","logo it must","http www sugarforge","www sugarforge org","sugarforge org in","addition the copyright","copyright notice must","notice must remain","must remain visible","remain visible to","all users at","users at all","all times at","times at the","at the bottom","bottom of the","the user interface","interface screen when","screen when users","on the copyright","copyright notice it","notice it must","sugarcrm public license applies","license applies to sugar","applies to sugar open","to sugar open source","sugar open source edition","open source edition v1"]},{"licenseTexts":["The TAPR Open Hardware License Version 1.0 (May 25, 2007) Copyright 2007 TAPR - http://www.tapr.org/OHL\n\nPREAMBLE\n\nOpen Hardware is a thing - a physical artifact, either electrical or mechanical - whose design information is available to, and usable by, the public in a way that allows anyone to make, modify, distribute, and use that thing. In this preface, design information is called \"documentation\" and things created from it are called \"products.\"\n\nThe TAPR Open Hardware License (\"OHL\") agreement provides a legal framework for Open Hardware projects. It may be used for any kind of product, be it a hammer or a computer motherboard, and is TAPR's contribution to the community; anyone may use the OHL for their Open Hardware project.\n\nLike the GNU General Public License, the OHL is designed to guarantee your freedom to share and to create. It forbids anyone who receives rights under the OHL to deny any other licensee those same rights to copy, modify, and distribute documentation, and to make, use and distribute products based on that documentation.\n\nUnlike the GPL, the OHL is not primarily a copyright license. While copyright protects documentation from unauthorized copying, modification, and distribution, it has little to do with your right to make, distribute, or use a product based on that documentation. For better or worse, patents play a significant role in those activities. Although it does not prohibit anyone from patenting inventions embodied in an Open Hardware design, and of course cannot prevent a third party from enforcing their patent rights, those who benefit from an OHL design may not bring lawsuits claiming that design infringes their patents or other intellectual property.\n\nThe OHL addresses unique issues involved in the creation of tangible, physical things, but does not cover software, firmware, or code loaded into programmable devices. A copyright-oriented license such as the GPL better suits these creations.\n\nHow can you use the OHL, or a design based upon it? While the terms and conditions below take precedence over this preamble, here is a summary:\n\n   * You may modify the documentation and make products based upon it.\n\n   * You may use products for any legal purpose without limitation.\n\n   * You may distribute unmodified documentation, but you must include the complete package as you received it.\n\n   * You may distribute products you make to third parties, if you either include the documentation on which the product is based, or make it available without charge for at least three years to anyone who requests it.\n\n   * You may distribute modified documentation or products based on it, if you:\n\n      * License your modifications under the OHL.\n\n      * Include those modifications, following the requirements stated below.\n\n      * Attempt to send the modified documentation by email to any of the developers who have provided their email address. This is a good faith obligation - if the email fails, you need do nothing more and may go on with your distribution.\n\n   * If you create a design that you want to license under the OHL, you should:\n\n      * Include this document in a file named LICENSE (with the appropriate extension) that is included in the documentation package.\n\n      * If the file format allows, include a notice like \"Licensed under the TAPR Open Hardware License (www.tapr.org/OHL)\" in each documentation file. While not required, you should also include this notice on printed circuit board artwork and the product itself; if space is limited the notice can be shortened or abbreviated.\n\n      * Include a copyright notice in each file and on printed circuit board artwork.\n\n      * If you wish to be notified of modifications that others may make, include your email address in a file named \"CONTRIB.TXT\" or something similar.\n\n   * Any time the OHL requires you to make documentation available to others, you must include all the materials you received from the upstream licensors. In addition, if you have modified the documentation:\n\n      * You must identify the modifications in a text file (preferably named \"CHANGES.TXT\") that you include with the documentation. That file must also include a statement like \"These modifications are licensed under the TAPR Open Hardware License.\"\n\n      * You must include any new files you created, including any manufacturing files (such as Gerber files) you create in the course of making products.\n\n      * You must include both \"before\" and \"after\" versions of all files you modified.\n\n      * You may include files in proprietary formats, but you must also include open format versions (such as Gerber, ASCII, Postscript, or PDF) if your tools can create them.\n\nTERMS AND CONDITIONS\n\n1. Introduction\n\n   1.1 This Agreement governs how you may use, copy, modify, and distribute Documentation, and how you may make, have made, and distribute Products based on that Documentation. As used in this Agreement, to \"distribute\" Documentation means to directly or indirectly make copies available to a third party, and to \"distribute\" Products means to directly or indirectly give, loan, sell or otherwise transfer them to a third party.\n\n   1.2 \"Documentation\" includes:\n\n      (a) schematic diagrams;\n\n      (b) circuit or circuit board layouts, including Gerber and other data files used for manufacture;\n\n      (c) mechanical drawings, including CAD, CAM, and other data files used for manufacture;\n\n      (d) flow charts and descriptive text; and\n\n      (e) other explanatory material.\n\n   Documentation may be in any tangible or intangible form of expression, including but not limited to computer files in open or proprietary formats and representations on paper, film, or other media.\n\n   1.3 \"Products\" include:\n\n      (a) circuit boards, mechanical assemblies, and other physical parts and components;\n\n      (b) assembled or partially assembled units (including components and subassemblies); and\n\n      (c) parts and components combined into kits intended for assembly by others; which are based in whole or in part on the Documentation.\n\n   1.4 This Agreement applies to any Documentation which contains a notice stating it is subject to the TAPR Open Hardware License, and to all Products based in whole or in part on that Documentation. If Documentation is distributed in an archive (such as a \"zip\" file) which includes this document, all files in that archive are subject to this Agreement unless they are specifically excluded. Each person who contributes content to the Documentation is referred to in this Agreement as a \"Licensor.\"\n\n   1.5 By (a) using, copying, modifying, or distributing the Documentation, or (b) making or having Products made or distributing them, you accept this Agreement, agree to comply with its terms, and become a \"Licensee.\" Any activity inconsistent with this Agreement will automatically terminate your rights under it (including the immunities from suit granted in Section 2), but the rights of others who have received Documentation, or have obtained Products, directly or indirectly from you will not be affected so long as they fully comply with it themselves.\n\n   1.6 This Agreement does not apply to software, firmware, or code loaded into programmable devices which may be used in conjunction with Documentation or Products. Such software is subject to the license terms established by its copyright holder(s).\n\n2. Patents\n\n   2.1 Each Licensor grants you, every other Licensee, and every possessor or user of Products a perpetual, worldwide, and royalty-free immunity from suit under any patent, patent application, or other intellectual property right which he or she controls, to the extent necessary to make, have made, possess, use, and distribute Products. This immunity does not extend to infringement arising from modifications subsequently made by others.\n\n   2.2 If you make or have Products made, or distribute Documentation that you have modified, you grant every Licensor, every other Licensee, and every possessor or user of Products a perpetual, worldwide, and royalty-free immunity from suit under any patent, patent application, or other intellectual property right which you control, to the extent necessary to make, have made, possess, use, and distribute Products. This immunity does not extend to infringement arising from modifications subsequently made by others.\n\n   2.3 To avoid doubt, providing Documentation to a third party for the sole purpose of having that party make Products on your behalf is not considered \"distribution,\"\\\" and a third party's act of making Products solely on your behalf does not cause that party to grant the immunity described in the preceding paragraph.\n\n   2.4 These grants of immunity are a material part of this Agreement, and form a portion of the consideration given by each party to the other. If any court judgment or legal agreement prevents you from granting the immunity required by this Section, your rights under this Agreement will terminate and you may no longer use, copy, modify or distribute the Documentation, or make, have made, or distribute Products.\n\n3. Modifications\n\nYou may modify the Documentation, and those modifications will become part of the Documentation. They are subject to this Agreement, as are Products based in whole or in part on them. If you distribute the modified Documentation, or Products based in whole or in part upon it, you must email the modified Documentation in a form compliant with Section 4 to each Licensor who has provided an email address with the Documentation. Attempting to send the email completes your obligations under this Section and you need take no further action if any address fails.\n\n4. Distributing Documentation\n\n   4.1 You may distribute unmodified copies of the Documentation in its entirety in any medium, provided that you retain all copyright and other notices (including references to this Agreement) included by each Licensor, and include an unaltered copy of this Agreement.\n\n   4.2 You may distribute modified copies of the Documentation if you comply with all the requirements of the preceding paragraph and:\n\n      (a) include a prominent notice in an ASCII or other open format file identifying those elements of the Documentation that you changed, and stating that the modifications are licensed under the terms of this Agreement;\n\n      (b) include all new documentation files that you create, as well as both the original and modified versions of each file you change (files may be in your development tool's native file format, but if reasonably possible, you must also include open format, such as Gerber, ASCII, Postscript, or PDF, versions);\n\n      (c) do not change the terms of this Agreement with respect to subsequent licensees; and\n\n      (d) if you make or have Products made, include in the Documentation all elements reasonably required to permit others to make Products, including Gerber, CAD/CAM and other files used for manufacture.\n\n5. Making Products\n\n   5.1 You may use the Documentation to make or have Products made, provided that each Product retains any notices included by the Licensor (including, but not limited to, copyright notices on circuit boards).\n\n   5.2 You may distribute Products you make or have made, provided that you include with each unit a copy of the Documentation in a form consistent with Section 4. Alternatively, you may include either (i) an offer valid for at least three years to provide that Documentation, at no charge other than the reasonable cost of media and postage, to any person who requests it; or (ii) a URL where that Documentation may be downloaded, available for at least three years after you last distribute the Product.\n\n6. NEW LICENSE VERSIONS\n\nTAPR may publish updated versions of the OHL which retain the same general provisions as the present version, but differ in detail to address new problems or concerns, and carry a distinguishing version number. If the Documentation specifies a version number which applies to it and \"any later version\", you may choose either that version or any later version published by TAPR. If the Documentation does not specify a version number, you may choose any version ever published by TAPR. TAPR owns the copyright to the OHL, but grants permission to any person to copy, distribute, and use it in unmodified form.\n\n7. WARRANTY AND LIABILITY LIMITATIONS\n\n   7.1 THE DOCUMENTATION IS PROVIDED ON AN\"AS-IS\" BASIS WITHOUT WARRANTY OF ANY KIND, TO THE EXTENT PERMITTED BY APPLICABLE LAW. ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND TITLE, ARE HEREBY EXPRESSLY DISCLAIMED.\n\n   7.2 IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW WILL ANY LICENSOR BE LIABLE TO YOU OR ANY THIRD PARTY FOR ANY DIRECT, INDIRECT, INCIDENTAL, CONSEQUENTIAL, PUNITIVE, OR EXEMPLARY DAMAGES ARISING OUT OF THE USE OF, OR INABILITY TO USE, THE DOCUMENTATION OR PRODUCTS, INCLUDING BUT NOT LIMITED TO CLAIMS OF INTELLECTUAL PROPERTY INFRINGEMENT OR LOSS OF DATA, EVEN IF THAT PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\n   7.3 You agree that the foregoing limitations are reasonable due to the non-financial nature of the transaction represented by this Agreement, and acknowledge that were it not for these limitations, the Licensor(s) would not be willing to make the Documentation available to you.\n\n   7.4 You agree to defend, indemnify, and hold each Licensor harmless from any claim brought by a third party alleging any defect in the design, manufacture, or operation of any Product which you make, have made, or distribute pursuant to this Agreement.\n\n####"],"licenseIds":["TAPR-OHL-1.0"],"keywords":["1 0 may","0 may 25","may 25 2007","25 2007 copyright","copyright 2007 tapr","2007 tapr http","tapr http www","http www tapr","org ohl preamble","ohl preamble open","preamble open hardware","open hardware is","hardware is a","is a thing","a thing a","thing a physical","a physical artifact","physical artifact either","artifact either electrical","either electrical or","electrical or mechanical","or mechanical whose","mechanical whose design","whose design information","information is available","available to and","to and usable","and usable by","usable by the","way that allows","that allows anyone","allows anyone to","anyone to make","to make modify","make modify distribute","and use that","use that thing","that thing in","thing in this","in this preface","this preface design","preface design information","information is called","is called documentation","called documentation and","documentation and things","and things created","things created from","created from it","from it are","it are called","are called products","called products the","products the tapr","hardware license ohl","license ohl agreement","ohl agreement provides","agreement provides a","provides a legal","a legal framework","legal framework for","framework for open","for open hardware","open hardware projects","hardware projects it","projects it may","kind of product","of product be","product be it","be it a","it a hammer","a hammer or","hammer or a","or a computer","a computer motherboard","computer motherboard and","motherboard and is","and is tapr","is tapr s","tapr s contribution","s contribution to","the community anyone","community anyone may","anyone may use","the ohl for","ohl for their","for their open","their open hardware","open hardware project","hardware project like","project like the","like the gnu","license the ohl","ohl is designed","designed to guarantee","share and to","and to create","to create it","create it forbids","it forbids anyone","forbids anyone who","who receives rights","receives rights under","the ohl to","ohl to deny","deny any other","any other licensee","other licensee those","licensee those same","same rights to","make use and","that documentation unlike","documentation unlike the","unlike the gpl","the gpl the","gpl the ohl","ohl is not","is not primarily","not primarily a","primarily a copyright","copyright license while","license while copyright","while copyright protects","copyright protects documentation","protects documentation from","documentation from unauthorized","from unauthorized copying","unauthorized copying modification","copying modification and","and distribution it","distribution it has","it has little","has little to","little to do","to do with","with your right","to make distribute","make distribute or","use a product","a product based","product based on","that documentation for","documentation for better","for better or","better or worse","or worse patents","worse patents play","patents play a","play a significant","a significant role","significant role in","role in those","in those activities","those activities although","activities although it","although it does","does not prohibit","not prohibit anyone","prohibit anyone from","anyone from patenting","from patenting inventions","patenting inventions embodied","inventions embodied in","embodied in an","in an open","an open hardware","open hardware design","design and of","and of course","of course cannot","course cannot prevent","cannot prevent a","prevent a third","third party from","party from enforcing","from enforcing their","enforcing their patent","their patent rights","patent rights those","rights those who","those who benefit","who benefit from","benefit from an","from an ohl","an ohl design","ohl design may","design may not","may not bring","not bring lawsuits","bring lawsuits claiming","lawsuits claiming that","claiming that design","that design infringes","design infringes their","infringes their patents","their patents or","intellectual property the","property the ohl","the ohl addresses","ohl addresses unique"]},{"licenseTexts":["This software is copyrighted by the Regents of the University of California, Sun Microsystems, Inc., Scriptics Corporation, ActiveState Corporation and other parties. The following terms apply to all files associated with the software unless explicitly disclaimed in individual files.\n\nThe authors hereby grant permission to use, copy, modify, distribute, and license this software and its documentation for any purpose, provided that existing copyright notices are retained in all copies and that this notice is included verbatim in any distributions. No written agreement, license, or royalty fee is required for any of the authorized uses. Modifications to this software may be copyrighted by their authors and need not follow the licensing terms described here, provided that the new terms are clearly indicated on the first page of each file where they apply.\n\nIN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION, OR ANY DERIVATIVES THEREOF, EVEN IF THE AUTHORS HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\nTHE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT. THIS SOFTWARE IS PROVIDED ON AN \"AS IS\" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.\n\nGOVERNMENT USE: If you are acquiring this software on behalf of the U.S. government, the Government shall have only \"Restricted Rights\" in the software and related documentation as defined in the Federal Acquisition Regulations (FARs) in Clause 52.227.19 (c) (2). If you are acquiring the software on behalf of the Department of Defense, the software shall be classified as \"Commercial Computer Software\" and the Government shall have only \"Restricted Rights\" as defined in Clause 252.227-7013 (c) (1) of DFARs. Notwithstanding the foregoing, the authors grant the U.S. Government and others acting in its behalf permission to use and distribute the software in accordance with the terms specified in this license."],"licenseIds":["TCL"],"keywords":["software is copyrighted","of california sun","california sun microsystems","microsystems inc scriptics","inc scriptics corporation","scriptics corporation activestate","corporation activestate corporation","activestate corporation and","corporation and other","and other parties","other parties the","parties the following","software unless explicitly","files the authors","this software is copyrighted","software is copyrighted by","copyrighted by the regents","university of california sun","of california sun microsystems","california sun microsystems inc","sun microsystems inc scriptics","microsystems inc scriptics corporation","inc scriptics corporation activestate","scriptics corporation activestate corporation","corporation activestate corporation and","activestate corporation and other","corporation and other parties","and other parties the","other parties the following","parties the following terms","with the software unless","the software unless explicitly","software unless explicitly disclaimed","in individual files the","individual files the authors","files the authors hereby","this software is copyrighted by","software is copyrighted by the","is copyrighted by the regents","copyrighted by the regents of","the university of california sun","university of california sun microsystems","of california sun microsystems inc","california sun microsystems inc scriptics","sun microsystems inc scriptics corporation","microsystems inc scriptics corporation activestate","inc scriptics corporation activestate corporation","scriptics corporation activestate corporation and","corporation activestate corporation and other","activestate corporation and other parties","corporation and other parties the","and other parties the following","other parties the following terms","parties the following terms apply","associated with the software unless","with the software unless explicitly","the software unless explicitly disclaimed","software unless explicitly disclaimed in","disclaimed in individual files the","in individual files the authors","individual files the authors hereby","files the authors hereby grant"]},{"licenseTexts":["Copyright 1995 by Wietse Venema. All rights reserved. Some individual files may be covered by other copyrights.\n\nThis material was originally written and compiled by Wietse Venema at Eindhoven University of Technology, The Netherlands, in 1990, 1991, 1992, 1993, 1994 and 1995.\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that this entire copyright notice is duplicated in all such copies.\n\nThis software is provided \"as is\" and without any expressed or implied warranties, including, without limitation, the implied warranties of merchantibility and fitness for any particular purpose."],"licenseIds":["TCP-wrappers"],"keywords":["copyright 1995 by","1995 by wietse","wietse venema all","venema all rights","rights reserved some","reserved some individual","some individual files","by other copyrights","other copyrights this","copyrights this material","this material was","material was originally","was originally written","originally written and","written and compiled","and compiled by","compiled by wietse","wietse venema at","venema at eindhoven","at eindhoven university","eindhoven university of","of technology the","technology the netherlands","the netherlands in","netherlands in 1990","in 1990 1991","1993 1994 and","1994 and 1995","and 1995 redistribution","1995 redistribution and","notice is duplicated","is duplicated in","duplicated in all","all such copies","such copies this","copies this software","without any expressed","copyright 1995 by wietse","1995 by wietse venema","by wietse venema all","wietse venema all rights","venema all rights reserved","all rights reserved some","rights reserved some individual","reserved some individual files","some individual files may","individual files may be","files may be covered","covered by other copyrights","by other copyrights this","other copyrights this material","copyrights this material was","this material was originally","material was originally written","was originally written and","originally written and compiled","written and compiled by","and compiled by wietse","compiled by wietse venema","by wietse venema at","wietse venema at eindhoven","venema at eindhoven university","at eindhoven university of","eindhoven university of technology","university of technology the","of technology the netherlands","technology the netherlands in","the netherlands in 1990","netherlands in 1990 1991","in 1990 1991 1992","1991 1992 1993 1994","1992 1993 1994 and","1993 1994 and 1995","1994 and 1995 redistribution","and 1995 redistribution and","1995 redistribution and use","that this entire copyright","entire copyright notice is","copyright notice is duplicated","notice is duplicated in","is duplicated in all","duplicated in all such","in all such copies","all such copies this","such copies this software","copies this software is","and without any expressed","without any expressed or","copyright 1995 by wietse venema","1995 by wietse venema all","by wietse venema all rights","wietse venema all rights reserved","venema all rights reserved some","all rights reserved some individual","rights reserved some individual files","reserved some individual files may","some individual files may be","individual files may be covered","files may be covered by","be covered by other copyrights","covered by other copyrights this","by other copyrights this material","other copyrights this material was","copyrights this material was originally","this material was originally written","material was originally written and","was originally written and compiled","originally written and compiled by","written and compiled by wietse","and compiled by wietse venema","compiled by wietse venema at","by wietse venema at eindhoven","wietse venema at eindhoven university","venema at eindhoven university of","at eindhoven university of technology","eindhoven university of technology the","university of technology the netherlands","of technology the netherlands in","technology the netherlands in 1990","the netherlands in 1990 1991","netherlands in 1990 1991 1992","in 1990 1991 1992 1993","1990 1991 1992 1993 1994","1991 1992 1993 1994 and","1992 1993 1994 and 1995","1993 1994 and 1995 redistribution","1994 and 1995 redistribution and","and 1995 redistribution and use","1995 redistribution and use in","are permitted provided that this","permitted provided that this entire","provided that this entire copyright","that this entire copyright notice","this entire copyright notice is","entire copyright notice is duplicated","copyright notice is duplicated in","notice is duplicated in all","is duplicated in all such","duplicated in all such copies","in all such copies this","all such copies this software","such copies this software is","copies this software is provided","is and without any expressed","and without any expressed or","without any expressed or implied","merchantibility and fitness for any"]},{"licenseTexts":["The TMate Open Source License. This license applies to all portions of TMate SVNKit library, which are not externally-maintained libraries (e.g. Ganymed SSH library).\n\nAll the source code and compiled classes in package org.tigris.subversion.javahl except SvnClient class are covered by the license in JAVAHL-LICENSE file Copyright (c) 2004-2012 TMate Software. All rights reserved.\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n   * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   * Redistributions in any form must be accompanied by information on how to obtain complete source code for the software that uses SVNKit and any accompanying software that uses the software that uses SVNKit. The source code must either be included in the distribution or be available for no more than the cost of distribution plus a nominal fee, and must be freely redistributable under reasonable conditions. For an executable file, complete source code means the source code for all modules it contains. It does not include source code for modules or files that typically accompany the major components of the operating system on which the executable file runs.\n\n   * Redistribution in any form without redistributing source code for software that uses SVNKit is possible only when such redistribution is explictly permitted by TMate Software. Please, contact TMate Software at support@svnkit.com to get such permission.\n\nTHIS SOFTWARE IS PROVIDED BY TMATE SOFTWARE ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE DISCLAIMED.\n\nIN NO EVENT SHALL TMATE SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."],"licenseIds":["TMate"],"keywords":["the tmate open","tmate open source","source license this","portions of tmate","of tmate svnkit","tmate svnkit library","svnkit library which","library which are","are not externally","not externally maintained","externally maintained libraries","maintained libraries e","libraries e g","e g ganymed","g ganymed ssh","ganymed ssh library","ssh library all","library all the","code and compiled","and compiled classes","compiled classes in","classes in package","in package org","package org tigris","org tigris subversion","tigris subversion javahl","subversion javahl except","javahl except svnclient","except svnclient class","svnclient class are","class are covered","license in javahl","in javahl license","javahl license file","license file copyright","c 2004 2012","2004 2012 tmate","2012 tmate software","tmate software all","uses svnkit and","svnkit and any","uses svnkit the","svnkit the source","file runs redistribution","runs redistribution in","redistribution in any","any form without","form without redistributing","without redistributing source","redistributing source code","code for software","uses svnkit is","svnkit is possible","is possible only","possible only when","only when such","when such redistribution","such redistribution is","redistribution is explictly","is explictly permitted","explictly permitted by","permitted by tmate","tmate software please","software please contact","please contact tmate","contact tmate software","tmate software at","software at support","at support svnkit","support svnkit com","svnkit com to","com to get","to get such","get such permission","such permission this","provided by tmate","tmate software as","event shall tmate","shall tmate software","tmate software be","the tmate open source","tmate open source license","open source license this","source license this license","applies to all portions","all portions of tmate","portions of tmate svnkit","of tmate svnkit library","tmate svnkit library which","svnkit library which are","library which are not","which are not externally","are not externally maintained","not externally maintained libraries","externally maintained libraries e","maintained libraries e g","libraries e g ganymed","e g ganymed ssh","g ganymed ssh library","ganymed ssh library all","ssh library all the","library all the source","source code and compiled","code and compiled classes","and compiled classes in","compiled classes in package","classes in package org","in package org tigris","package org tigris subversion","org tigris subversion javahl","tigris subversion javahl except","subversion javahl except svnclient","javahl except svnclient class","except svnclient class are","svnclient class are covered","class are covered by","are covered by the","covered by the license","by the license in","the license in javahl","license in javahl license","in javahl license file","javahl license file copyright","license file copyright c","file copyright c 2004","copyright c 2004 2012","c 2004 2012 tmate","2004 2012 tmate software","2012 tmate software all","tmate software all rights","that uses svnkit and","uses svnkit and any","svnkit and any accompanying","that uses the software","uses the software that","that uses svnkit the","uses svnkit the source","svnkit the source code","executable file runs redistribution","file runs redistribution in","runs redistribution in any","redistribution in any form","in any form without","any form without redistributing","form without redistributing source","without redistributing source code","redistributing source code for","source code for software","code for software that","for software that uses","that uses svnkit is","uses svnkit is possible","svnkit is possible only","is possible only when","possible only when such","only when such redistribution","when such redistribution is","such redistribution is explictly","redistribution is explictly permitted","is explictly permitted by","explictly permitted by tmate","permitted by tmate software","by tmate software please","tmate software please contact","software please contact tmate","please contact tmate software","contact tmate software at","tmate software at support","software at support svnkit","at support svnkit com","support svnkit com to","svnkit com to get","com to get such","to get such permission","get such permission this","such permission this software","is provided by tmate","provided by tmate software","by tmate software as","tmate software as is","no event shall tmate","event shall tmate software","shall tmate software be","tmate software be liable","the tmate open source license","tmate open source license this","open source license this license","source license this license applies","license applies to all portions","applies to all portions of","to all portions of tmate","all portions of tmate svnkit","portions of tmate svnkit library","of tmate svnkit library which","tmate svnkit library which are","svnkit library which are not","library which are not externally","which are not externally maintained","are not externally maintained libraries","not externally maintained libraries e"]},{"licenseTexts":["TORQUE v2.5+ Software License v1.1 Copyright (c) 2010-2011 Adaptive Computing Enterprises, Inc. All rights reserved. Use this license to use or redistribute the TORQUE software v2.5+ and later versions. For free support for TORQUE users, questions should be emailed to the community of TORQUE users at torqueusers@supercluster.org. Users can also subscribe to the user mailing list at http://www.supercluster.org/mailman/listinfo/torqueusers. Customers using TORQUE that also are licensed users of Moab branded software from Adaptive Computing Inc. can get TORQUE support from Adaptive Computing via:\n\nEmail: torque-support@adaptivecomputing.com.\n\nPhone: (801) 717-3700\n\nWeb: www.adaptivecomputing.com www.clusterresources.com\n\nThis license covers use of the TORQUE v2.5 software (the \"Software\") at your site or location, and, for certain users, redistribution of the Software to other sites and locations1. Later versions of TORQUE are also covered by this license. Use and redistribution of TORQUE v2.5 in source and binary forms, with or without modification, are permitted provided that all of the following conditions are met.\n\n   1. Any Redistribution of source code must retain the above copyright notice and the acknowledgment contained in paragraph 5, this list of conditions and the disclaimer contained in paragraph 5.\n\n   2. Any Redistribution in binary form must reproduce the above copyright notice and the acknowledgment contained in paragraph 4, this list of conditions and the disclaimer contained in paragraph 5 in the documentation and/or other materials provided with the distribution.\n\n   3. Redistributions in any form must be accompanied by information on how to obtain complete source code for TORQUE and any modifications and/or additions to TORQUE. The source code must either be included in the distribution or be available for no more than the cost of distribution plus a nominal fee, and all modifications and additions to the Software must be freely redistributable by any party (including Licensor) without restriction.\n\n   4. All advertising materials mentioning features or use of the Software must display the following acknowledgment:\n\n   \"TORQUE is a modification of OpenPBS which was developed by NASA Ames Research Center, Lawrence Livermore National Laboratory, and Veridian TORQUE Open Source License v1.1. 1 Information Solutions, Inc. Visit www.clusterresources.com/products/ for more information about TORQUE and to download TORQUE. For information about Moab branded products and so receive support from Adaptive Computing for TORQUE, see www.adaptivecomputing.com.\"\n\n   5. DISCLAIMER OF WARRANTY THIS SOFTWARE IS PROVIDED \"AS IS\" WITHOUT WARRANTY OF ANY KIND. ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT ARE EXPRESSLY DISCLAIMED. IN NO EVENT SHALL ADAPTIVE COMPUTING ENTERPRISES, INC. CORPORATION, ITS AFFILIATED COMPANIES, OR THE U.S. GOVERNMENT OR ANY OF ITS AGENCIES BE LIABLE FOR ANY DIRECT OR INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\nThis license will be governed by the laws of Utah, without reference to its choice of law rules. Note 1: TORQUE is developed from an earlier version v2.3 of OpenPBS. TORQUE has been developed beyond OpenPBS v2.3. The OpenPBS v2.3 license and OpenPBS software can be obtained at:\n\nhttp://www.pbsworks.com/ResLibSearchResult.aspx?keywords=openpbs\u0026industry=All\u0026pro duct_service=All\u0026category=Free%20Software%20Downloads\u0026order_by=title. Users of TORQUE should comply with the TORQUE license as well as the OpenPBS license."],"licenseIds":["TORQUE-1.1"],"keywords":["5 software license","software license v1","v1 1 copyright","c 2010 2011","2010 2011 adaptive","2011 adaptive computing","enterprises inc all","reserved use this","use or redistribute","redistribute the torque","the torque software","torque software v2","software v2 5","v2 5 and","5 and later","and later versions","later versions for","versions for free","for free support","free support for","support for torque","for torque users","torque users questions","users questions should","questions should be","should be emailed","be emailed to","emailed to the","the community of","community of torque","of torque users","torque users at","users at torqueusers","at torqueusers supercluster","torqueusers supercluster org","supercluster org users","org users can","users can also","can also subscribe","also subscribe to","the user mailing","user mailing list","mailing list at","list at http","http www supercluster","www supercluster org","supercluster org mailman","org mailman listinfo","mailman listinfo torqueusers","listinfo torqueusers customers","torqueusers customers using","customers using torque","using torque that","torque that also","that also are","also are licensed","are licensed users","licensed users of","users of moab","of moab branded","moab branded software","branded software from","software from adaptive","adaptive computing inc","computing inc can","inc can get","can get torque","get torque support","torque support from","adaptive computing via","computing via email","via email torque","email torque support","torque support adaptivecomputing","support adaptivecomputing com","adaptivecomputing com phone","com phone 801","phone 801 717","801 717 3700","717 3700 web","3700 web www","web www adaptivecomputing","adaptivecomputing com www","com www clusterresources","clusterresources com this","com this license","license covers use","covers use of","of the torque","the torque v2","5 software the","software at your","at your site","your site or","site or location","or location and","location and for","and for certain","for certain users","certain users redistribution","users redistribution of","software to other","to other sites","other sites and","sites and locations1","and locations1 later","locations1 later versions","versions of torque","of torque are","torque are also","are also covered","also covered by","this license use","license use and","use and redistribution","redistribution of torque","of torque v2","v2 5 in","5 in source","that all of","met 1 any","1 any redistribution","paragraph 5 this","5 this list","paragraph 5 2","5 2 any","2 any redistribution","any redistribution in","paragraph 4 this","4 this list","paragraph 5 in","5 in the","code for torque","for torque and","torque and any","additions to torque","to torque the","torque the source","fee and all","all modifications and","modifications and additions","freely redistributable by","redistributable by any","any party including","party including licensor","including licensor without","licensor without restriction","without restriction 4","restriction 4 all","following acknowledgment torque","acknowledgment torque is","torque is a","modification of openpbs","of openpbs which","openpbs which was","which was developed","developed by nasa","by nasa ames","nasa ames research","ames research center","research center lawrence","center lawrence livermore","lawrence livermore national","livermore national laboratory","national laboratory and","laboratory and veridian","and veridian torque","veridian torque open","torque open source","source license v1","1 1 information","1 information solutions","information solutions inc","solutions inc visit","inc visit www","visit www clusterresources","clusterresources com products","com products for","products for more","more information about","information about torque","about torque and","torque and to","and to download","to download torque","download torque for","torque for information","for information about","information about moab","about moab branded","moab branded products","branded products and","products and so","and so receive","so receive support","receive support from","adaptive computing for","computing for torque","for torque see","torque see www"]},{"licenseTexts":["Trusster Open Source License version 1.0a (TRUST) copyright (c) 2006 Mike Mintz and Robert Ekendahl. All rights reserved.\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n   * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   * Redistributions in any form must be accompanied by information on how to obtain complete source code for this software and any accompanying software that uses this software. The source code must either be included in the distribution or be available in a timely fashion for no more than the cost of distribution plus a nominal fee, and must be freely redistributable under reasonable and no more restrictive conditions. For an executable file, complete source code means the source code for all modules it contains. It does not include source code for modules or files that typically accompany the major components of the operating system on which the executable file runs.\n\nTHIS SOFTWARE IS PROVIDED BY MIKE MINTZ AND ROBERT EKENDAHL ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE DISCLAIMED. IN NO EVENT SHALL MIKE MINTZ AND ROBERT EKENDAHL OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."],"licenseIds":["TOSL"],"keywords":["trusster open source","1 0a trust","0a trust copyright","trust copyright c","c 2006 mike","2006 mike mintz","robert ekendahl all","ekendahl all rights","that uses this","this software the","be available in","timely fashion for","fashion for no","under reasonable and","reasonable and no","and no more","restrictive conditions for","provided by mike","by mike mintz","robert ekendahl as","ekendahl as is","event shall mike","shall mike mintz","robert ekendahl or","ekendahl or its","trusster open source license","version 1 0a trust","1 0a trust copyright","0a trust copyright c","trust copyright c 2006","copyright c 2006 mike","c 2006 mike mintz","2006 mike mintz and","and robert ekendahl all","robert ekendahl all rights","ekendahl all rights reserved","software that uses this","that uses this software","uses this software the","this software the source","or be available in","be available in a","a timely fashion for","timely fashion for no","fashion for no more","redistributable under reasonable and","under reasonable and no","reasonable and no more","and no more restrictive","no more restrictive conditions","more restrictive conditions for","restrictive conditions for an","is provided by mike","provided by mike mintz","by mike mintz and","and robert ekendahl as","robert ekendahl as is","ekendahl as is and","no event shall mike","event shall mike mintz","shall mike mintz and","and robert ekendahl or","robert ekendahl or its","ekendahl or its contributors","trusster open source license version","source license version 1 0a","license version 1 0a trust","version 1 0a trust copyright","1 0a trust copyright c","0a trust copyright c 2006","trust copyright c 2006 mike","copyright c 2006 mike mintz","c 2006 mike mintz and","2006 mike mintz and robert","mintz and robert ekendahl all","and robert ekendahl all rights","robert ekendahl all rights reserved","ekendahl all rights reserved redistribution","complete source code for this","code for this software and","for this software and any","this software and any accompanying","accompanying software that uses this","software that uses this software","that uses this software the","uses this software the source","this software the source code","distribution or be available in","or be available in a","be available in a timely","in a timely fashion for","a timely fashion for no","timely fashion for no more","fashion for no more than","freely redistributable under reasonable and","redistributable under reasonable and no","under reasonable and no more","reasonable and no more restrictive","and no more restrictive conditions","no more restrictive conditions for","more restrictive conditions for an","restrictive conditions for an executable","software is provided by mike","is provided by mike mintz","provided by mike mintz and","by mike mintz and robert","mintz and robert ekendahl as","and robert ekendahl as is","robert ekendahl as is and","ekendahl as is and any","in no event shall mike","no event shall mike mintz","event shall mike mintz and","shall mike mintz and robert","mintz and robert ekendahl or","and robert ekendahl or its","robert ekendahl or its contributors","ekendahl or its contributors be"]},{"licenseTexts":["Copyright 1992, 1993, 1994 by Jutta Degener and Carsten Bormann,\n\nTechnische Universitaet Berlin\n\nAny use of this software is permitted provided that this notice is not removed and that neither the authors nor the Technische Universitaet Berlin are deemed to have made any representations as to the suitability of this software for any purpose nor are held responsible for any defects of this software. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.\n\nAs a matter of courtesy, the authors request to be informed about uses this software has found, about bugs in this software, and about any improvements that may be of general interest. Berlin, 28.11.1994\n\nJutta Degener\n\nCarsten Bormann"],"licenseIds":["TU-Berlin-1.0"],"keywords":null},{"licenseTexts":["Copyright 1992, 1993, 1994 by Jutta Degener and Carsten Bormann,\n\nTechnische Universitaet Berlin\n\nAny use of this software is permitted provided that this notice is not removed and that neither the authors nor the Technische Universitaet Berlin are deemed to have made any representations as to the suitability of this software for any purpose nor are held responsible for any defects of this software. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.\n\nAs a matter of courtesy, the authors request to be informed about uses this software has found, about bugs in this software, and about any improvements that may be of general interest. Berlin, 28.11.1994\n\nJutta Degener\n\nCarsten Bormann oOo\n\nSince the original terms of 15 years ago maybe do not make our intentions completely clear given today's refined usage of the legal terms, we append this additional permission:\n\nPermission to use, copy, modify, and distribute this software for any purpose with or without fee is hereby granted, provided that this notice is not removed and that neither the authors nor the Technische Universitaet Berlin are deemed to have made any representations as to the suitability of this software for any purpose nor are held responsible for any defects of this software. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE. Berkeley/Bremen, 05.04.2009\n\nJutta Degener\n\nCarsten Bormann"],"licenseIds":["TU-Berlin-2.0"],"keywords":["carsten bormann ooo","bormann ooo since","ooo since the","since the original","the original terms","original terms of","terms of 15","of 15 years","15 years ago","years ago maybe","ago maybe do","maybe do not","not make our","make our intentions","our intentions completely","intentions completely clear","completely clear given","clear given today","given today s","today s refined","s refined usage","refined usage of","of the legal","the legal terms","legal terms we","terms we append","we append this","append this additional","this additional permission","additional permission permission","permission permission to","this software berkeley","software berkeley bremen","berkeley bremen 05","bremen 05 04","05 04 2009","04 2009 jutta","2009 jutta degener","degener carsten bormann ooo","carsten bormann ooo since","bormann ooo since the","ooo since the original","since the original terms","the original terms of","original terms of 15","terms of 15 years","of 15 years ago","15 years ago maybe","years ago maybe do","ago maybe do not","maybe do not make","do not make our","not make our intentions","make our intentions completely","our intentions completely clear","intentions completely clear given","completely clear given today","clear given today s","given today s refined","today s refined usage","s refined usage of","refined usage of the","usage of the legal","of the legal terms","the legal terms we","legal terms we append","terms we append this","we append this additional","append this additional permission","this additional permission permission","additional permission permission to","permission permission to use","for this software berkeley","this software berkeley bremen","software berkeley bremen 05","berkeley bremen 05 04","bremen 05 04 2009","05 04 2009 jutta","04 2009 jutta degener","2009 jutta degener carsten","jutta degener carsten bormann ooo","degener carsten bormann ooo since","carsten bormann ooo since the","bormann ooo since the original","ooo since the original terms","since the original terms of","the original terms of 15","original terms of 15 years","terms of 15 years ago","of 15 years ago maybe","15 years ago maybe do","years ago maybe do not","ago maybe do not make","maybe do not make our","do not make our intentions","not make our intentions completely","make our intentions completely clear","our intentions completely clear given","intentions completely clear given today","completely clear given today s","clear given today s refined","given today s refined usage","today s refined usage of","s refined usage of the","refined usage of the legal","usage of the legal terms","of the legal terms we","the legal terms we append","legal terms we append this","terms we append this additional","we append this additional permission","append this additional permission permission","this additional permission permission to","additional permission permission to use","permission permission to use copy","warranty for this software berkeley","for this software berkeley bremen","this software berkeley bremen 05","software berkeley bremen 05 04","berkeley bremen 05 04 2009","bremen 05 04 2009 jutta","05 04 2009 jutta degener","04 2009 jutta degener carsten","2009 jutta degener carsten bormann"]},{"licenseTexts":["Upstream Compatibility License v. 1.0 (UCL-1.0)\n\nThis Upstream Compatibility License (the \"License\") applies to any original work of authorship (the \"Original Work\") whose owner (the \"Licensor\") has placed the following licensing notice adjacent to the copyright notice for the Original Work:\n\nLicensed under the Upstream Compatibility License 1.0\n\n   1) Grant of Copyright License. Licensor grants You a worldwide, royalty-free, non-exclusive, sublicensable license, for the duration of the copyright, to do the following:\n\n      a) to reproduce the Original Work in copies, either alone or as part of a collective work;\n\n      b) to translate, adapt, alter, transform, modify, or arrange the Original Work, thereby creating derivative works (\"Derivative Works\") based upon the Original Work;\n\n      c) to distribute or communicate copies of the Original Work and Derivative Works to the public, with the proviso that copies of Original Work You distribute or communicate shall be licensed under this Upstream Compatibility License and all Derivative Work You distribute or communicate shall be licensed under both this Upstream Compatibility License and the Apache License 2.0 or later;\n\n      d) to perform the Original Work publicly; and\n\n      e) to display the Original Work publicly.\n\n   2) Grant of Patent License. Licensor grants You a worldwide, royalty-free, non-exclusive, sublicensable license, under patent claims owned or controlled by the Licensor that are embodied in the Original Work as furnished by the Licensor, for the duration of the patents, to make, use, sell, offer for sale, have made, and import the Original Work and Derivative Works.\n\n   3) Grant of Source Code License. The term \"Source Code\" means the preferred form of the Original Work for making modifications to it and all available documentation describing how to modify the Original Work. Licensor agrees to provide a machine-readable copy of the Source Code of the Original Work along with each copy of the Original Work that Licensor distributes. Licensor reserves the right to satisfy this obligation by placing a machine-readable copy of the Source Code in an information repository reasonably calculated to permit inexpensive and convenient access by You for as long as Licensor continues to distribute the Original Work.\n\n   4) Exclusions From License Grant. Neither the names of Licensor, nor the names of any contributors to the Original Work, nor any of their trademarks or service marks, may be used to endorse or promote products derived from this Original Work without express prior permission of the Licensor. Except as expressly stated herein, nothing in this License grants any license to Licensor's trademarks, copyrights, patents, trade secrets or any other intellectual property. No patent license is granted to make, use, sell, offer for sale, have made, or import embodiments of any patent claims other than the licensed claims defined in Section 2. No license is granted to the trademarks of Licensor even if such marks are included in the Original Work. Nothing in this License shall be interpreted to prohibit Licensor from licensing under terms different from this License any Original Work that Licensor otherwise would have a right to license.\n\n   5) External Deployment. The term \"External Deployment\" means the use, distribution, or communication of the Original Work or Derivative Works in any way such that the Original Work or Derivative Works may be used by anyone other than You, whether those works are distributed or communicated to those persons or made available as an application intended for use over a network. As an express condition for the grants of license hereunder, You must treat any External Deployment by You of the Original Work or a Derivative Work as a distribution under section 1(c).\n\n   6) Attribution Rights. You must retain, in the Source Code of any Derivative Works that You create, all copyright, patent, or trademark notices from the Source Code of the Original Work, as well as any notices of licensing and any descriptive text identified therein as an \"Attribution Notice.\" You must cause the Source Code for any Derivative Works that You create to carry a prominent Attribution Notice reasonably calculated to inform recipients that You have modified the Original Work.\n\n   7) Warranty of Provenance and Disclaimer of Warranty. Licensor warrants that the copyright in and to the Original Work and the patent rights granted herein by Licensor are owned by the Licensor or are sublicensed to You under the terms of this License with the permission of the contributor(s) of those copyrights and patent rights. Except as expressly stated in the immediately preceding sentence, the Original Work is provided under this License on an \"AS IS\" BASIS and WITHOUT WARRANTY, either express or implied, including, without limitation, the warranties of non-infringement, merchantability or fitness for a particular purpose. THE ENTIRE RISK AS TO THE QUALITY OF THE ORIGINAL WORK IS WITH YOU. This DISCLAIMER OF WARRANTY constitutes an essential part of this License. No license to the Original Work is granted by this License except under this disclaimer.\n\n   8) Limitation of Liability. Under no circumstances and under no legal theory, whether in tort (including negligence), contract, or otherwise, shall the Licensor be liable to anyone for any indirect, special, incidental, or consequential damages of any character arising as a result of this License or the use of the Original Work including, without limitation, damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses. This limitation of liability shall not apply to the extent applicable law prohibits such limitation.\n\n   9) Acceptance and Termination. If, at any time, You expressly assented to this License, that assent indicates your clear and irrevocable acceptance of this License and all of its terms and conditions. If You distribute or communicate copies of the Original Work or a Derivative Work, You must make a reasonable effort under the circumstances to obtain the express assent of recipients to the terms of this License. This License conditions your rights to undertake the activities listed in Section 1, including your right to create Derivative Works based upon the Original Work, and doing so without honoring these terms and conditions is prohibited by copyright law and international treaty. Nothing in this License is intended to affect copyright exceptions and limitations (including \"fair use\" or \"fair dealing\"). This License shall terminate immediately and You may no longer exercise any of the rights granted to You by this License upon your failure to honor the conditions in Section 1(c).\n\n   10) Termination for Patent Action. This License shall terminate automatically and You may no longer exercise any of the rights granted to You by this License as of the date You commence an action, including a cross-claim or counterclaim, against Licensor or any licensee alleging that the Original Work infringes a patent. This termination provision shall not apply for an action alleging patent infringement by combinations of the Original Work with other software or hardware.\n\n   11) Jurisdiction, Venue and Governing Law. Any action or suit relating to this License may be brought only in the courts of a jurisdiction wherein the Licensor resides or in which Licensor conducts its primary business, and under the laws of that jurisdiction excluding its conflict-of-law provisions. The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded. Any use of the Original Work outside the scope of this License or after its termination shall be subject to the requirements and penalties of copyright or patent law in the appropriate jurisdiction. This section shall survive the termination of this License.\n\n   12) Attorneys' Fees. In any action to enforce the terms of this License or seeking damages relating thereto, the prevailing party shall be entitled to recover its costs and expenses, including, without limitation, reasonable attorneys' fees and costs incurred in connection with such action, including any appeal of such action. This section shall survive the termination of this License.\n\n   13) Miscellaneous. If any provision of this License is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable.\n\n   14) Definition of \"You\" in This License. \"You\" throughout this License, whether in upper or lower case, means an individual or a legal entity exercising rights under, and complying with all of the terms of, this License. For legal entities, \"You\" includes any entity that controls, is controlled by, or is under common control with you. For purposes of this definition, \"control\" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.\n\n   15) Right to Use. You may use the Original Work in all ways not otherwise restricted or conditioned by this License or by law, and Licensor promises not to interfere with or be responsible for such uses by You.\n\n   16) Modification of This License. This License is Copyright (c) 2005 Lawrence Rosen and Copyright (c) 2017 Nigel Tzeng. Permission is granted to copy, distribute, or communicate this License without modification. Nothing in this License permits You to modify this License as applied to the Original Work or to Derivative Works. However, You may modify the text of this License and copy, distribute or communicate your modified version (the \"Modified License\") and apply it to other original works of authorship subject to the following conditions: (i) You may not indicate in any way that your Modified License is the \"Open Software License\" or \"OSL\" or the \"Upstream Compatibility License\" or \"UCL\" and you may not use those names in the name of your Modified License; (ii) You must replace the notice specified in the first paragraph above with the notice \"Licensed under \u003cinsert your license name here\u003e \" or with a notice of your own that is not confusingly similar to the notice in this License; and (iii) You may not claim that your original works are open source software unless your Modified License has been approved by Open Source Initiative (OSI) and You comply with its license review and certification process."],"licenseIds":["UCL-1.0"],"keywords":["compatibility license v","1 0 ucl","0 ucl 1","ucl 1 0","0 this upstream","compatibility license the","under the upstream","compatibility license 1","under this upstream","all derivative work","licensed under both","under both this","both this upstream","0 or later","or later d","later d to","lawrence rosen and","rosen and copyright","and copyright c","copyright c 2017","c 2017 nigel","2017 nigel tzeng","nigel tzeng permission","tzeng permission is","or osl or","osl or the","or the upstream","compatibility license or","license or ucl","or ucl and","ucl and you","upstream compatibility license v","compatibility license v 1","v 1 0 ucl","1 0 ucl 1","0 ucl 1 0","ucl 1 0 this","1 0 this upstream","0 this upstream compatibility","upstream compatibility license the","compatibility license the license","licensed under the upstream","under the upstream compatibility","upstream compatibility license 1","compatibility license 1 0","license 1 0 1","1 0 1 grant","of original work you","original work you distribute","licensed under this upstream","under this upstream compatibility","compatibility license and all","license and all derivative","and all derivative work","all derivative work you","be licensed under both","licensed under both this","under both this upstream","both this upstream compatibility","compatibility license and the","license and the apache","and the apache license","license 2 0 or","2 0 or later","0 or later d","or later d to","later d to perform","2005 lawrence rosen and","lawrence rosen and copyright","rosen and copyright c","and copyright c 2017","copyright c 2017 nigel","c 2017 nigel tzeng","2017 nigel tzeng permission","nigel tzeng permission is","tzeng permission is granted","license or osl or","or osl or the","osl or the upstream","or the upstream compatibility","upstream compatibility license or","compatibility license or ucl","license or ucl and","or ucl and you","ucl and you may","upstream compatibility license v 1","compatibility license v 1 0","license v 1 0 ucl","v 1 0 ucl 1","1 0 ucl 1 0","0 ucl 1 0 this","ucl 1 0 this upstream","1 0 this upstream compatibility","0 this upstream compatibility license","this upstream compatibility license the","upstream compatibility license the license","compatibility license the license applies","work licensed under the upstream","licensed under the upstream compatibility","under the upstream compatibility license","the upstream compatibility license 1","upstream compatibility license 1 0","compatibility license 1 0 1","license 1 0 1 grant","1 0 1 grant of","copies of original work you","of original work you distribute","original work you distribute or","be licensed under this upstream","licensed under this upstream compatibility","under this upstream compatibility license","upstream compatibility license and all","compatibility license and all derivative","license and all derivative work","and all derivative work you","all derivative work you distribute","derivative work you distribute or","shall be licensed under both","be licensed under both this","licensed under both this upstream","under both this upstream compatibility","both this upstream compatibility license","upstream compatibility license and the","compatibility license and the apache","license and the apache license","and the apache license 2","apache license 2 0 or","license 2 0 or later","2 0 or later d","0 or later d to","or later d to perform","later d to perform the","c 2005 lawrence rosen and","2005 lawrence rosen and copyright","lawrence rosen and copyright c","rosen and copyright c 2017","and copyright c 2017 nigel","copyright c 2017 nigel tzeng","c 2017 nigel tzeng permission","2017 nigel tzeng permission is","nigel tzeng permission is granted","tzeng permission is granted to","software license or osl or","license or osl or the","or osl or the upstream","osl or the upstream compatibility","or the upstream compatibility license","the upstream compatibility license or","upstream compatibility license or ucl","compatibility license or ucl and","license or ucl and you","or ucl and you may","ucl and you may not"]},{"licenseTexts":["Copyright (c) [year] [copyright holders] The Universal Permissive License (UPL), Version 1.0\n\nSubject to the condition set forth below, permission is hereby granted to any person obtaining a copy of this software, associated documentation and/or data (collectively the \"Software\"), free of charge and under any and all copyright rights in the Software, and any and all patent rights owned or freely licensable by each licensor hereunder covering either (i) the unmodified Software as contributed to or provided by such licensor, or (ii) the Larger Works (as defined below), to deal in both\n\n   (a) the Software, and\n\n   (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if one is included with the Software (each a \"Larger Work\" to which the Software is contributed by such licensors),\n\nwithout restriction, including without limitation the rights to copy, create derivative works of, display, perform, and distribute the Software and make, use, sell, offer for sale, import, export, have made, and have sold the Software and the Larger Work(s), and to sublicense the foregoing rights on either these or other terms.\n\nThis license is subject to the following condition:\n\nThe above copyright notice and either this complete permission notice or at a minimum a reference to the UPL must be included in all copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE."],"licenseIds":["UPL-1.0"],"keywords":["holders the universal","the universal permissive","universal permissive license","permissive license upl","license upl version","upl version 1","1 0 subject","0 subject to","the condition set","condition set forth","forth below permission","granted to any","this software associated","software associated documentation","or data collectively","data collectively the","the software free","software free of","all copyright rights","and any and","and all patent","all patent rights","patent rights owned","owned or freely","or freely licensable","freely licensable by","licensable by each","each licensor hereunder","licensor hereunder covering","hereunder covering either","covering either i","either i the","i the unmodified","unmodified software as","software as contributed","as contributed to","contributed to or","to or provided","or provided by","provided by such","licensor or ii","ii the larger","the larger works","larger works as","works as defined","below to deal","deal in both","in both a","both a the","a the software","software and b","b any piece","and or hardware","or hardware listed","hardware listed in","in the lrgrwrks","the lrgrwrks txt","lrgrwrks txt file","txt file if","file if one","if one is","one is included","the software each","software each a","each a larger","larger work to","software is contributed","contributed by such","by such licensors","such licensors without","licensors without restriction","to copy create","display perform and","software and make","and make use","sale import export","import export have","export have made","made and have","and have sold","have sold the","sold the software","larger work s","work s and","and to sublicense","sublicense the foregoing","the foregoing rights","foregoing rights on","rights on either","on either these","either these or","these or other","other terms this","terms this license","the following condition","following condition the","condition the above","notice and either","either this complete","this complete permission","complete permission notice","notice or at","a minimum a","minimum a reference","to the upl","the upl must","upl must be","year copyright holders the","copyright holders the universal","holders the universal permissive","the universal permissive license","universal permissive license upl","permissive license upl version","license upl version 1","upl version 1 0","version 1 0 subject","1 0 subject to","0 subject to the","subject to the condition","to the condition set","the condition set forth","condition set forth below","set forth below permission","forth below permission is","hereby granted to any","granted to any person","of this software associated","this software associated documentation","software associated documentation and","associated documentation and or","documentation and or data","and or data collectively","or data collectively the","data collectively the software","collectively the software free","the software free of","software free of charge","charge and under any","and under any and","and all copyright rights","all copyright rights in","copyright rights in the","software and any and","and any and all","any and all patent","and all patent rights","all patent rights owned","patent rights owned or","rights owned or freely","owned or freely licensable","or freely licensable by","freely licensable by each","licensable by each licensor","by each licensor hereunder","each licensor hereunder covering","licensor hereunder covering either","hereunder covering either i","covering either i the","either i the unmodified","i the unmodified software","the unmodified software as","unmodified software as contributed","software as contributed to","as contributed to or","contributed to or provided","to or provided by","or provided by such","provided by such licensor","by such licensor or","such licensor or ii","licensor or ii the","or ii the larger","ii the larger works","the larger works as","larger works as defined","works as defined below","as defined below to","defined below to deal","below to deal in","to deal in both","deal in both a","in both a the","both a the software","a the software and","the software and b","software and b any","and b any piece","b any piece of","any piece of software","piece of software and","software and or hardware","and or hardware listed","or hardware listed in","hardware listed in the","listed in the lrgrwrks","in the lrgrwrks txt","the lrgrwrks txt file","lrgrwrks txt file if","txt file if one","file if one is"]},{"licenseTexts":["UNICODE, INC. LICENSE AGREEMENT - DATA FILES AND SOFTWARE\n\nUnicode Data Files include all data files under the directories http://www.unicode.org/Public/, http://www.unicode.org/reports/, and http://www.unicode.org/cldr/data/. Unicode Data Files do not include PDF online code charts under the directory http://www.unicode.org/Public/. Software includes any source code published in the Unicode Standard or under the directories http://www.unicode.org/Public/, http://www.unicode.org/reports/, and http://www.unicode.org/cldr/data/.\n\nNOTICE TO USER: Carefully read the following legal agreement. BY DOWNLOADING, INSTALLING, COPYING OR OTHERWISE USING UNICODE INC.'S DATA FILES (\"DATA FILES\"), AND/OR SOFTWARE (\"SOFTWARE\"), YOU UNEQUIVOCALLY ACCEPT, AND AGREE TO BE BOUND BY, ALL OF THE TERMS AND CONDITIONS OF THIS AGREEMENT. IF YOU DO NOT AGREE, DO NOT DOWNLOAD, INSTALL, COPY, DISTRIBUTE OR USE THE DATA FILES OR SOFTWARE.\n\nCOPYRIGHT AND PERMISSION NOTICE\n\nCopyright © 1991-2015 Unicode, Inc. All rights reserved. Distributed under the Terms of Use in http://www.unicode.org/copyright.html.\n\nPermission is hereby granted, free of charge, to any person obtaining a copy of the Unicode data files and any associated documentation (the \"Data Files\") or Unicode software and any associated documentation (the \"Software\") to deal in the Data Files or Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, and/or sell copies of the Data Files or Software, and to permit persons to whom the Data Files or Software are furnished to do so, provided that\n\n   (a) this copyright and permission notice appear with all copies of the Data Files or Software,\n\n   (b) this copyright and permission notice appear in associated documentation, and\n\n   (c) there is clear notice in each modified Data File or in the Software as well as in the documentation associated with the Data File(s) or Software that the data or software has been modified.\n\nTHE DATA FILES AND SOFTWARE ARE PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THE DATA FILES OR SOFTWARE.\n\nExcept as contained in this notice, the name of a copyright holder shall not be used in advertising or otherwise to promote the sale, use or other dealings in these Data Files or Software without prior written authorization of the copyright holder."],"licenseIds":["Unicode-DFS-2015"],"keywords":["cldr data unicode","data unicode data","cldr data notice","data notice to","copyright 1991 2015","1991 2015 unicode","2015 unicode inc","that a this","or software b","software b this","and c there","c there is","there is clear","is clear notice","clear notice in","in each modified","each modified data","modified data file","data file or","software as well","the documentation associated","documentation associated with","the data file","data file s","file s or","s or software","or software has","been modified the","modified the data","org cldr data unicode","cldr data unicode data","data unicode data files","org cldr data notice","cldr data notice to","data notice to user","notice copyright 1991 2015","copyright 1991 2015 unicode","1991 2015 unicode inc","2015 unicode inc all","so provided that a","provided that a this","that a this copyright","files or software b","or software b this","software b this copyright","in associated documentation and","associated documentation and c","documentation and c there","and c there is","c there is clear","there is clear notice","is clear notice in","clear notice in each","notice in each modified","in each modified data","each modified data file","modified data file or","data file or in","in the software as","the software as well","software as well as","well as in the","as in the documentation","in the documentation associated","the documentation associated with","documentation associated with the","associated with the data","with the data file","the data file s","data file s or","file s or software","s or software that","or software that the","software that the data","the data or software","data or software has","or software has been","software has been modified","has been modified the","been modified the data","modified the data files","unicode org cldr data unicode","org cldr data unicode data","cldr data unicode data files","data unicode data files do","unicode org cldr data notice","org cldr data notice to","cldr data notice to user","data notice to user carefully","permission notice copyright 1991 2015","notice copyright 1991 2015 unicode","copyright 1991 2015 unicode inc","1991 2015 unicode inc all","2015 unicode inc all rights","do so provided that a","so provided that a this","provided that a this copyright","that a this copyright and","data files or software b","files or software b this","or software b this copyright","software b this copyright and","appear in associated documentation and","in associated documentation and c","associated documentation and c there","documentation and c there is","and c there is clear","c there is clear notice","there is clear notice in","is clear notice in each","clear notice in each modified","notice in each modified data","in each modified data file","each modified data file or","modified data file or in","data file or in the","file or in the software","or in the software as","in the software as well","the software as well as","software as well as in","as well as in the","well as in the documentation","as in the documentation associated","in the documentation associated with","the documentation associated with the","documentation associated with the data","associated with the data file","with the data file s","the data file s or","data file s or software","file s or software that","s or software that the","or software that the data","software that the data or","that the data or software","the data or software has","data or software has been","or software has been modified","software has been modified the","has been modified the data","been modified the data files","modified the data files and"]},{"licenseTexts":["UNICODE, INC. LICENSE AGREEMENT - DATA FILES AND SOFTWARE\n\nUnicode Data Files include all data files under the directories http://www.unicode.org/Public/, http://www.unicode.org/reports/, http://www.unicode.org/cldr/data/, http://source.icu-project.org/repos/icu/, http://www.unicode.org/ivd/data/, and http://www.unicode.org/utility/trac/browser/.\n\nUnicode Data Files do not include PDF online code charts under the directory http://www.unicode.org/Public/.\n\nSoftware includes any source code published in the Unicode Standard or under the directories http://www.unicode.org/Public/, http://www.unicode.org/reports/, http://www.unicode.org/cldr/data/, http://source.icu-project.org/repos/icu/, and http://www.unicode.org/utility/trac/browser/.\n\nNOTICE TO USER: Carefully read the following legal agreement. BY DOWNLOADING, INSTALLING, COPYING OR OTHERWISE USING UNICODE INC.'S DATA FILES (\"DATA FILES\"), AND/OR SOFTWARE (\"SOFTWARE\"), YOU UNEQUIVOCALLY ACCEPT, AND AGREE TO BE BOUND BY, ALL OF THE TERMS AND CONDITIONS OF THIS AGREEMENT. IF YOU DO NOT AGREE, DO NOT DOWNLOAD, INSTALL, COPY, DISTRIBUTE OR USE THE DATA FILES OR SOFTWARE.\n\nCOPYRIGHT AND PERMISSION NOTICE Copyright © 1991-2016 Unicode, Inc. All rights reserved. Distributed under the Terms of Use in http://www.unicode.org/copyright.html.\n\nPermission is hereby granted, free of charge, to any person obtaining a copy of the Unicode data files and any associated documentation (the \"Data Files\") or Unicode software and any associated documentation (the \"Software\") to deal in the Data Files or Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, and/or sell copies of the Data Files or Software, and to permit persons to whom the Data Files or Software are furnished to do so, provided that either\n\n   (a) this copyright and permission notice appear with all copies of the Data Files or Software, or\n\n   (b) this copyright and permission notice appear in associated Documentation.\n\nTHE DATA FILES AND SOFTWARE ARE PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THE DATA FILES OR SOFTWARE.\n\nExcept as contained in this notice, the name of a copyright holder shall not be used in advertising or otherwise to promote the sale, use or other dealings in these Data Files or Software without prior written authorization of the copyright holder."],"licenseIds":["Unicode-DFS-2016"],"keywords":["repos icu http","icu http www","unicode org ivd","org ivd data","ivd data and","data and http","trac browser unicode","browser unicode data","repos icu and","icu and http","trac browser notice","browser notice to","copyright 1991 2016","1991 2016 unicode","2016 unicode inc","provided that either","that either a","either a this","or b this","org repos icu http","repos icu http www","icu http www unicode","www unicode org ivd","unicode org ivd data","org ivd data and","ivd data and http","data and http www","utility trac browser unicode","trac browser unicode data","browser unicode data files","org repos icu and","repos icu and http","icu and http www","utility trac browser notice","trac browser notice to","browser notice to user","notice copyright 1991 2016","copyright 1991 2016 unicode","1991 2016 unicode inc","2016 unicode inc all","so provided that either","provided that either a","that either a this","either a this copyright","files or software or","or software or b","software or b this","or b this copyright","in associated documentation the","project org repos icu http","org repos icu http www","repos icu http www unicode","icu http www unicode org","http www unicode org ivd","www unicode org ivd data","unicode org ivd data and","org ivd data and http","ivd data and http www","data and http www unicode","org utility trac browser unicode","utility trac browser unicode data","trac browser unicode data files","browser unicode data files do","project org repos icu and","org repos icu and http","repos icu and http www","icu and http www unicode","org utility trac browser notice","utility trac browser notice to","trac browser notice to user","browser notice to user carefully","permission notice copyright 1991 2016","notice copyright 1991 2016 unicode","copyright 1991 2016 unicode inc","1991 2016 unicode inc all","2016 unicode inc all rights","do so provided that either","so provided that either a","provided that either a this","that either a this copyright","either a this copyright and","data files or software or","files or software or b","or software or b this","software or b this copyright","or b this copyright and","appear in associated documentation the","in associated documentation the data","documentation the data files and"]},{"licenseTexts":["Unicode Terms of Use\n\nFor the general privacy policy governing access to this site, see the Unicode Privacy Policy. For trademark usage, see the Unicode® Consortium Name and Trademark Usage Policy.\n\n   A. Unicode Copyright.\n\n      1. Copyright © 1991-2014 Unicode, Inc. All rights reserved.\n\n      2. Certain documents and files on this website contain a legend indicating that \"Modification is permitted.\" Any person is hereby authorized, without fee, to modify such documents and files to create derivative works conforming to the Unicode® Standard, subject to Terms and Conditions herein.\n\n      3. Any person is hereby authorized, without fee, to view, use, reproduce, and distribute all documents and files solely for informational purposes in the creation of products supporting the Unicode Standard, subject to the Terms and Conditions herein.\n\n      4. Further specifications of rights and restrictions pertaining to the use of the particular set of data files known as the \"Unicode Character Database\" can be found in Exhibit 1.\n\n      5. Each version of the Unicode Standard has further specifications of rights and restrictions of use. For the book editions (Unicode 5.0 and earlier), these are found on the back of the title page. The online code charts carry specific restrictions. All other files, including online documentation of the core specification for Unicode 6.0 and later, are covered under these general Terms of Use.\n\n      6. No license is granted to \"mirror\" the Unicode website where a fee is charged for access to the \"mirror\" site.\n\n      7. Modification is not permitted with respect to this document. All copies of this document must be verbatim.\n\n   B. Restricted Rights Legend. Any technical data or software which is licensed to the United States of America, its agencies and/or instrumentalities under this Agreement is commercial technical data or commercial computer software developed exclusively at private expense as defined in FAR 2.101, or DFARS 252.227-7014 (June 1995), as applicable. For technical data, use, duplication, or disclosure by the Government is subject to restrictions as set forth in DFARS 202.227-7015 Technical Data, Commercial and Items (Nov 1995) and this Agreement. For Software, in accordance with FAR 12-212 or DFARS 227-7202, as applicable, use, duplication or disclosure by the Government is subject to the restrictions set forth in this Agreement.\n\n   C. Warranties and Disclaimers.\n\n      1. This publication and/or website may include technical or typographical errors or other inaccuracies . Changes are periodically added to the information herein; these changes will be incorporated in new editions of the publication and/or website. Unicode may make improvements and/or changes in the product(s) and/or program(s) described in this publication and/or website at any time.\n\n      2. If this file has been purchased on magnetic or optical media from Unicode, Inc. the sole and exclusive remedy for any claim will be exchange of the defective media within ninety (90) days of original purchase.\n\n      3. EXCEPT AS PROVIDED IN SECTION C.2, THIS PUBLICATION AND/OR SOFTWARE IS PROVIDED \"AS IS\" WITHOUT WARRANTY OF ANY KIND EITHER EXPRESS, IMPLIED, OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT. UNICODE AND ITS LICENSORS ASSUME NO RESPONSIBILITY FOR ERRORS OR OMISSIONS IN THIS PUBLICATION AND/OR SOFTWARE OR OTHER DOCUMENTS WHICH ARE REFERENCED BY OR LINKED TO THIS PUBLICATION OR THE UNICODE WEBSITE.\n\n   D. Waiver of Damages. In no event shall Unicode or its licensors be liable for any special, incidental, indirect or consequential damages of any kind, or any damages whatsoever, whether or not Unicode was advised of the possibility of the damage, including, without limitation, those resulting from the following: loss of use, data or profits, in connection with the use, modification or distribution of this information or its derivatives.\n\n   E. Trademarks \u0026 Logos.\n\n      1. The Unicode Word Mark and the Unicode Logo are trademarks of Unicode, Inc. \"The Unicode Consortium\" and \"Unicode, Inc.\" are trade names of Unicode, Inc. Use of the information and materials found on this website indicates your acknowledgement of Unicode, Inc.'s exclusive worldwide rights in the Unicode Word Mark, the Unicode Logo, and the Unicode trade names.\n\n      2. The Unicode Consortium Name and Trademark Usage Policy (\"Trademark Policy\") are incorporated herein by reference and you agree to abide by the provisions of the Trademark Policy, which may be changed from time to time in the sole discretion of Unicode, Inc.\n\n      3. All third party trademarks referenced herein are the property of their respective owners.\n\n   F. Miscellaneous.\n\n      1. Jurisdiction and Venue. This server is operated from a location in the State of California, United States of America. Unicode makes no representation that the materials are appropriate for use in other locations. If you access this server from other locations, you are responsible for compliance with local laws. This Agreement, all use of this site and any claims and damages resulting from use of this site are governed solely by the laws of the State of California without regard to any principles which would apply the laws of a different jurisdiction. The user agrees that any disputes regarding this site shall be resolved solely in the courts located in Santa Clara County, California. The user agrees said courts have personal jurisdiction and agree to waive any right to transfer the dispute to any other forum.\n\n      2. Modification by Unicode Unicode shall have the right to modify this Agreement at any time by posting it to this site. The user may not assign any part of this Agreement without Unicode's prior written consent.\n\n      3. Taxes. The user agrees to pay any taxes arising from access to this website or use of the information herein, except for those based on Unicode's net income.\n\n      4. Severability. If any provision of this Agreement is declared invalid or unenforceable, the remaining provisions of this Agreement shall remain in effect.\n\n      5. Entire Agreement. This Agreement constitutes the entire agreement between the parties."],"licenseIds":["Unicode-TOU"],"keywords":["unicode terms of","for the general","the general privacy","general privacy policy","privacy policy governing","policy governing access","governing access to","this site see","site see the","the unicode privacy","unicode privacy policy","privacy policy for","policy for trademark","for trademark usage","trademark usage see","usage see the","usage policy a","policy a unicode","a unicode copyright","unicode copyright 1","copyright 1 copyright","1 copyright 1991","copyright 1991 2014","1991 2014 unicode","2014 unicode inc","reserved 2 certain","2 certain documents","certain documents and","and files on","files on this","this website contain","website contain a","contain a legend","a legend indicating","legend indicating that","indicating that modification","that modification is","is permitted any","permitted any person","fee to modify","to modify such","modify such documents","such documents and","and files to","files to create","derivative works conforming","works conforming to","conforming to the","to the unicode","subject to terms","to terms and","conditions herein 3","herein 3 any","3 any person","fee to view","to view use","view use reproduce","and distribute all","distribute all documents","and files solely","files solely for","solely for informational","informational purposes in","purposes in the","creation of products","of products supporting","products supporting the","supporting the unicode","conditions herein 4","herein 4 further","4 further specifications","and restrictions pertaining","restrictions pertaining to","the particular set","particular set of","set of data","of data files","data files known","files known as","as the unicode","the unicode character","unicode character database","character database can","database can be","found in exhibit","in exhibit 1","exhibit 1 5","1 5 each","5 each version","unicode standard has","standard has further","has further specifications","and restrictions of","restrictions of use","for the book","the book editions","book editions unicode","editions unicode 5","unicode 5 0","5 0 and","0 and earlier","and earlier these","earlier these are","these are found","are found on","the back of","back of the","page the online","the online code","code charts carry","charts carry specific","carry specific restrictions","specific restrictions all","restrictions all other","all other files","other files including","files including online","including online documentation","online documentation of","documentation of the","of the core","the core specification","core specification for","specification for unicode","for unicode 6","unicode 6 0","6 0 and","0 and later","and later are","later are covered","are covered under","covered under these","under these general","these general terms","general terms of","of use 6","use 6 no","6 no license","granted to mirror","to mirror the","mirror the unicode","unicode website where","website where a","where a fee","charged for access","to the mirror","the mirror site","mirror site 7","site 7 modification","7 modification is","not permitted with","permitted with respect","document all copies","this document must","document must be","must be verbatim","be verbatim b","verbatim b restricted","b restricted rights","restricted rights legend","rights legend any","legend any technical","or software which","which is licensed","of america its","america its agencies","its agencies and","agencies and or","and or instrumentalities","or instrumentalities under","instrumentalities under this","agreement is commercial","is commercial technical","commercial technical data","data or commercial","or commercial computer","computer software developed","software developed exclusively","developed exclusively at","exclusively at private","at private expense","private expense as","expense as defined","2 101 or","101 or dfars","or dfars 252","227 7014 june","7014 june 1995","june 1995 as","1995 as applicable","as applicable for","applicable for technical","for technical data","technical data use","data use duplication","forth in dfars","in dfars 202","dfars 202 227","202 227 7015","data commercial and"]},{"licenseTexts":["This is free and unencumbered software released into the public domain.\n\nAnyone is free to copy, modify, publish, use, compile, sell, or distribute this software, either in source code form or as a compiled binary, for any purpose, commercial or non-commercial, and by any means.\n\nIn jurisdictions that recognize copyright laws, the author or authors of this software dedicate any and all copyright interest in the software to the public domain. We make this dedication for the benefit of the public at large and to the detriment of our heirs and successors. We intend this dedication to be an overt act of relinquishment in perpetuity of all present and future rights to this software under copyright law.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. For more information, please refer to \u003chttps://unlicense.org/\u003e"],"licenseIds":["Unlicense"],"keywords":["free and unencumbered","and unencumbered software","unencumbered software released","software released into","public domain anyone","domain anyone is","anyone is free","modify publish use","publish use compile","use compile sell","compile sell or","sell or distribute","this software either","software either in","either in source","as a compiled","a compiled binary","compiled binary for","binary for any","commercial and by","any means in","means in jurisdictions","jurisdictions that recognize","that recognize copyright","recognize copyright laws","copyright laws the","laws the author","author or authors","this software dedicate","software dedicate any","dedicate any and","public domain we","domain we make","we make this","make this dedication","detriment of our","of our heirs","our heirs and","and successors we","successors we intend","we intend this","intend this dedication","future rights to","rights to this","software under copyright","law the software","software for more","more information please","information please refer","please refer to","refer to https","to https unlicense","https unlicense org","this is free and","is free and unencumbered","free and unencumbered software","and unencumbered software released","unencumbered software released into","software released into the","the public domain anyone","public domain anyone is","domain anyone is free","anyone is free to","is free to copy","copy modify publish use","modify publish use compile","publish use compile sell","use compile sell or","compile sell or distribute","sell or distribute this","distribute this software either","this software either in","software either in source","either in source code","form or as a","or as a compiled","as a compiled binary","a compiled binary for","compiled binary for any","binary for any purpose","non commercial and by","commercial and by any","and by any means","by any means in","any means in jurisdictions","means in jurisdictions that","in jurisdictions that recognize","jurisdictions that recognize copyright","that recognize copyright laws","recognize copyright laws the","copyright laws the author","laws the author or","the author or authors","author or authors of","or authors of this","authors of this software","of this software dedicate","this software dedicate any","software dedicate any and","dedicate any and all","and all copyright interest","interest in the software","in the software to","software to the public","the public domain we","public domain we make","domain we make this","we make this dedication","make this dedication for","the detriment of our","detriment of our heirs","of our heirs and","our heirs and successors","heirs and successors we","and successors we intend","successors we intend this","we intend this dedication","intend this dedication to","and future rights to","future rights to this","rights to this software","to this software under","this software under copyright","software under copyright law","under copyright law the","copyright law the software","law the software is","in the software for","the software for more","software for more information","for more information please","more information please refer","information please refer to","please refer to https","refer to https unlicense","to https unlicense org","this is free and unencumbered","is free and unencumbered software","free and unencumbered software released","and unencumbered software released into","unencumbered software released into the","software released into the public","into the public domain anyone","the public domain anyone is","public domain anyone is free","domain anyone is free to","anyone is free to copy","is free to copy modify","to copy modify publish use","copy modify publish use compile","modify publish use compile sell","publish use compile sell or","use compile sell or distribute","compile sell or distribute this","sell or distribute this software","or distribute this software either","distribute this software either in","this software either in source","software either in source code","either in source code form","in source code form or","code form or as a","form or as a compiled","or as a compiled binary","as a compiled binary for","a compiled binary for any","compiled binary for any purpose","binary for any purpose commercial","or non commercial and by","non commercial and by any","commercial and by any means","and by any means in","by any means in jurisdictions","any means in jurisdictions that","means in jurisdictions that recognize","in jurisdictions that recognize copyright","jurisdictions that recognize copyright laws","that recognize copyright laws the","recognize copyright laws the author","copyright laws the author or","laws the author or authors","the author or authors of","author or authors of this","or authors of this software","authors of this software dedicate","of this software dedicate any","this software dedicate any and","software dedicate any and all","dedicate any and all copyright","any and all copyright interest","and all copyright interest in","copyright interest in the software","interest in the software to","in the software to the","the software to the public","software to the public domain","to the public domain we","the public domain we make","public domain we make this","domain we make this dedication"]},{"licenseTexts":["VOSTROM Public License for Open Source Copyright (c) 2007 VOSTROM Holdings, Inc.\n\nThis VOSTROM Holdings, Inc. (VOSTROM) Distribution (code and documentation) is made available to the open source community as a public service by VOSTROM. Contact VOSTROM at license@vostrom.com for information on other licensing arrangements (e.g. for use in proprietary applications).\n\nUnder this license, this Distribution may be modified and the original version and modified versions may be copied, distributed, publicly displayed and performed provided that the following conditions are met:\n\n   1. Modified versions are distributed with source code and documentation and with permission for others to use any code and documentation (whether in original or modified versions) as granted under this license;\n\n   2. if modified, the source code, documentation, and user run-time elements should be clearly labeled by placing an identifier of origin (such as a name, initial, or other tag) after the version number;\n\n   3. users, modifiers, distributors, and others coming into possession or using the Distribution in original or modified form accept the entire risk as to the possession, use, and performance of the Distribution;\n\n   4. this copyright management information (software identifier and version number, copyright notice and license) shall be retained in all versions of the Distribution;\n\n   5. VOSTROM may make modifications to the Distribution that are substantially similar to modified versions of the Distribution, and may make, use, sell, copy, distribute, publicly display, and perform such modifications, including making such modifications available under this or other licenses, without obligation or restriction;\n\n   6. modifications incorporating code, libraries, and/or documentation subject to any other open source license may be made, and the resulting work may be distributed under the terms of such open source license if required by that open source license, but doing so will not affect this Distribution, other modifications made under this license or modifications made under other VOSTROM licensing arrangements;\n\n   7. no permission is granted to distribute, publicly display, or publicly perform modifications to the Distribution made using proprietary materials that cannot be released in source format under conditions of this license;\n\n   8. the name of VOSTROM may not be used in advertising or publicity pertaining to Distribution of the software without specific, prior written permission.\n\nThis software is made available \"as is\", and\n\nVOSTROM DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, WITH REGARD TO THIS SOFTWARE, INCLUDING WITHOUT LIMITATION ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, AND IN NO EVENT SHALL VOSTROM BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, TORT (INCLUDING NEGLIGENCE) OR STRICT LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE."],"licenseIds":["VOSTROM"],"keywords":["vostrom public license","license for open","for open source","open source copyright","source copyright c","c 2007 vostrom","2007 vostrom holdings","holdings inc this","inc this vostrom","this vostrom holdings","holdings inc vostrom","inc vostrom distribution","vostrom distribution code","distribution code and","documentation is made","source community as","community as a","a public service","public service by","service by vostrom","by vostrom contact","vostrom contact vostrom","contact vostrom at","vostrom at license","at license vostrom","license vostrom com","vostrom com for","com for information","for information on","information on other","on other licensing","other licensing arrangements","licensing arrangements e","arrangements e g","e g for","g for use","use in proprietary","in proprietary applications","proprietary applications under","applications under this","license this distribution","be modified and","original version and","version and modified","be copied distributed","copied distributed publicly","distributed publicly displayed","publicly displayed and","displayed and performed","and performed provided","performed provided that","met 1 modified","1 modified versions","versions are distributed","are distributed with","distributed with source","and documentation and","documentation and with","and with permission","with permission for","permission for others","use any code","any code and","and documentation whether","whether in original","versions as granted","as granted under","license 2 if","2 if modified","if modified the","modified the source","documentation and user","and user run","user run time","run time elements","time elements should","elements should be","should be clearly","clearly labeled by","labeled by placing","by placing an","placing an identifier","an identifier of","identifier of origin","of origin such","origin such as","as a name","a name initial","name initial or","initial or other","or other tag","other tag after","tag after the","after the version","number 3 users","3 users modifiers","users modifiers distributors","modifiers distributors and","distributors and others","and others coming","others coming into","coming into possession","into possession or","possession or using","using the distribution","the distribution in","distribution in original","or modified form","modified form accept","form accept the","accept the entire","to the possession","the possession use","possession use and","use and performance","distribution 4 this","4 this copyright","this copyright management","copyright management information","management information software","information software identifier","software identifier and","identifier and version","and version number","version number copyright","number copyright notice","and license shall","shall be retained","in all versions","the distribution 5","distribution 5 vostrom","5 vostrom may","vostrom may make","the distribution that","distribution that are","that are substantially","are substantially similar","substantially similar to","similar to modified","to modified versions","distribution and may","and may make","may make use","use sell copy","sell copy distribute","copy distribute publicly","publicly display and","and perform such","perform such modifications","such modifications including","modifications including making","including making such","making such modifications","such modifications available","modifications available under","under this or","this or other","other licenses without","licenses without obligation","without obligation or","obligation or restriction","or restriction 6","restriction 6 modifications","6 modifications incorporating","modifications incorporating code","incorporating code libraries","code libraries and","libraries and or","or documentation subject","documentation subject to","any other open","source license may","be made and","resulting work may","such open source","source license if","license if required","if required by","required by that","by that open","source license but","license but doing","but doing so","not affect this","affect this distribution","this distribution other","distribution other modifications","license or modifications","or modifications made","made under other","under other vostrom","other vostrom licensing","vostrom licensing arrangements","licensing arrangements 7","arrangements 7 no","7 no permission","no permission is","to distribute publicly","publicly display or","display or publicly"]},{"licenseTexts":["Vovida Software License v. 1.0 This license applies to all software incorporated in the \"Vovida Open Communication Application Library\" except for those portions incorporating third party software specifically identified as being licensed under separate license. The Vovida Software License, Version 1.0 Copyright (c) 2000 Vovida Networks, Inc. All rights reserved.\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n   2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   3. The names \"VOCAL\", \"Vovida Open Communication Application Library\", and \"Vovida Open Communication Application Library (VOCAL)\" must not be used to endorse or promote products derived from this software without prior written permission. For written permission, please contact vocal@vovida.org.\n\n   4. Products derived from this software may not be called \"VOCAL\", nor may \"VOCAL\" appear in their name, without prior written permission.\n\nTHIS SOFTWARE IS PROVIDED \"AS IS\" AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT ARE DISCLAIMED. IN NO EVENT SHALL VOVIDA NETWORKS, INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY DAMAGES IN EXCESS OF $1,000, NOR FOR ANY INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."],"licenseIds":["VSL-1.0"],"keywords":["to all software","all software incorporated","software incorporated in","in the vovida","the vovida open","application library except","library except for","those portions incorporating","portions incorporating third","incorporating third party","party software specifically","software specifically identified","specifically identified as","identified as being","licensed under separate","under separate license","separate license the","license the vovida","the vovida software","c 2000 vovida","2000 vovida networks","networks inc all","the names vocal","names vocal vovida","vocal vovida open","application library and","library and vovida","and vovida open","application library vocal","library vocal must","vocal must not","please contact vocal","contact vocal vovida","vocal vovida org","vovida org 4","be called vocal","called vocal nor","vocal nor may","nor may vocal","may vocal appear","vocal appear in","event shall vovida","shall vovida networks","networks inc or","any damages in","damages in excess","excess of 1","of 1 000","1 000 nor","000 nor for","any indirect incidental","applies to all software","to all software incorporated","all software incorporated in","software incorporated in the","incorporated in the vovida","in the vovida open","the vovida open communication","communication application library except","application library except for","library except for those","except for those portions","for those portions incorporating","those portions incorporating third","portions incorporating third party","incorporating third party software","third party software specifically","party software specifically identified","software specifically identified as","specifically identified as being","identified as being licensed","being licensed under separate","licensed under separate license","under separate license the","separate license the vovida","license the vovida software","the vovida software license","vovida software license version","copyright c 2000 vovida","c 2000 vovida networks","2000 vovida networks inc","vovida networks inc all","networks inc all rights","3 the names vocal","the names vocal vovida","names vocal vovida open","vocal vovida open communication","communication application library and","application library and vovida","library and vovida open","and vovida open communication","communication application library vocal","application library vocal must","library vocal must not","vocal must not be","permission please contact vocal","please contact vocal vovida","contact vocal vovida org","vocal vovida org 4","vovida org 4 products","not be called vocal","be called vocal nor","called vocal nor may","vocal nor may vocal","nor may vocal appear","may vocal appear in","vocal appear in their","no event shall vovida","event shall vovida networks","shall vovida networks inc","vovida networks inc or","networks inc or its","for any damages in","any damages in excess","damages in excess of","in excess of 1","excess of 1 000","of 1 000 nor","1 000 nor for","000 nor for any","nor for any indirect","for any indirect incidental","any indirect incidental special","v 1 0 this license","1 0 this license applies","license applies to all software","applies to all software incorporated","to all software incorporated in","all software incorporated in the","software incorporated in the vovida","incorporated in the vovida open","in the vovida open communication","the vovida open communication application","open communication application library except","communication application library except for","application library except for those","library except for those portions","except for those portions incorporating","for those portions incorporating third","those portions incorporating third party","portions incorporating third party software","incorporating third party software specifically","third party software specifically identified","party software specifically identified as","software specifically identified as being","specifically identified as being licensed","identified as being licensed under","as being licensed under separate","being licensed under separate license","licensed under separate license the","under separate license the vovida","separate license the vovida software","license the vovida software license","the vovida software license version","vovida software license version 1","1 0 copyright c 2000","0 copyright c 2000 vovida","copyright c 2000 vovida networks","c 2000 vovida networks inc","2000 vovida networks inc all","vovida networks inc all rights","networks inc all rights reserved","distribution 3 the names vocal","3 the names vocal vovida","the names vocal vovida open","names vocal vovida open communication","vocal vovida open communication application","open communication application library and","communication application library and vovida","application library and vovida open","library and vovida open communication","and vovida open communication application","open communication application library vocal","communication application library vocal must","application library vocal must not","library vocal must not be","vocal must not be used","written permission please contact vocal","permission please contact vocal vovida","please contact vocal vovida org","contact vocal vovida org 4","vocal vovida org 4 products","vovida org 4 products derived","may not be called vocal","not be called vocal nor","be called vocal nor may","called vocal nor may vocal","vocal nor may vocal appear","nor may vocal appear in","may vocal appear in their","vocal appear in their name","without prior written permission this","title and non infringement are","in no event shall vovida","no event shall vovida networks","event shall vovida networks inc","shall vovida networks inc or","vovida networks inc or its","networks inc or its contributors","liable for any damages in"]},{"licenseTexts":["VIM LICENSE\n\n   I) There are no restrictions on distributing unmodified copies of Vim except that they must include this license text. You can also distribute unmodified parts of Vim , likewise unrestricted except that they must include this license text. You are also allowed to include executables that you made from the unmodified Vim sources, plus your own usage examples and Vim scripts.\n\n   II) It is allowed to distribute a modified (or extended) version of Vim , including executables and/or source code, when the following four conditions are met:\n\n      1) This license text must be included unmodified.\n\n      2) The modified Vim must be distributed in one of the following five ways:\n\n         a) If you make changes to Vim yourself, you must clearly describe in the distribution how to contact you. When the maintainer asks you (in any way) for a copy of the modified Vim you distributed, you must make your changes, including source code, available to the maintainer without fee. The maintainer reserves the right to include your changes in the official version of Vim . What the maintainer will do with your changes and under what license they will be distributed is negotiable. If there has been no negotiation then this license, or a later version, also applies to your changes. The current maintainer is Bram Moolenaar \u003cBram@vim.org\u003e. If this changes it will be announced in appropriate places (most likely vim.sf.net, www.vim.org and/or comp.editors). When it is completely impossible to contact the maintainer, the obligation to send him your changes ceases. Once the maintainer has confirmed that he has received your changes they will not have to be sent again.\n\n         b) If you have received a modified Vim that was distributed as mentioned under a) you are allowed to further distribute it unmodified, as mentioned at I). If you make additional changes the text under a) applies to those changes.\n\n         c) Provide all the changes, including source code, with every copy of the modified Vim you distribute. This may be done in the form of a context diff. You can choose what license to use for new code you add. The changes and their license must not restrict others from making their own changes to the official version of Vim .\n\n         d) When you have a modified Vim which includes changes as mentioned under c), you can distribute it without the source code for the changes if the following three conditions are met:\n\n            - The license that applies to the changes permits you to distribute the changes to the Vim maintainer without fee or restriction, and permits the Vim maintainer to include the changes in the official version of Vim without fee or restriction.\n\n            - You keep the changes for at least three years after last distributing the corresponding modified Vim . When the maintainer or someone who you distributed the modified Vim to asks you (in any way) for the changes within this period, you must make them available to him.\n\n            - You clearly describe in the distribution how to contact you. This contact information must remain valid for at least three years after last distributing the corresponding modified Vim , or as long as possible.\n\n         e) When the GNU General Public License (GPL) applies to the changes, you can distribute the modified Vim under the GNU GPL version 2 or any later version.\n\n      3) A message must be added, at least in the output of the \":version\" command and in the intro screen, such that the user of the modified Vim is able to see that it was modified. When distributing as mentioned under 2)e) adding the message is only required for as far as this does not conflict with the license used for the changes.\n\n      4) The contact information as required under 2)a) and 2)d) must not be removed or changed, except that the person himself can make corrections.\n\n   III) If you distribute a modified version of Vim , you are encouraged to use the Vim license for your changes and make them available to the maintainer, including the source code. The preferred way to do this is by e-mail or by uploading the files to a server and e-mailing the URL. If the number of changes is small (e.g., a modified Makefile) e-mailing a context diff will do. The e-mail address to be used is \u003cmaintainer@vim.org\u003e\n\n   IV) It is not allowed to remove this license from the distribution of the Vim sources, parts of it or from a modified version. You may use this license for previous Vim releases instead of the license that they came with, at your option."],"licenseIds":["Vim"],"keywords":["vim license i","license i there","i there are","restrictions on distributing","on distributing unmodified","distributing unmodified copies","copies of vim","of vim except","vim except that","text you can","can also distribute","also distribute unmodified","distribute unmodified parts","unmodified parts of","parts of vim","of vim likewise","vim likewise unrestricted","likewise unrestricted except","unrestricted except that","text you are","you are also","are also allowed","also allowed to","allowed to include","to include executables","include executables that","executables that you","that you made","you made from","made from the","from the unmodified","the unmodified vim","unmodified vim sources","vim sources plus","sources plus your","plus your own","your own usage","own usage examples","usage examples and","examples and vim","and vim scripts","vim scripts ii","scripts ii it","ii it is","a modified or","modified or extended","or extended version","extended version of","of vim including","vim including executables","including executables and","executables and or","code when the","the following four","following four conditions","four conditions are","met 1 this","license text must","text must be","be included unmodified","included unmodified 2","unmodified 2 the","2 the modified","modified vim must","vim must be","distributed in one","the following five","following five ways","five ways a","ways a if","you make changes","changes to vim","to vim yourself","vim yourself you","yourself you must","must clearly describe","contact you when","you when the","the maintainer asks","maintainer asks you","way for a","vim you distributed","you distributed you","distributed you must","must make your","make your changes","your changes including","the maintainer without","without fee the","fee the maintainer","the maintainer reserves","maintainer reserves the","right to include","include your changes","your changes in","of vim what","vim what the","what the maintainer","the maintainer will","maintainer will do","will do with","with your changes","changes and under","and under what","under what license","what license they","license they will","they will be","be distributed is","distributed is negotiable","is negotiable if","negotiable if there","if there has","there has been","has been no","been no negotiation","no negotiation then","negotiation then this","later version also","version also applies","to your changes","your changes the","changes the current","maintainer is bram","is bram moolenaar","bram moolenaar bram","moolenaar bram vim","bram vim org","vim org if","org if this","if this changes","this changes it","changes it will","will be announced","be announced in","announced in appropriate","in appropriate places","appropriate places most","places most likely","most likely vim","likely vim sf","vim sf net","sf net www","net www vim","www vim org","vim org and","org and or","and or comp","or comp editors","comp editors when","editors when it","it is completely","is completely impossible","completely impossible to","impossible to contact","to contact the","contact the maintainer","the maintainer the","maintainer the obligation","obligation to send","to send him","send him your","him your changes","your changes ceases","changes ceases once","ceases once the","once the maintainer","the maintainer has","maintainer has confirmed","has confirmed that","confirmed that he","that he has","he has received","has received your","received your changes","your changes they","changes they will","they will not","to be sent","be sent again","sent again b","again b if","received a modified","modified vim that","vim that was","that was distributed","was distributed as","distributed as mentioned","mentioned under a","under a you","a you are","allowed to further","further distribute it","distribute it unmodified","it unmodified as","unmodified as mentioned","as mentioned at","mentioned at i","at i if","you make additional"]},{"licenseTexts":["W3C® SOFTWARE NOTICE AND LICENSE Copyright (c) 1994-2002 World Wide Web Consortium, (Massachusetts Institute of Technology, Institut National de Recherche en Informatique et en Automatique, Keio University). All Rights Reserved. http://www.w3.org/Consortium/Legal/\n\nThis W3C work (including software, documents, or other related items) is being provided by the copyright holders under the following license. By obtaining, using and/or copying this work, you (the licensee) agree that you have read, understood, and will comply with the following terms and conditions:\n\nPermission to use, copy, modify, and distribute this software and its documentation, with or without modification, for any purpose and without fee or royalty is hereby granted, provided that you include the following on ALL copies of the software and documentation or portions thereof, including modifications, that you make:\n\n   1. The full text of this NOTICE in a location viewable to users of the redistributed or derivative work.\n\n   2. Any pre-existing intellectual property disclaimers, notices, or terms and conditions. If none exist, a short notice of the following form (hypertext is preferred, text is permitted) should be used within the body of any redistributed or derivative code: \"Copyright © [$date-of-software] World Wide Web Consortium, (Massachusetts Institute of Technology, Institut National de Recherche en Informatique et en Automatique, Keio University). All Rights Reserved. http://www.w3.org/Consortium/Legal/\"\n\n   3. Notice of any changes or modifications to the W3C files, including the date changes were made. (We recommend you provide URIs to the location from which the code is derived.)\n\nTHIS SOFTWARE AND DOCUMENTATION IS PROVIDED \"AS IS,\" AND COPYRIGHT HOLDERS MAKE NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE OR DOCUMENTATION WILL NOT INFRINGE ANY THIRD PARTY PATENTS, COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS.\n\nCOPYRIGHT HOLDERS WILL NOT BE LIABLE FOR ANY DIRECT, INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF ANY USE OF THE SOFTWARE OR DOCUMENTATION.\n\nThe name and trademarks of copyright holders may NOT be used in advertising or publicity pertaining to the software without specific, written prior permission. Title to copyright in this software and any associated documentation will at all times remain with copyright holders. ____________________________________\n\nThis formulation of W3C's notice and license became active on August 14 1998 so as to improve compatibility with GPL. This version ensures that W3C software licensing terms are no more restrictive than GPL and consequently W3C software may be distributed in GPL packages. See the older formulation for the policy prior to this date. Please see our Copyright FAQ for common questions about using materials from our site, including specific terms and conditions for packages like libwww, Amaya, and Jigsaw. Other questions about this notice can be directed to site-policy@w3.org."],"licenseIds":["W3C-19980720"],"keywords":["and license copyright","c 1994 2002","1994 2002 world","2002 world wide","consortium legal this","legal this w3c","this w3c work","w3c work including","date of software","of software world","software world wide","consortium legal 3","legal 3 notice","to the w3c","the w3c files","w3c files including","holders this formulation","active on august","on august 14","august 14 1998","14 1998 so","1998 so as","as to improve","to improve compatibility","improve compatibility with","compatibility with gpl","with gpl this","gpl this version","this version ensures","version ensures that","ensures that w3c","that w3c software","w3c software licensing","software licensing terms","licensing terms are","terms are no","are no more","more restrictive than","restrictive than gpl","than gpl and","gpl and consequently","and consequently w3c","consequently w3c software","w3c software may","distributed in gpl","in gpl packages","gpl packages see","packages see the","see the older","the older formulation","older formulation for","formulation for the","for the policy","the policy prior","policy prior to","prior to this","to this date","this date please","date please see","please see our","see our copyright","our copyright faq","copyright faq for","faq for common","for common questions","common questions about","questions about using","about using materials","using materials from","materials from our","from our site","our site including","site including specific","including specific terms","conditions for packages","for packages like","packages like libwww","like libwww amaya","libwww amaya and","amaya and jigsaw","and jigsaw other","jigsaw other questions","other questions about","questions about this","about this notice","this notice can","can be directed","directed to site","to site policy","site policy w3","policy w3 org","notice and license copyright","and license copyright c","license copyright c 1994","copyright c 1994 2002","c 1994 2002 world","1994 2002 world wide","2002 world wide web","org consortium legal this","consortium legal this w3c","legal this w3c work","this w3c work including","w3c work including software","copyright date of software","date of software world","of software world wide","software world wide web","org consortium legal 3","consortium legal 3 notice","legal 3 notice of","modifications to the w3c","to the w3c files","the w3c files including","w3c files including the","with copyright holders this","copyright holders this formulation","holders this formulation of","became active on august","active on august 14","on august 14 1998","august 14 1998 so","14 1998 so as","1998 so as to","so as to improve","as to improve compatibility","to improve compatibility with","improve compatibility with gpl","compatibility with gpl this","with gpl this version","gpl this version ensures","this version ensures that","version ensures that w3c","ensures that w3c software","that w3c software licensing","w3c software licensing terms","software licensing terms are","licensing terms are no","terms are no more","are no more restrictive","no more restrictive than","more restrictive than gpl","restrictive than gpl and","than gpl and consequently","gpl and consequently w3c","and consequently w3c software","consequently w3c software may","w3c software may be","may be distributed in","be distributed in gpl","distributed in gpl packages","in gpl packages see","gpl packages see the","packages see the older","see the older formulation","the older formulation for","older formulation for the","formulation for the policy","for the policy prior","the policy prior to","policy prior to this","prior to this date","to this date please","this date please see","date please see our","please see our copyright","see our copyright faq","our copyright faq for","copyright faq for common","faq for common questions","for common questions about","common questions about using","questions about using materials","about using materials from","using materials from our","materials from our site","from our site including","our site including specific","site including specific terms","including specific terms and","and conditions for packages","conditions for packages like","for packages like libwww","packages like libwww amaya","like libwww amaya and","libwww amaya and jigsaw","amaya and jigsaw other","and jigsaw other questions","jigsaw other questions about","other questions about this","questions about this notice","about this notice can","this notice can be","notice can be directed","can be directed to","be directed to site","directed to site policy","to site policy w3","site policy w3 org","software notice and license copyright","notice and license copyright c"]},{"licenseTexts":["This work is being provided by the copyright holders under the following license.\n\nLicense\n\nBy obtaining and/or copying this work, you (the licensee) agree that you have read, understood, and will comply with the following terms and conditions.\n\nPermission to copy, modify, and distribute this work, with or without modification, for any purpose and without fee or royalty is hereby granted, provided that you include the following on ALL copies of the work or portions thereof, including modifications:\n\n   • The full text of this NOTICE in a location viewable to users of the redistributed or derivative work.\n\n   • Any pre-existing intellectual property disclaimers, notices, or terms and conditions. If none exist, the W3C Software and Document Short Notice should be included.\n\n   • Notice of any changes or modifications, through a copyright statement on the new code or document such as \"This software or document includes material copied from or derived from [title and URI of the W3C document]. Copyright (c) [YEAR] W3C® (MIT, ERCIM, Keio, Beihang).\"\n\nDisclaimers\n\nTHIS WORK IS PROVIDED \"AS IS,\" AND COPYRIGHT HOLDERS MAKE NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE OR DOCUMENT WILL NOT INFRINGE ANY THIRD PARTY PATENTS, COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS.\n\nCOPYRIGHT HOLDERS WILL NOT BE LIABLE FOR ANY DIRECT, INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF ANY USE OF THE SOFTWARE OR DOCUMENT.\n\nThe name and trademarks of copyright holders may NOT be used in advertising or publicity pertaining to the work without specific, written prior permission. Title to copyright in this work will at all times remain with copyright holders."],"licenseIds":["W3C-20150513"],"keywords":["work is being","by obtaining and","obtaining and or","distribute this work","this work with","work with or","w3c software and","software and document","and document short","document short notice","be included notice","included notice of","or modifications through","modifications through a","through a copyright","a copyright statement","copyright statement on","statement on the","on the new","the new code","new code or","code or document","or document such","document such as","or document includes","document includes material","includes material copied","copied from or","from or derived","derived from title","from title and","title and uri","and uri of","the w3c document","w3c document copyright","document copyright c","c year w3c","year w3c mit","w3c mit ercim","mit ercim keio","ercim keio beihang","keio beihang disclaimers","beihang disclaimers this","disclaimers this work","or document will","document will not","or document the","document the name","work without specific","this work will","work will at","this work is being","work is being provided","license by obtaining and","by obtaining and or","obtaining and or copying","and distribute this work","distribute this work with","this work with or","work with or without","the work or portions","the w3c software and","w3c software and document","software and document short","and document short notice","document short notice should","should be included notice","be included notice of","included notice of any","changes or modifications through","or modifications through a","modifications through a copyright","through a copyright statement","a copyright statement on","copyright statement on the","statement on the new","on the new code","the new code or","new code or document","code or document such","or document such as","document such as this","such as this software","as this software or","this software or document","software or document includes","or document includes material","document includes material copied","includes material copied from","material copied from or","copied from or derived","from or derived from","or derived from title","derived from title and","from title and uri","title and uri of","and uri of the","uri of the w3c","of the w3c document","the w3c document copyright","w3c document copyright c","document copyright c year","copyright c year w3c","c year w3c mit","year w3c mit ercim","w3c mit ercim keio","mit ercim keio beihang","ercim keio beihang disclaimers","keio beihang disclaimers this","beihang disclaimers this work","disclaimers this work is","software or document will","or document will not","document will not infringe","software or document the","or document the name","document the name and","pertaining to the work","to the work without","the work without specific","work without specific written","copyright in this work","in this work will","this work will at","work will at all","this work is being provided","work is being provided by","license license by obtaining and","license by obtaining and or","by obtaining and or copying","obtaining and or copying this","modify and distribute this work","and distribute this work with","distribute this work with or","this work with or without","work with or without modification","all copies of the work","of the work or portions","the work or portions thereof","exist the w3c software and","the w3c software and document","w3c software and document short","software and document short notice","and document short notice should","document short notice should be","notice should be included notice","should be included notice of","be included notice of any","included notice of any changes","any changes or modifications through","changes or modifications through a","or modifications through a copyright","modifications through a copyright statement","through a copyright statement on","a copyright statement on the","copyright statement on the new","statement on the new code","on the new code or","the new code or document","new code or document such","code or document such as","or document such as this","document such as this software","such as this software or","as this software or document","this software or document includes","software or document includes material","or document includes material copied","document includes material copied from","includes material copied from or","material copied from or derived","copied from or derived from","from or derived from title","or derived from title and","derived from title and uri","from title and uri of","title and uri of the","and uri of the w3c","uri of the w3c document","of the w3c document copyright","the w3c document copyright c","w3c document copyright c year","document copyright c year w3c","copyright c year w3c mit","c year w3c mit ercim","year w3c mit ercim keio","w3c mit ercim keio beihang","mit ercim keio beihang disclaimers","ercim keio beihang disclaimers this","keio beihang disclaimers this work","beihang disclaimers this work is","disclaimers this work is provided","the software or document will","software or document will not","or document will not infringe","document will not infringe any","the software or document the","software or document the name","or document the name and","document the name and trademarks"]},{"licenseTexts":["W3C SOFTWARE NOTICE AND LICENSE\n\nThis work (and included software, documentation such as READMEs, or other related items) is being provided by the copyright holders under the following license.\n\nLicense\n\nBy obtaining, using and/or copying this work, you (the licensee) agree that you have read, understood, and will comply with the following terms and conditions.\n\nPermission to copy, modify, and distribute this software and its documentation, with or without modification, for any purpose and without fee or royalty is hereby granted, provided that you include the following on ALL copies of the software and documentation or portions thereof, including modifications:\n\nThe full text of this NOTICE in a location viewable to users of the redistributed or derivative work.\n\nAny pre-existing intellectual property disclaimers, notices, or terms and conditions. If none exist, the W3C Software Short Notice should be included (hypertext is preferred, text is permitted) within the body of any redistributed or derivative code.\n\nNotice of any changes or modifications to the files, including the date changes were made. (We recommend you provide URIs to the location from which the code is derived.)\n\nDisclaimers\n\nTHIS SOFTWARE AND DOCUMENTATION IS PROVIDED \"AS IS,\" AND COPYRIGHT HOLDERS MAKE NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE OR DOCUMENTATION WILL NOT INFRINGE ANY THIRD PARTY PATENTS, COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS.\n\nCOPYRIGHT HOLDERS WILL NOT BE LIABLE FOR ANY DIRECT, INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF ANY USE OF THE SOFTWARE OR DOCUMENTATION.\n\nThe name and trademarks of copyright holders may NOT be used in advertising or publicity pertaining to the software without specific, written prior permission. Title to copyright in this software and any associated documentation will at all times remain with copyright holders. Notes\n\nThis version: http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231\n\nThis formulation of W3C's notice and license became active on December 31 2002. This version removes the copyright ownership notice such that this license can be used with materials other than those owned by the W3C, reflects that ERCIM is now a host of the W3C, includes references to this specific dated version of the license, and removes the ambiguous grant of \"use\". Otherwise, this version is the same as the previous version and is written so as to preserve the Free Software Foundation's assessment of GPL compatibility and OSI's certification under the Open Source Definition."],"licenseIds":["W3C"],"keywords":["license this work","work and included","and included software","included software documentation","software documentation such","documentation such as","such as readmes","as readmes or","readmes or other","w3c software short","software short notice","be included hypertext","included hypertext is","is permitted within","permitted within the","derivative code notice","code notice of","to the files","the files including","is derived disclaimers","derived disclaimers this","disclaimers this software","copyright holders notes","holders notes this","notes this version","this version http","version http www","consortium legal 2002","legal 2002 copyright","2002 copyright software","copyright software 20021231","software 20021231 this","20021231 this formulation","active on december","on december 31","december 31 2002","31 2002 this","2002 this version","this version removes","version removes the","removes the copyright","the copyright ownership","copyright ownership notice","ownership notice such","notice such that","such that this","used with materials","with materials other","materials other than","than those owned","those owned by","by the w3c","the w3c reflects","w3c reflects that","reflects that ercim","that ercim is","ercim is now","is now a","now a host","a host of","host of the","the w3c includes","w3c includes references","includes references to","to this specific","this specific dated","specific dated version","dated version of","license and removes","and removes the","removes the ambiguous","the ambiguous grant","ambiguous grant of","grant of use","of use otherwise","use otherwise this","otherwise this version","this version is","version is the","same as the","as the previous","the previous version","previous version and","version and is","and is written","is written so","preserve the free","foundation s assessment","s assessment of","assessment of gpl","of gpl compatibility","gpl compatibility and","compatibility and osi","and osi s","osi s certification","s certification under","certification under the","notice and license this","and license this work","license this work and","this work and included","work and included software","and included software documentation","included software documentation such","software documentation such as","documentation such as readmes","such as readmes or","as readmes or other","readmes or other related","the w3c software short","w3c software short notice","software short notice should","should be included hypertext","be included hypertext is","included hypertext is preferred","text is permitted within","is permitted within the","permitted within the body","or derivative code notice","derivative code notice of","code notice of any","modifications to the files","to the files including","the files including the","code is derived disclaimers","is derived disclaimers this","derived disclaimers this software","disclaimers this software and","with copyright holders notes","copyright holders notes this","holders notes this version","notes this version http","this version http www","version http www w3","org consortium legal 2002","consortium legal 2002 copyright","legal 2002 copyright software","2002 copyright software 20021231","copyright software 20021231 this","software 20021231 this formulation","20021231 this formulation of","became active on december","active on december 31","on december 31 2002","december 31 2002 this","31 2002 this version","2002 this version removes","this version removes the","version removes the copyright","removes the copyright ownership","the copyright ownership notice","copyright ownership notice such","ownership notice such that","notice such that this","such that this license","that this license can","can be used with","be used with materials","used with materials other","with materials other than","materials other than those","other than those owned","than those owned by","those owned by the","owned by the w3c","by the w3c reflects","the w3c reflects that","w3c reflects that ercim","reflects that ercim is","that ercim is now","ercim is now a","is now a host","now a host of","a host of the","host of the w3c","of the w3c includes","the w3c includes references","w3c includes references to","includes references to this","references to this specific","to this specific dated","this specific dated version","specific dated version of","dated version of the","the license and removes","license and removes the","and removes the ambiguous","removes the ambiguous grant","the ambiguous grant of","ambiguous grant of use","grant of use otherwise","of use otherwise this","use otherwise this version","otherwise this version is","this version is the","version is the same","the same as the","same as the previous","as the previous version","the previous version and"]},{"licenseTexts":["DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE\n\nVersion 2, December 2004\n\nCopyright (C) 2004 Sam Hocevar \u003csam@hocevar.net\u003e\n\nEveryone is permitted to copy and distribute verbatim or modified copies of this license document, and changing it is allowed as long as the name is changed.\n\nDO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE\n\nTERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION\n\n   0. You just DO WHAT THE FUCK YOU WANT TO."],"licenseIds":["WTFPL"],"keywords":["version 2 december","2 december 2004","december 2004 copyright","2004 copyright c","c 2004 sam","2004 sam hocevar","sam hocevar sam","hocevar sam hocevar","sam hocevar net","hocevar net everyone","net everyone is","distribute verbatim or","verbatim or modified","or modified copies","license document and","document and changing","and changing it","is allowed as","allowed as long","as the name","is changed do","changed do what","modification 0 you","0 you just","you just do","just do what","to public license version","license version 2 december","version 2 december 2004","2 december 2004 copyright","december 2004 copyright c","2004 copyright c 2004","copyright c 2004 sam","c 2004 sam hocevar","2004 sam hocevar sam","sam hocevar sam hocevar","hocevar sam hocevar net","sam hocevar net everyone","hocevar net everyone is","net everyone is permitted","and distribute verbatim or","distribute verbatim or modified","verbatim or modified copies","or modified copies of","modified copies of this","this license document and","license document and changing","document and changing it","and changing it is","changing it is allowed","it is allowed as","is allowed as long","allowed as long as","long as the name","as the name is","name is changed do","is changed do what","changed do what the","to public license terms","and modification 0 you","modification 0 you just","0 you just do","you just do what","just do what the","want to public license version","to public license version 2","public license version 2 december","license version 2 december 2004","version 2 december 2004 copyright","2 december 2004 copyright c","december 2004 copyright c 2004","2004 copyright c 2004 sam","copyright c 2004 sam hocevar","c 2004 sam hocevar sam","2004 sam hocevar sam hocevar","sam hocevar sam hocevar net","hocevar sam hocevar net everyone","sam hocevar net everyone is","hocevar net everyone is permitted","net everyone is permitted to","copy and distribute verbatim or","and distribute verbatim or modified","distribute verbatim or modified copies","verbatim or modified copies of","or modified copies of this","modified copies of this license","of this license document and","this license document and changing","license document and changing it","document and changing it is","and changing it is allowed","changing it is allowed as","it is allowed as long","is allowed as long as","allowed as long as the","as long as the name","long as the name is","as the name is changed","the name is changed do","name is changed do what","is changed do what the","changed do what the fuck","want to public license terms","to public license terms and","distribution and modification 0 you","and modification 0 you just","modification 0 you just do","0 you just do what","you just do what the","just do what the fuck"]},{"licenseTexts":["EXCEPTION NOTICE\n\n   1. As a special exception, the copyright holders of this library give permission for additional uses of the text contained in this release of the library as licenced under the wxWindows Library Licence, applying either version 3.1 of the Licence, or (at your option) any later version of the Licence as published by the copyright holders of version 3.1 of the Licence document.\n\n   2. The exception is that you may use, copy, link, modify and distribute under your own terms, binary object code versions of works based on the Library.\n\n   3. If you copy code from files distributed under the terms of the GNU General Public Licence or the GNU Library General Public Licence into a copy of this library, as this licence permits, the exception does not apply to the code that you add in this way. To avoid misleading anyone as to the status of such modified files, you must delete this exception notice from such code and/or adjust the licensing conditions notice accordingly.\n\n   4. If you write modifications of your own for this library, it is your choice whether to permit this exception to apply to your modifications. If you do not wish that, you must delete the exception notice from such code and/or adjust the licensing conditions notice accordingly."],"licenseIds":["wxWindows"],"keywords":["exception notice 1","notice 1 as","1 as a","library give permission","give permission for","permission for additional","for additional uses","additional uses of","uses of the","the text contained","text contained in","in this release","this release of","library as licenced","as licenced under","licenced under the","under the wxwindows","the wxwindows library","wxwindows library licence","library licence applying","licence applying either","applying either version","licence or at","licence as published","holders of version","the licence document","licence document 2","document 2 the","2 the exception","the exception is","exception is that","is that you","use copy link","copy link modify","link modify and","and distribute under","distribute under your","your own terms","own terms binary","terms binary object","binary object code","object code versions","code versions of","versions of works","of works based","the library 3","library 3 if","you copy code","copy code from","code from files","from files distributed","files distributed under","public licence or","public licence into","licence into a","into a copy","this library as","library as this","as this licence","this licence permits","licence permits the","permits the exception","the exception does","the code that","you add in","add in this","this way to","way to avoid","to avoid misleading","avoid misleading anyone","misleading anyone as","anyone as to","to the status","status of such","of such modified","modified files you","files you must","must delete this","this exception notice","notice accordingly 4","accordingly 4 if","if you write","you write modifications","write modifications of","modifications of your","your own for","own for this","for this library","this library it","is your choice","your choice whether","choice whether to","whether to permit","to permit this","permit this exception","exception to apply","your modifications if","not wish that","must delete the","delete the exception","the exception notice","exception notice 1 as","notice 1 as a","1 as a special","this library give permission","library give permission for","give permission for additional","permission for additional uses","for additional uses of","additional uses of the","uses of the text","of the text contained","the text contained in","text contained in this","contained in this release","in this release of","this release of the","release of the library","of the library as","the library as licenced","library as licenced under","as licenced under the","licenced under the wxwindows","under the wxwindows library","the wxwindows library licence","wxwindows library licence applying","library licence applying either","licence applying either version","applying either version 3","either version 3 1","the licence or at","licence or at your","the licence as published","licence as published by","published by the copyright","copyright holders of version","holders of version 3","of version 3 1","of the licence document","the licence document 2","licence document 2 the","document 2 the exception","2 the exception is","the exception is that","exception is that you","is that you may","that you may use","may use copy link","use copy link modify","copy link modify and","link modify and distribute","modify and distribute under","and distribute under your","distribute under your own","under your own terms","your own terms binary","own terms binary object","terms binary object code","binary object code versions","object code versions of","code versions of works","versions of works based","of works based on","on the library 3","the library 3 if","library 3 if you","3 if you copy","if you copy code","you copy code from","copy code from files","code from files distributed","from files distributed under","files distributed under the","gnu general public licence","general public licence or","public licence or the","licence or the gnu","or the gnu library","library general public licence","general public licence into","public licence into a","licence into a copy","into a copy of","copy of this library","of this library as","this library as this","library as this licence","as this licence permits","this licence permits the","licence permits the exception","permits the exception does","the exception does not","exception does not apply","to the code that","the code that you","code that you add","that you add in","you add in this","add in this way","in this way to"]},{"licenseTexts":["Sybase Open Watcom Public License version 1.0\n\nUSE OF THE SYBASE OPEN WATCOM SOFTWARE DESCRIBED BELOW (\"SOFTWARE\") IS SUBJECT TO THE TERMS AND CONDITIONS SET FORTH IN THE SYBASE OPEN WATCOM PUBLIC LICENSE SET FORTH BELOW (\"LICENSE\"). YOU MAY NOT USE THE SOFTWARE IN ANY MANNER UNLESS YOU ACCEPT THE TERMS AND CONDITIONS OF THE LICENSE. YOU INDICATE YOUR ACCEPTANCE BY IN ANY MANNER USING (INCLUDING WITHOUT LIMITATION BY REPRODUCING, MODIFYING OR DISTRIBUTING) THE SOFTWARE. IF YOU DO NOT ACCEPT ALL OF THE TERMS AND CONDITIONS OF THE LICENSE, DO NOT USE THE SOFTWARE IN ANY MANNER.\n\nSybase Open Watcom Public License version 1.0\n\n   1. General; Definitions. This License applies only to the following software programs: the open source versions of Sybase's Watcom C/C++ and Fortran compiler products (\"Software\"), which are modified versions of, with significant changes from, the last versions made commercially available by Sybase. As used in this License:\n\n      1.1 \"Applicable Patent Rights\" mean: (a) in the case where Sybase is the grantor of rights, (i) claims of patents that are now or hereafter acquired, owned by or assigned to Sybase and (ii) that cover subject matter contained in the Original Code, but only to the extent necessary to use, reproduce and/or distribute the Original Code without infringement; and (b) in the case where You are the grantor of rights, (i) claims of patents that are now or hereafter acquired, owned by or assigned to You and (ii) that cover subject matter in Your Modifications, taken alone or in combination with Original Code.\n\n      1.2 \"Contributor\" means any person or entity that creates or contributes to the creation of Modifications.\n\n      1.3 \"Covered Code\" means the Original Code, Modifications, the combination of Original Code and any Modifications, and/or any respective portions thereof.\n\n      1.4 \"Deploy\" means to use, sublicense or distribute Covered Code other than for Your internal research and development (R\u0026D) and/or Personal Use, and includes without limitation, any and all internal use or distribution of Covered Code within Your business or organization except for R\u0026D use and/or Personal Use, as well as direct or indirect sublicensing or distribution of Covered Code by You to any third party in any form or manner.\n\n      1.5 \"Larger Work\" means a work which combines Covered Code or portions thereof with code not governed by the terms of this License.\n\n      1.6 \"Modifications\" mean any addition to, deletion from, and/or change to, the substance and/or structure of the Original Code, any previous Modifications, the combination of Original Code and any previous Modifications, and/or any respective portions thereof. When code is released as a series of files, a Modification is: (a) any addition to or deletion from the contents of a file containing Covered Code; and/or (b) any new file or other representation of computer program statements that contains any part of Covered Code.\n\n      1.7 \"Original Code\" means (a) the Source Code of a program or other work as originally made available by Sybase under this License, including the Source Code of any updates or upgrades to such programs or works made available by Sybase under this License, and that has been expressly identified by Sybase as such in the header file(s) of such work; and (b) the object code compiled from such Source Code and originally made available by Sybase under this License.\n\n      1.8 \"Personal Use\" means use of Covered Code by an individual solely for his or her personal, private and non-commercial purposes. An individual's use of Covered Code in his or her capacity as an officer, employee, member, independent contractor or agent of a corporation, business or organization (commercial or non-commercial) does not qualify as Personal Use.\n\n      1.9 \"Source Code\" means the human readable form of a program or other work that is suitable for making modifications to it, including all modules it contains, plus any associated interface definition files, scripts used to control compilation and installation of an executable (object code).\n\n      1.10 \"You\" or \"Your\" means an individual or a legal entity exercising rights under this License. For legal entities, \"You\" or \"Your\" includes any entity which controls, is controlled by, or is under common control with, You, where \"control\" means (a) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (b) ownership of fifty percent (50%) or more of the outstanding shares or beneficial ownership of such entity.\n\n   2. Permitted Uses; Conditions \u0026 Restrictions.Subject to the terms and conditions of this License, Sybase hereby grants You, effective on the date You accept this License and download the Original Code, a world-wide, royalty-free, non-exclusive license, to the extent of Sybase's Applicable Patent Rights and copyrights covering the Original Code, to do the following:\n\n      2.1 You may use, reproduce, display, perform, modify and distribute Original Code, with or without Modifications, solely for Your internal research and development and/or Personal Use, provided that in each instance:\n\n         (a) You must retain and reproduce in all copies of Original Code the copyright and other proprietary notices and disclaimers of Sybase as they appear in the Original Code, and keep intact all notices in the Original Code that refer to this License; and\n\n         (b) You must retain and reproduce a copy of this License with every copy of Source Code of Covered Code and documentation You distribute, and You may not offer or impose any terms on such Source Code that alter or restrict this License or the recipients' rights hereunder, except as permitted under Section 6.\n\n         (c) Whenever reasonably feasible you should include the copy of this License in a click-wrap format, which requires affirmative acceptance by clicking on an \"I accept\" button or similar mechanism. If a click-wrap format is not included, you must include a statement that any use (including without limitation reproduction, modification or distribution) of the Software, and any other affirmative act that you define, constitutes acceptance of the License, and instructing the user not to use the Covered Code in any manner if the user does not accept all of the terms and conditions of the License.\n\n      2.2 You may use, reproduce, display, perform, modify and Deploy Covered Code, provided that in each instance:\n\n         (a) You must satisfy all the conditions of Section 2.1 with respect to the Source Code of the Covered Code;\n\n         (b) You must duplicate, to the extent it does not already exist, the notice in Exhibit A in each file of the Source Code of all Your Modifications, and cause the modified files to carry prominent notices stating that You changed the files and the date of any change;\n\n         (c) You must make Source Code of all Your Deployed Modifications publicly available under the terms of this License, including the license grants set forth in Section 3 below, for as long as you Deploy the Covered Code or twelve (12) months from the date of initial Deployment, whichever is longer. You should preferably distribute the Source Code of Your Deployed Modifications electronically (e.g. download from a web site);\n\n         (d) if You Deploy Covered Code in object code, executable form only, You must include a prominent notice, in the code itself as well as in related documentation, stating that Source Code of the Covered Code is available under the terms of this License with information on how and where to obtain such Source Code; and\n\n         (e) the object code form of the Covered Code may be distributed under Your own license agreement, provided that such license agreement contains terms no less protective of Sybase and each Contributor than the terms of this License, and stating that any provisions which differ from this License are offered by You alone and not by any other party.\n\n      2.3 You expressly acknowledge and agree that although Sybase and each Contributor grants the licenses to their respective portions of the Covered Code set forth herein, no assurances are provided by Sybase or any Contributor that the Covered Code does not infringe the patent or other intellectual property rights of any other entity. Sybase and each Contributor disclaim any liability to You for claims brought by any other entity based on infringement of intellectual property rights or otherwise. As a condition to exercising the rights and licenses granted hereunder, You hereby assume sole responsibility to secure any other intellectual property rights needed, if any. For example, if a third party patent license is required to allow You to distribute the Covered Code, it is Your responsibility to acquire that license before distributing the Covered Code.\n\n   3. Your Grants. In consideration of, and as a condition to, the licenses granted to You under this License, You hereby grant to Sybase and all third parties a non-exclusive, royalty-free license, under Your Applicable Patent Rights and other intellectual property rights (other than patent) owned or controlled by You, to use, reproduce, display, perform, modify, distribute and Deploy Your Modifications of the same scope and extent as Sybase's licenses under Sections 2.1 and 2.2.\n\n   4. Larger Works. You may create a Larger Work by combining Covered Code with other code not governed by the terms of this License and distribute the Larger Work as a single product. In each such instance, You must make sure the requirements of this License are fulfilled for the Covered Code or any portion thereof.\n\n   5. Limitations on Patent License. Except as expressly stated in Section 2, no other patent rights, express or implied, are granted by Sybase herein. Modifications and/or Larger Works may require additional patent licenses from Sybase which Sybase may grant in its sole discretion.\n\n   6. Additional Terms. You may choose to offer, and to charge a fee for, warranty, support, indemnity or liability obligations and/or other rights consistent with this License (\"Additional Terms\") to one or more recipients of Covered Code. However, You may do so only on Your own behalf and as Your sole responsibility, and not on behalf of Sybase or any Contributor. You must obtain the recipient's agreement that any such Additional Terms are offered by You alone, and You hereby agree to indemnify, defend and hold Sybase and every Contributor harmless for any liability incurred by or claims asserted against Sybase or such Contributor by reason of any such Additional Terms.\n\n   7. Versions of the License. Sybase may publish revised and/or new versions of this License from time to time. Each version will be given a distinguishing version number. Once Original Code has been published under a particular version of this License, You may continue to use it under the terms of that version. You may also choose to use such Original Code under the terms of any subsequent version of this License published by Sybase. No one other than Sybase has the right to modify the terms applicable to Covered Code created under this License.\n\n   8. NO WARRANTY OR SUPPORT. The Covered Code may contain in whole or in part pre-release, untested, or not fully tested works. The Covered Code may contain errors that could cause failures or loss of data, and may be incomplete or contain inaccuracies. You expressly acknowledge and agree that use of the Covered Code, or any portion thereof, is at Your sole and entire risk. THE COVERED CODE IS PROVIDED \"AS IS\" AND WITHOUT WARRANTY, UPGRADES OR SUPPORT OF ANY KIND AND SYBASE AND SYBASE'S LICENSOR(S) (COLLECTIVELY REFERRED TO AS \"SYBASE\" FOR THE PURPOSES OF SECTIONS 8 AND 9) AND ALL CONTRIBUTORS EXPRESSLY DISCLAIM ALL WARRANTIES AND/OR CONDITIONS, EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES AND/OR CONDITIONS OF MERCHANTABILITY, OF SATISFACTORY QUALITY, OF FITNESS FOR A PARTICULAR PURPOSE, OF ACCURACY, OF QUIET ENJOYMENT, AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. SYBASE AND EACH CONTRIBUTOR DOES NOT WARRANT AGAINST INTERFERENCE WITH YOUR ENJOYMENT OF THE COVERED CODE, THAT THE FUNCTIONS CONTAINED IN THE COVERED CODE WILL MEET YOUR REQUIREMENTS, THAT THE OPERATION OF THE COVERED CODE WILL BE UNINTERRUPTED OR ERROR-FREE, OR THAT DEFECTS IN THE COVERED CODE WILL BE CORRECTED. NO ORAL OR WRITTEN INFORMATION OR ADVICE GIVEN BY SYBASE, A SYBASE AUTHORIZED REPRESENTATIVE OR ANY CONTRIBUTOR SHALL CREATE A WARRANTY. You acknowledge that the Covered Code is not intended for use in the operation of nuclear facilities, aircraft navigation, communication systems, or air traffic control machines in which case the failure of the Covered Code could lead to death, personal injury, or severe physical or environmental damage.\n\n   9. LIMITATION OF LIABILITY. TO THE EXTENT NOT PROHIBITED BY LAW, IN NO EVENT SHALL SYBASE OR ANY CONTRIBUTOR BE LIABLE FOR ANY DIRECT, INCIDENTAL, SPECIAL, INDIRECT, CONSEQUENTIAL OR OTHER DAMAGES OF ANY KIND ARISING OUT OF OR RELATING TO THIS LICENSE OR YOUR USE OR INABILITY TO USE THE COVERED CODE, OR ANY PORTION THEREOF, WHETHER UNDER A THEORY OF CONTRACT, WARRANTY, TORT (INCLUDING NEGLIGENCE), PRODUCTS LIABILITY OR OTHERWISE, EVEN IF SYBASE OR SUCH CONTRIBUTOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES, AND NOTWITHSTANDING THE FAILURE OF ESSENTIAL PURPOSE OF ANY REMEDY. SOME JURISDICTIONS DO NOT ALLOW THE LIMITATION OF LIABILITY OF INCIDENTAL OR CONSEQUENTIAL OR OTHER DAMAGES OF ANY KIND, SO THIS LIMITATION MAY NOT APPLY TO YOU. In no event shall Sybase's or any Contributor's total liability to You for all damages (other than as may be required by applicable law) under this License exceed the amount of five hundred dollars ($500.00).\n\n   10. Trademarks. This License does not grant any rights to use the trademarks or trade names \"Sybase\" or any other trademarks or trade names belonging to Sybase (collectively \"Sybase Marks\") or to any trademark or trade name belonging to any Contributor(\"Contributor Marks\"). No Sybase Marks or Contributor Marks may be used to endorse or promote products derived from the Original Code or Covered Code other than with the prior written consent of Sybase or the Contributor, as applicable.\n\n   11. Ownership. Subject to the licenses granted under this License, each Contributor retains all rights, title and interest in and to any Modifications made by such Contributor. Sybase retains all rights, title and interest in and to the Original Code and any Modifications made by or on behalf of Sybase (\"Sybase Modifications\"), and such Sybase Modifications will not be automatically subject to this License. Sybase may, at its sole discretion, choose to license such Sybase Modifications under this License, or on different terms from those contained in this License or may choose not to license them at all.\n\n   12. Termination.\n\n      12.1 Termination. This License and the rights granted hereunder will terminate:\n\n         (a) automatically without notice if You fail to comply with any term(s) of this License and fail to cure such breach within 30 days of becoming aware of such breach;\n\n         (b) immediately in the event of the circumstances described in Section 13.5(b); or\n\n         (c) automatically without notice if You, at any time during the term of this License, commence an action for patent infringement (including as a cross claim or counterclaim) against Sybase or any Contributor.\n\n      12.2 Effect of Termination. Upon termination, You agree to immediately stop any further use, reproduction, modification, sublicensing and distribution of the Covered Code and to destroy all copies of the Covered Code that are in your possession or control. All sublicenses to the Covered Code that have been properly granted prior to termination shall survive any termination of this License. Provisions which, by their nature, should remain in effect beyond the termination of this License shall survive, including but not limited to Sections 3, 5, 8, 9, 10, 11, 12.2 and 13. No party will be liable to any other for compensation, indemnity or damages of any sort solely as a result of terminating this License in accordance with its terms, and termination of this License will be without prejudice to any other right or remedy of any party.\n\n   13. Miscellaneous.\n\n      13.1 Government End Users. The Covered Code is a \"commercial item\" as defined in FAR 2.101. Government software and technical data rights in the Covered Code include only those rights customarily provided to the public as defined in this License. This customary commercial license in technical data and software is provided in accordance with FAR 12.211 (Technical Data) and 12.212 (Computer Software) and, for Department of Defense purchases, DFAR 252.227-7015 (Technical Data -- Commercial Items) and 227.7202-3 (Rights in Commercial Computer Software or Computer Software Documentation). Accordingly, all U.S. Government End Users acquire Covered Code with only those rights set forth herein.\n\n      13.2 Relationship of Parties. This License will not be construed as creating an agency, partnership, joint venture or any other form of legal association between or among you, Sybase or any Contributor, and You will not represent to the contrary, whether expressly, by implication, appearance or otherwise.\n\n      13.3 Independent Development. Nothing in this License will impair Sybase's or any Contributor's right to acquire, license, develop, have others develop for it, market and/or distribute technology or products that perform the same or similar functions as, or otherwise compete with, Modifications, Larger Works, technology or products that You may develop, produce, market or distribute.\n\n      13.4 Waiver; Construction. Failure by Sybase or any Contributor to enforce any provision of this License will not be deemed a waiver of future enforcement of that or any other provision. Any law or regulation which provides that the language of a contract shall be construed against the drafter will not apply to this License.\n\n      13.5 Severability. (a) If for any reason a court of competent jurisdiction finds any provision of this License, or portion thereof, to be unenforceable, that provision of the License will be enforced to the maximum extent permissible so as to effect the economic benefits and intent of the parties, and the remainder of this License will continue in full force and effect. (b) Notwithstanding the foregoing, if applicable law prohibits or restricts You from fully and/or specifically complying with Sections 2 and/or 3 or prevents the enforceability of either of those Sections, this License will immediately terminate and You must immediately discontinue any use of the Covered Code and destroy all copies of it that are in your possession or control.\n\n      13.6 Dispute Resolution. Any litigation or other dispute resolution between You and Sybase relating to this License shall take place in the Northern District of California, and You and Sybase hereby consent to the personal jurisdiction of, and venue in, the state and federal courts within that District with respect to this License. The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded.\n\n      13.7 Entire Agreement; Governing Law. This License constitutes the entire agreement between the parties with respect to the subject matter hereof. This License shall be governed by the laws of the United States and the State of California, except that body of California law concerning conflicts of law.\n\nWhere You are located in the province of Quebec, Canada, the following clause applies: The parties hereby confirm that they have requested that this License and all related documents be drafted in English. Les parties ont exigè que le prèsent contrat et tous les documents connexes soient rèdiès en anglais. EXHIBIT A.\n\n\"Portions Copyright (c) 1983-2002 Sybase, Inc. All Rights Reserved.\n\nThis file contains Original Code and/or Modifications of Original Code as defined in and that are subject to the Sybase Open Watcom Public License version 1.0 (the 'License'). You may not use this file except in compliance with the License. BY USING THIS FILE YOU AGREE TO ALL TERMS AND CONDITIONS OF THE LICENSE. A copy of the License is provided with the Original Code and Modifications, and is also available at www.sybase.com/developer/opensource.\n\nThe Original Code and all software distributed under the License are distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, AND SYBASE AND ALL CONTRIBUTORS HEREBY DISCLAIM ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. Please see the License for the specific language governing rights and limitations under the License.\""],"licenseIds":["Watcom-1.0"],"keywords":["0 use of","of the sybase","open watcom software","watcom software described","software described below","described below software","below software is","in the sybase","public license set","forth below license","below license you","any manner unless","manner unless you","unless you accept","license you indicate","your acceptance by","acceptance by in","by in any","any manner using","manner using including","using including without","limitation by reproducing","by reproducing modifying","reproducing modifying or","any manner sybase","manner sybase open","the following software","following software programs","software programs the","programs the open","open source versions","versions of sybase","sybase s watcom","s watcom c","watcom c c","c c and","c and fortran","and fortran compiler","fortran compiler products","compiler products software","products software which","which are modified","are modified versions","versions of with","of with significant","with significant changes","significant changes from","from the last","the last versions","last versions made","versions made commercially","made commercially available","commercially available by","sybase as used","case where sybase","where sybase is","sybase is the","assigned to sybase","sybase and ii","identified by sybase","sybase as such","license sybase hereby","sybase hereby grants","extent of sybase","sybase s applicable","disclaimers of sybase","of sybase as","sybase as they","and reproduce a","reproduce a copy","6 c whenever","c whenever reasonably","whenever reasonably feasible","reasonably feasible you","feasible you should","include the copy","in a click","wrap format which","format which requires","which requires affirmative","requires affirmative acceptance","affirmative acceptance by","acceptance by clicking","on an i","an i accept","i accept button","button or similar","or similar mechanism","similar mechanism if","mechanism if a","if a click","wrap format is","is not included","not included you","included you must","statement that any","that any use","any use including","use including without","without limitation reproduction","limitation reproduction modification","any other affirmative","other affirmative act","affirmative act that","act that you","that you define","you define constitutes","define constitutes acceptance","license and instructing","and instructing the","instructing the user","the user not","user not to","any manner if","manner if the","the user does","user does not","does not accept","the license 2","web site d","site d if","code and e","and e the","e the object","distributed under your","license agreement contains","agreement contains terms","contains terms no","terms no less","no less protective","protective of sybase","of sybase and","each contributor than","contributor than the","than the terms","license and stating","stating that any","other party 2","party 2 3","that although sybase","although sybase and","provided by sybase","other entity sybase","entity sybase and","grant to sybase","extent as sybase","as sybase s","sybase s licenses","2 2 4","2 4 larger","granted by sybase","by sybase herein","sybase herein modifications","licenses from sybase","from sybase which","sybase which sybase","which sybase may","sybase may grant","this license additional","and hold sybase","hold sybase and","sybase and every","asserted against sybase","the license sybase","sybase may publish","published by sybase","by sybase no","sybase no one","other than sybase","than sybase has","sybase has the","kind and sybase","sybase and sybase","and sybase s","sybase s licensor","to as sybase","as sybase for","sybase for the","party rights sybase","rights sybase and","given by sybase","by sybase a","sybase a sybase","a sybase authorized","sybase authorized representative","shall sybase or","any direct incidental","direct incidental special","special indirect consequential","indirect consequential or","even if sybase","if sybase or","or consequential or","any kind so","kind so this","shall sybase s","contributor s total","amount of five","of five hundred","five hundred dollars"]},{"licenseTexts":["This file was added by Clea F. Rees on 2008/11/30 with the permission of Dean Guenther and pointers to this file were added to all source files.\n\nUnlimited copying and redistribution of each of the files is permitted as long as the file is not modified. Modifications, and redistribution of modified versions, are also permitted, but only if the resulting file is renamed. The copyright holder is Washington State University. The original author of the fonts is Janene Winter. The primary contact (as of 2008) is Dean Guenther."],"licenseIds":["Wsuipa"],"keywords":["this file was","file was added","added by clea","by clea f","clea f rees","f rees on","rees on 2008","on 2008 11","2008 11 30","11 30 with","30 with the","permission of dean","of dean guenther","dean guenther and","guenther and pointers","and pointers to","pointers to this","this file were","file were added","added to all","to all source","all source files","source files unlimited","files unlimited copying","unlimited copying and","copying and redistribution","redistribution of each","the files is","files is permitted","is permitted as","permitted as long","as the file","not modified modifications","modified modifications and","modifications and redistribution","versions are also","are also permitted","permitted but only","if the resulting","the resulting file","resulting file is","file is renamed","is renamed the","renamed the copyright","holder is washington","is washington state","washington state university","state university the","university the original","original author of","of the fonts","the fonts is","fonts is janene","is janene winter","janene winter the","winter the primary","primary contact as","contact as of","as of 2008","of 2008 is","2008 is dean","is dean guenther","this file was added","file was added by","was added by clea","added by clea f","by clea f rees","clea f rees on","f rees on 2008","rees on 2008 11","on 2008 11 30","2008 11 30 with","11 30 with the","30 with the permission","the permission of dean","permission of dean guenther","of dean guenther and","dean guenther and pointers","guenther and pointers to","and pointers to this","pointers to this file","to this file were","this file were added","file were added to","were added to all","added to all source","to all source files","all source files unlimited","source files unlimited copying","files unlimited copying and","unlimited copying and redistribution","copying and redistribution of","and redistribution of each","redistribution of each of","of the files is","the files is permitted","files is permitted as","is permitted as long","permitted as long as","long as the file","as the file is","file is not modified","is not modified modifications","not modified modifications and","modified modifications and redistribution","modifications and redistribution of","and redistribution of modified","of modified versions are","modified versions are also","versions are also permitted","are also permitted but","also permitted but only","permitted but only if","but only if the","only if the resulting","if the resulting file","the resulting file is","resulting file is renamed","file is renamed the","is renamed the copyright","renamed the copyright holder","the copyright holder is","copyright holder is washington","holder is washington state","is washington state university","washington state university the","state university the original","university the original author","the original author of","original author of the","author of the fonts","of the fonts is","the fonts is janene","fonts is janene winter","is janene winter the","janene winter the primary","winter the primary contact","the primary contact as","primary contact as of","contact as of 2008","as of 2008 is","of 2008 is dean","2008 is dean guenther","this file was added by","file was added by clea","was added by clea f","added by clea f rees","by clea f rees on","clea f rees on 2008","f rees on 2008 11","rees on 2008 11 30","on 2008 11 30 with","2008 11 30 with the","11 30 with the permission","30 with the permission of","with the permission of dean","the permission of dean guenther","permission of dean guenther and","of dean guenther and pointers","dean guenther and pointers to","guenther and pointers to this","and pointers to this file","pointers to this file were","to this file were added","this file were added to","file were added to all","were added to all source","added to all source files","to all source files unlimited","all source files unlimited copying","source files unlimited copying and","files unlimited copying and redistribution","unlimited copying and redistribution of","copying and redistribution of each","and redistribution of each of","redistribution of each of the","of each of the files","each of the files is","of the files is permitted","the files is permitted as","files is permitted as long","is permitted as long as","permitted as long as the","as long as the file","long as the file is","as the file is not","the file is not modified","file is not modified modifications","is not modified modifications and","not modified modifications and redistribution","modified modifications and redistribution of","modifications and redistribution of modified","and redistribution of modified versions","redistribution of modified versions are","of modified versions are also","modified versions are also permitted","versions are also permitted but","are also permitted but only","also permitted but only if","permitted but only if the"]},{"licenseTexts":["X11 License Copyright (C) 1996 X Consortium\n\nPermission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the \"Software\"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nExcept as contained in this notice, the name of the X Consortium shall not be used in advertising or otherwise to promote the sale, use or other dealings in this Software without prior written authorization from the X Consortium.\n\nX Window System is a trademark of X Consortium, Inc."],"licenseIds":["X11"],"keywords":["x11 license copyright","c 1996 x","1996 x consortium","x consortium permission","consortium permission is","shall the x","x consortium be","consortium be liable","of the x","x consortium shall","consortium shall not","from the x","x consortium x","consortium x window","x window system","window system is","system is a","trademark of x","of x consortium","x consortium inc","x11 license copyright c","copyright c 1996 x","c 1996 x consortium","1996 x consortium permission","x consortium permission is","consortium permission is hereby","event shall the x","shall the x consortium","the x consortium be","x consortium be liable","consortium be liable for","name of the x","of the x consortium","the x consortium shall","x consortium shall not","consortium shall not be","authorization from the x","from the x consortium","the x consortium x","x consortium x window","consortium x window system","x window system is","window system is a","system is a trademark","a trademark of x","trademark of x consortium","of x consortium inc","x11 license copyright c 1996","license copyright c 1996 x","copyright c 1996 x consortium","c 1996 x consortium permission","1996 x consortium permission is","x consortium permission is hereby","consortium permission is hereby granted","no event shall the x","event shall the x consortium","shall the x consortium be","the x consortium be liable","x consortium be liable for","consortium be liable for any","the name of the x","name of the x consortium","of the x consortium shall","the x consortium shall not","x consortium shall not be","consortium shall not be used","written authorization from the x","authorization from the x consortium","from the x consortium x","the x consortium x window","x consortium x window system","consortium x window system is","x window system is a","window system is a trademark","system is a trademark of","is a trademark of x","a trademark of x consortium","trademark of x consortium inc"]},{"licenseTexts":["XFree86 License (version 1.1) Copyright (C) 1994-2006 The XFree86 Project, Inc.\n\nAll rights reserved.\n\nPermission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the \"Software\"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:\n\n   1. Redistributions of source code must retain the above copyright notice, this list of conditions, and the following disclaimer.\n\n   2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution, and in the same place and form as other copyright, license and disclaimer information.\n\n   3. The end-user documentation included with the redistribution, if any, must include the following acknowledgment: \"This product includes software developed by The XFree86 Project, Inc (http://www.xfree86.org/) and its contributors\", in the same place and form as other third-party acknowledgments. Alternately, this acknowledgment may appear in the software itself, in the same form and location as other such third-party acknowledgments.\n\n   4. Except as contained in this notice, the name of The XFree86 Project, Inc shall not be used in advertising or otherwise to promote the sale, use or other dealings in this Software without prior written authorization from The XFree86 Project, Inc.\n\nTHIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE XFREE86 PROJECT, INC OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."],"licenseIds":["XFree86-1.1"],"keywords":["xfree86 license version","c 1994 2006","1994 2006 the","2006 the xfree86","project inc all","distribution and in","as other copyright","other copyright license","and disclaimer information","disclaimer information 3","information 3 the","by the xfree86","project inc http","http www xfree86","www xfree86 org","xfree86 org and","org and its","its contributors in","as other third","party acknowledgments alternately","acknowledgments alternately this","software itself in","itself in the","same form and","form and location","and location as","location as other","as other such","other such third","party acknowledgments 4","acknowledgments 4 except","4 except as","of the xfree86","project inc shall","from the xfree86","project inc this","inc this software","shall the xfree86","project inc or","xfree86 license version 1","1 copyright c 1994","copyright c 1994 2006","c 1994 2006 the","1994 2006 the xfree86","2006 the xfree86 project","xfree86 project inc all","project inc all rights","the distribution and in","distribution and in the","and in the same","form as other copyright","as other copyright license","other copyright license and","copyright license and disclaimer","license and disclaimer information","and disclaimer information 3","disclaimer information 3 the","information 3 the end","developed by the xfree86","by the xfree86 project","xfree86 project inc http","project inc http www","inc http www xfree86","http www xfree86 org","www xfree86 org and","xfree86 org and its","org and its contributors","and its contributors in","its contributors in the","contributors in the same","form as other third","as other third party","other third party acknowledgments","third party acknowledgments alternately","party acknowledgments alternately this","acknowledgments alternately this acknowledgment","the software itself in","software itself in the","itself in the same","the same form and","same form and location","form and location as","and location as other","location as other such","as other such third","other such third party","third party acknowledgments 4","party acknowledgments 4 except","acknowledgments 4 except as","4 except as contained","name of the xfree86","of the xfree86 project","xfree86 project inc shall","project inc shall not","authorization from the xfree86","from the xfree86 project","xfree86 project inc this","project inc this software","inc this software is","event shall the xfree86","shall the xfree86 project","xfree86 project inc or","project inc or its","xfree86 license version 1 1","1 1 copyright c 1994","1 copyright c 1994 2006","copyright c 1994 2006 the","c 1994 2006 the xfree86","1994 2006 the xfree86 project","2006 the xfree86 project inc","the xfree86 project inc all","xfree86 project inc all rights","project inc all rights reserved","conditions 1 redistributions of source","with the distribution and in","the distribution and in the","distribution and in the same","and in the same place","and form as other copyright","form as other copyright license","as other copyright license and","other copyright license and disclaimer","copyright license and disclaimer information","license and disclaimer information 3","and disclaimer information 3 the","disclaimer information 3 the end","information 3 the end user","software developed by the xfree86","developed by the xfree86 project","by the xfree86 project inc","the xfree86 project inc http","xfree86 project inc http www","project inc http www xfree86","inc http www xfree86 org","http www xfree86 org and","www xfree86 org and its","xfree86 org and its contributors","org and its contributors in","and its contributors in the","its contributors in the same","contributors in the same place","and form as other third","form as other third party","as other third party acknowledgments","other third party acknowledgments alternately","third party acknowledgments alternately this","party acknowledgments alternately this acknowledgment","acknowledgments alternately this acknowledgment may","in the software itself in","the software itself in the","software itself in the same","itself in the same form","in the same form and","the same form and location","same form and location as","form and location as other","and location as other such","location as other such third","as other such third party","other such third party acknowledgments","such third party acknowledgments 4","third party acknowledgments 4 except","party acknowledgments 4 except as","acknowledgments 4 except as contained","4 except as contained in","the name of the xfree86","name of the xfree86 project","of the xfree86 project inc","the xfree86 project inc shall","xfree86 project inc shall not","project inc shall not be","written authorization from the xfree86","authorization from the xfree86 project","from the xfree86 project inc","the xfree86 project inc this","xfree86 project inc this software","project inc this software is","inc this software is provided","no event shall the xfree86","event shall the xfree86 project","shall the xfree86 project inc","the xfree86 project inc or","xfree86 project inc or its","project inc or its contributors"]},{"licenseTexts":["This program is free software; you can redistribute it freely.\n\nUse it at your own risk; there is NO WARRANTY.\n\nRedistribution of modified versions is permitted provided that the following conditions are met:\n\n   1. All copyright \u0026 permission notices are preserved.\n\n   2.a) Only changes required for packaging or porting are made.\n\n   or\n\n   2.b) It is clearly stated who last changed the program. The program is renamed or the version number is of the form x.y.z, where x.y is the version of the original program and z is an arbitrary suffix."],"licenseIds":["XSkat"],"keywords":["it freely use","freely use it","use it at","it at your","own risk there","risk there is","no warranty redistribution","warranty redistribution of","versions is permitted","all copyright permission","copyright permission notices","permission notices are","notices are preserved","are preserved 2","preserved 2 a","2 a only","a only changes","only changes required","changes required for","required for packaging","for packaging or","packaging or porting","or porting are","porting are made","are made or","made or 2","or 2 b","2 b it","b it is","it is clearly","is clearly stated","clearly stated who","stated who last","who last changed","last changed the","changed the program","program is renamed","is renamed or","renamed or the","or the version","version number is","number is of","is of the","the form x","form x y","x y z","y z where","z where x","where x y","x y is","y is the","is the version","program and z","and z is","z is an","is an arbitrary","an arbitrary suffix","can redistribute it freely","redistribute it freely use","it freely use it","freely use it at","use it at your","it at your own","your own risk there","own risk there is","risk there is no","is no warranty redistribution","no warranty redistribution of","warranty redistribution of modified","of modified versions is","modified versions is permitted","versions is permitted provided","met 1 all copyright","1 all copyright permission","all copyright permission notices","copyright permission notices are","permission notices are preserved","notices are preserved 2","are preserved 2 a","preserved 2 a only","2 a only changes","a only changes required","only changes required for","changes required for packaging","required for packaging or","for packaging or porting","packaging or porting are","or porting are made","porting are made or","are made or 2","made or 2 b","or 2 b it","2 b it is","b it is clearly","it is clearly stated","is clearly stated who","clearly stated who last","stated who last changed","who last changed the","last changed the program","changed the program the","the program the program","the program is renamed","program is renamed or","is renamed or the","renamed or the version","or the version number","the version number is","version number is of","number is of the","is of the form","of the form x","the form x y","form x y z","x y z where","y z where x","z where x y","where x y is","x y is the","y is the version","is the version of","of the original program","original program and z","program and z is","and z is an","z is an arbitrary","is an arbitrary suffix","you can redistribute it freely","can redistribute it freely use","redistribute it freely use it","it freely use it at","freely use it at your","use it at your own","it at your own risk","at your own risk there","your own risk there is","own risk there is no","risk there is no warranty","there is no warranty redistribution","is no warranty redistribution of","no warranty redistribution of modified","warranty redistribution of modified versions","redistribution of modified versions is","of modified versions is permitted","modified versions is permitted provided","versions is permitted provided that","are met 1 all copyright","met 1 all copyright permission","1 all copyright permission notices","all copyright permission notices are","copyright permission notices are preserved","permission notices are preserved 2","notices are preserved 2 a","are preserved 2 a only","preserved 2 a only changes","2 a only changes required","a only changes required for","only changes required for packaging","changes required for packaging or","required for packaging or porting","for packaging or porting are","packaging or porting are made","or porting are made or","porting are made or 2","are made or 2 b","made or 2 b it","or 2 b it is","2 b it is clearly","b it is clearly stated","it is clearly stated who","is clearly stated who last","clearly stated who last changed","stated who last changed the","who last changed the program","last changed the program the","changed the program the program","the program the program is","program the program is renamed","the program is renamed or","program is renamed or the","is renamed or the version","renamed or the version number","or the version number is","the version number is of","version number is of the","number is of the form","is of the form x","of the form x y","the form x y z","form x y z where","x y z where x","y z where x y","z where x y is","where x y is the","x y is the version","y is the version of","is the version of the","version of the original program","of the original program and","the original program and z"]},{"licenseTexts":["Copyright (c) 1995, 1996 Xerox Corporation. All Rights Reserved.\n\nUse and copying of this software and preparation of derivative works based upon this software are permitted. Any copy of this software or of any derivative work must include the above copyright notice of Xerox Corporation, this paragraph and the one after it. Any distribution of this software or derivative works must comply with all applicable United States export control laws.\n\nThis software is made available AS IS, and XEROX CORPORATION DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, AND NOTWITHSTANDING ANY OTHER PROVISION CONTAINED HEREIN, ANY LIABILITY FOR DAMAGES RESULTING FROM THE SOFTWARE OR ITS USE IS EXPRESSLY DISCLAIMED, WHETHER ARISING IN CONTRACT, TORT (INCLUDING NEGLIGENCE) OR STRICT LIABILITY, EVEN IF XEROX CORPORATION IS ADVISED OF THE POSSIBILITY OF SUCH DAMAGES."],"licenseIds":["Xerox"],"keywords":["1995 1996 xerox","1996 xerox corporation","xerox corporation all","reserved use and","use and copying","and copying of","copying of this","software and preparation","and preparation of","based upon this","upon this software","software are permitted","permitted any copy","notice of xerox","of xerox corporation","xerox corporation this","corporation this paragraph","and the one","the one after","one after it","after it any","it any distribution","works must comply","all applicable united","applicable united states","states export control","control laws this","is and xerox","and xerox corporation","xerox corporation disclaims","corporation disclaims all","purpose and notwithstanding","other provision contained","provision contained herein","contained herein any","herein any liability","use is expressly","is expressly disclaimed","expressly disclaimed whether","disclaimed whether arising","whether arising in","arising in contract","strict liability even","liability even if","even if xerox","if xerox corporation","xerox corporation is","corporation is advised","is advised of","c 1995 1996 xerox","1995 1996 xerox corporation","1996 xerox corporation all","xerox corporation all rights","rights reserved use and","reserved use and copying","use and copying of","and copying of this","copying of this software","this software and preparation","software and preparation of","and preparation of derivative","works based upon this","based upon this software","upon this software are","this software are permitted","software are permitted any","are permitted any copy","permitted any copy of","any copy of this","this software or of","software or of any","or of any derivative","of any derivative work","above copyright notice of","copyright notice of xerox","notice of xerox corporation","of xerox corporation this","xerox corporation this paragraph","corporation this paragraph and","paragraph and the one","and the one after","the one after it","one after it any","after it any distribution","it any distribution of","distribution of this software","this software or derivative","or derivative works must","derivative works must comply","works must comply with","with all applicable united","all applicable united states","applicable united states export","united states export control","states export control laws","export control laws this","control laws this software","as is and xerox","is and xerox corporation","and xerox corporation disclaims","xerox corporation disclaims all","corporation disclaims all warranties","particular purpose and notwithstanding","purpose and notwithstanding any","and notwithstanding any other","any other provision contained","other provision contained herein","provision contained herein any","contained herein any liability","herein any liability for","any liability for damages","resulting from the software","or its use is","its use is expressly","use is expressly disclaimed","is expressly disclaimed whether","expressly disclaimed whether arising","disclaimed whether arising in","whether arising in contract","arising in contract tort","in contract tort including","or strict liability even","strict liability even if","liability even if xerox","even if xerox corporation","if xerox corporation is","xerox corporation is advised","corporation is advised of","is advised of the","copyright c 1995 1996 xerox","c 1995 1996 xerox corporation","1995 1996 xerox corporation all","1996 xerox corporation all rights","xerox corporation all rights reserved","corporation all rights reserved use","all rights reserved use and","rights reserved use and copying","reserved use and copying of","use and copying of this","and copying of this software","copying of this software and","of this software and preparation","this software and preparation of","software and preparation of derivative","and preparation of derivative works","of derivative works based upon","derivative works based upon this","works based upon this software","based upon this software are","upon this software are permitted","this software are permitted any","software are permitted any copy","are permitted any copy of","permitted any copy of this","any copy of this software","copy of this software or","of this software or of","this software or of any","software or of any derivative","or of any derivative work","of any derivative work must","work must include the above","the above copyright notice of","above copyright notice of xerox","copyright notice of xerox corporation","notice of xerox corporation this","of xerox corporation this paragraph","xerox corporation this paragraph and","corporation this paragraph and the","this paragraph and the one","paragraph and the one after","and the one after it","the one after it any","one after it any distribution","after it any distribution of","it any distribution of this","any distribution of this software","distribution of this software or","of this software or derivative","this software or derivative works","software or derivative works must","or derivative works must comply","derivative works must comply with","works must comply with all","must comply with all applicable","comply with all applicable united","with all applicable united states","all applicable united states export","applicable united states export control","united states export control laws","states export control laws this","export control laws this software","control laws this software is","laws this software is made","available as is and xerox","as is and xerox corporation","is and xerox corporation disclaims","and xerox corporation disclaims all","xerox corporation disclaims all warranties","corporation disclaims all warranties express"]},{"licenseTexts":["The X.Net, Inc. License Copyright (c) 2000-2001 X.Net, Inc. Lafayette, California, USA\n\nPermission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the \"Software\"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nThis agreement shall be governed in all respects by the laws of the State of California and by the laws of the United States of America."],"licenseIds":["Xnet"],"keywords":["the x net","net inc license","inc license copyright","2000 2001 x","2001 x net","net inc lafayette","inc lafayette california","lafayette california usa","be governed in","governed in all","california and by","and by the","the x net inc","x net inc license","net inc license copyright","inc license copyright c","c 2000 2001 x","2000 2001 x net","2001 x net inc","x net inc lafayette","net inc lafayette california","inc lafayette california usa","lafayette california usa permission","the software this agreement","software this agreement shall","shall be governed in","be governed in all","governed in all respects","respects by the laws","of california and by","california and by the","and by the laws","the x net inc license","x net inc license copyright","net inc license copyright c","inc license copyright c 2000","license copyright c 2000 2001","copyright c 2000 2001 x","c 2000 2001 x net","2000 2001 x net inc","2001 x net inc lafayette","x net inc lafayette california","net inc lafayette california usa","inc lafayette california usa permission","lafayette california usa permission is","dealings in the software this","in the software this agreement","the software this agreement shall","software this agreement shall be","agreement shall be governed in","shall be governed in all","be governed in all respects","governed in all respects by","all respects by the laws","respects by the laws of","state of california and by","of california and by the","california and by the laws","and by the laws of"]},{"licenseTexts":["Yahoo! Public License, Version 1.0 (YPL)\n\nThis Yahoo! Public License (this \"Agreement\") is a legal agreement that describes the terms under which Yahoo! Inc., a Delaware corporation having its principal place of business at 701 First Avenue, Sunnyvale, California 94089 (\"Yahoo!\") will provide software to you via download or otherwise (\"Software\"). By using the Software, you, an individual or an entity (\"You\") agree to the terms of this Agreement.\n\nIn consideration of the mutual promises and upon the terms and conditions set forth below, the parties agree as follows:\n\n   1. Grant of Copyright License\n\n      1.1 - Subject to the terms and conditions of this Agreement, Yahoo! hereby grants to You, under any and all of its copyright interest in and to the Software, a royalty-free, non-exclusive, non-transferable license to copy, modify, compile, execute, and distribute the Software and Modifications. For the purposes of this Agreement, any change to, addition to, or abridgement of the Software made by You is a \"Modification;\" however, any file You add to the Software that does not contain any part of the Software is not a \"Modification.\"\n\n      1.2 - If You are an individual acting on behalf of a corporation or other entity, Your use of the Software or any Modification is subject to Your having the authority to bind such corporation or entity to this Agreement. Providing copies to persons within such corporation or entity is not considered distribution for purposes of this Agreement.\n\n      1.3 - For the Software or any Modification You distribute in source code format, You must do so only under the terms of this Agreement, and You must include a complete copy of this Agreement with Your distribution. With respect to any Modification You distribute in source code format, the terms of this Agreement will apply to You in the same way those terms apply to Yahoo! with respect to the Software. In other words, when You are distributing Modifications under this Agreement, You \"stand in the shoes\" of Yahoo! in terms of the rights You grant and how the terms and conditions apply to You and the licensees of Your Modifications. Notwithstanding the foregoing, when You \"stand in the shoes\" of Yahoo!, You are not subject to the jurisdiction provision under Section 7, which requires all disputes under this Agreement to be subject to the jurisdiction of federal or state courts of northern California.\n\n      1.4 - For the Software or any Modification You distribute in compiled or object code format, You must also provide recipients with access to the Software or Modification in source code format along with a complete copy of this Agreement. The distribution of the Software or Modifications in compiled or object code format may be under a license of Your choice, provided that You are in compliance with the terms of this Agreement. In addition, You must make absolutely clear that any license terms applying to such Software or Modification that differ from this Agreement are offered by You alone and not by Yahoo!, and that such license does not restrict recipients from exercising rights in the source code to the Software granted by Yahoo! under this Agreement or rights in the source code to any Modification granted by You as described in Section 1.3.\n\n      1.5 - This Agreement does not limit Your right to distribute files that are entirely Your own work (i.e., which do not incorporate any portion of the Software and are not Modifications) under any terms You choose.\n\n   2. Support\n\n   Yahoo! has no obligation to provide technical support or updates to You. Nothing in this Agreement requires Yahoo! to enter into any license with You for any other edition of the Software.\n\n   3. Intellectual Property Rights\n\n      3.1 - Except for the license expressly granted under copyright in Section 1.1, no rights, licenses or forbearances are granted or may arise in relation to this Agreement whether expressly, by implication, exhaustion, estoppel or otherwise. All rights, including all intellectual property rights, that are not expressly granted under this Agreement are hereby reserved.\n\n      3.2 - In any copy of the Software or in any Modification you create, You must retain and reproduce, any and all copyright, patent, trademark, and attribution notices that are included in the Software in the same form as they appear in the Software. This includes the preservation of attribution notices in the form of trademarks or logos that exist within a user interface of the Software.\n\n      3.3 - This license does not grant You rights to use any party's name, logo, or trademarks, except solely as necessary to comply with Section 3.2.\n\n   4. Disclaimer of Warranties\n\n   THE SOFTWARE IS PROVIDED \"AS IS\" AND WITHOUT WARRANTY OF ANY KIND. YAHOO! MAKES NO WARRANTIES, WHETHER EXPRESS, IMPLIED, OR STATUTORY REGARDING OR RELATING TO THE SOFTWARE. SPECIFICALLY, YAHOO! DOES NOT WARRANT THAT THE SOFTWARE WILL BE ERROR FREE OR WILL PERFORM IN AN UNINTERRUPTED MANNER. TO THE GREATEST EXTENT ALLOWED BY LAW, YAHOO! SPECIFICALLY DISCLAIMS ALL IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE (EVEN IF YAHOO! HAD BEEN INFORMED OF SUCH PURPOSE), AND NONINFRINGEMENT WITH RESPECT TO THE SOFTWARE, ANY MODIFICATIONS THERETO AND WITH RESPECT TO THE USE OF THE FOREGOING.\n\n   5. Limitation of Liability\n\n   IN NO EVENT WILL YAHOO! BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES OF ANY KIND (INCLUDING WITHOUT LIMITATION LOSS OF PROFITS, LOSS OF USE, BUSINESS INTERRUPTION, LOSS OF DATA, COST OF COVER) IN CONNECTION WITH OR ARISING OUT OF OR RELATING TO THE FURNISHING, PERFORMANCE OR USE OF THE SOFTWARE OR ANY OTHER RIGHTS GRANTED HEREUNDER, WHETHER ALLEGED AS A BREACH OF CONTRACT OR TORTIOUS CONDUCT, INCLUDING NEGLIGENCE, AND EVEN IF YAHOO! HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\n   6. Term and Termination\n\n      6.1 - This Agreement will continue in effect unless and until terminated earlier pursuant to this Section 6.\n\n      6.2 - In the event Yahoo! determines that You have breached this Agreement, Yahoo! may terminate this Agreement.\n\n      6.3 - All licenses granted hereunder shall terminate upon the termination of this Agreement. Termination will be in addition to any rights and remedies available to Yahoo! at law or equity or under this Agreement.\n\n      6.4 - Termination of this Agreement will not affect the provisions regarding reservation of rights (Section 3.1), provisions disclaiming or limiting Yahoo!'s liability (Sections 4 and 5), Termination (Section 6) or Miscellaneous (Section 7), which provisions will survive termination of this Agreement.\n\n   7. Miscellaneous\n\n   This Agreement contains the entire agreement of the parties with respect to the subject matter of this Agreement and supersedes all previous communications, representations, understandings and agreements, either oral or written, between the parties with respect to said subject matter. The relationship of the parties hereunder is that of independent contractors, and this Agreement will not be construed as creating an agency, partnership, joint venture or any other form of legal association between the parties. If any term, condition, or provision in this Agreement is found to be invalid, unlawful or unenforceable to any extent, this Agreement will be construed in a manner that most closely effectuates the intent of this Agreement. Such invalid term, condition or provision will be severed from the remaining terms, conditions and provisions, which will continue to be valid and enforceable to the fullest extent permitted by law. This Agreement will be interpreted and construed in accordance with the laws of the State of California and the United States of America, without regard to conflict of law principles. The U.N. Convention on Contracts for the International Sale of Goods shall not apply to this Agreement. All disputes arising out of this Agreement involving Yahoo! or any of its subsidiaries shall be subject to the jurisdiction of the federal or state courts of northern California, with venue lying in Santa Clara County, California. No rights may be assigned, no obligations may be delegated, and this Agreement may not be transferred by You, in whole or in part, whether voluntary or by operation of law, including by way of sale of assets, merger or consolidation, without the prior written consent of Yahoo!, and any purported assignment, delegation or transfer without such consent shall be void ab initio. Any waiver of the provisions of this Agreement or of a party's rights or remedies under this Agreement must be in writing to be effective. Failure, neglect or delay by a party to enforce the provisions of this Agreement or its rights or remedies at any time, will not be construed or be deemed to be a waiver of such party's rights under this Agreement and will not in any way affect the validity of the whole or any part of this Agreement or prejudice such party's right to take subsequent action."],"licenseIds":["YPL-1.0"],"keywords":["1 0 ypl","0 ypl this","the event yahoo","event yahoo determines","yahoo determines that","determines that you","you have breached","have breached this","version 1 0 ypl","1 0 ypl this","0 ypl this yahoo","in the event yahoo","the event yahoo determines","event yahoo determines that","yahoo determines that you","determines that you have","that you have breached","you have breached this","have breached this agreement","breached this agreement yahoo","license version 1 0 ypl","version 1 0 ypl this","1 0 ypl this yahoo","0 ypl this yahoo public","2 in the event yahoo","in the event yahoo determines","the event yahoo determines that","event yahoo determines that you","yahoo determines that you have","determines that you have breached","that you have breached this","you have breached this agreement","have breached this agreement yahoo","breached this agreement yahoo may"]},{"licenseTexts":["Yahoo! Public License, Version 1.1 (YPL)\n\nThis Yahoo! Public License (this \"Agreement\") is a legal agreement that describes the terms under which Yahoo! Inc., a Delaware corporation having its principal place of business at 701 First Avenue, Sunnyvale, California 94089 (\"Yahoo!\") will provide software to you via download or otherwise (\"Software\"). By using the Software, you, an individual or an entity (\"You\") agree to the terms of this Agreement.\n\nIn consideration of the mutual promises and upon the terms and conditions set forth below, the parties agree as follows:\n\n   1. Grant of Copyright License\n\n      1.1 - Subject to the terms and conditions of this Agreement, Yahoo! hereby grants to You, under any and all of its copyright interest in and to the Software, a royalty-free, non-exclusive, non-transferable license to copy, modify, compile, execute, and distribute the Software and Modifications. For the purposes of this Agreement, any change to, addition to, or abridgement of the Software made by You is a \"Modification;\" however, any file You add to the Software that does not contain any part of the Software is not a \"Modification.\"\n\n      1.2 - If You are an individual acting on behalf of a corporation or other entity, Your use of the Software or any Modification is subject to Your having the authority to bind such corporation or entity to this Agreement. Providing copies to persons within such corporation or entity is not considered distribution for purposes of this Agreement.\n\n      1.3 - For the Software or any Modification You distribute in source code format, You must do so only under the terms of this Agreement, and You must include a complete copy of this Agreement with Your distribution. With respect to any Modification You distribute in source code format, the terms of this Agreement will apply to You in the same way those terms apply to Yahoo! with respect to the Software. In other words, when You are distributing Modifications under this Agreement, You \"stand in the shoes\" of Yahoo! in terms of the rights You grant and how the terms and conditions apply to You and the licensees of Your Modifications. Notwithstanding the foregoing, when You \"stand in the shoes\" of Yahoo!, You are not subject to the jurisdiction provision under Section 7, which requires all disputes under this Agreement to be subject to the jurisdiction of federal or state courts of northern California.\n\n      1.4 - For the Software or any Modification You distribute in compiled or object code format, You must also provide recipients with access to the Software or Modification in source code format along with a complete copy of this Agreement. The distribution of the Software or Modifications in compiled or object code format may be under a license of Your choice, provided that You are in compliance with the terms of this Agreement. In addition, You must make absolutely clear that any license terms applying to such Software or Modification that differ from this Agreement are offered by You alone and not by Yahoo!, and that such license does not restrict recipients from exercising rights in the source code to the Software granted by Yahoo! under this Agreement or rights in the source code to any Modification granted by You as described in Section 1.3.\n\n      1.5 - This Agreement does not limit Your right to distribute files that are entirely Your own work (i.e., which do not incorporate any portion of the Software and are not Modifications) under any terms You choose.\n\n   2. Support\n\n   Yahoo! has no obligation to provide technical support or updates to You. Nothing in this Agreement requires Yahoo! to enter into any license with You for any other edition of the Software.\n\n   3. Intellectual Property Rights\n\n      3.1 - Except for the license expressly granted under copyright in Section 1.1, no rights, licenses or forbearances are granted or may arise in relation to this Agreement whether expressly, by implication, exhaustion, estoppel or otherwise. All rights, including all intellectual property rights, that are not expressly granted under this Agreement are hereby reserved.\n\n      3.2 - In any copy of the Software or in any Modification you create, You must retain and reproduce, any and all copyright, patent, trademark, and attribution notices that are included in the Software in the same form as they appear in the Software. This includes the preservation of attribution notices in the form of trademarks or logos that exist within a user interface of the Software.\n\n      3.3 - This license does not grant You rights to use any party's name, logo, or trademarks, except solely as necessary to comply with Section 3.2.\n\n   4. Disclaimer of Warranties\n\n   THE SOFTWARE IS PROVIDED \"AS IS\" AND WITHOUT WARRANTY OF ANY KIND. YAHOO! MAKES NO WARRANTIES, WHETHER EXPRESS, IMPLIED, OR STATUTORY REGARDING OR RELATING TO THE SOFTWARE. SPECIFICALLY, YAHOO! DOES NOT WARRANT THAT THE SOFTWARE WILL BE ERROR FREE OR WILL PERFORM IN AN UNINTERRUPTED MANNER. TO THE GREATEST EXTENT ALLOWED BY LAW, YAHOO! SPECIFICALLY DISCLAIMS ALL IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE (EVEN IF YAHOO! HAD BEEN INFORMED OF SUCH PURPOSE), AND NONINFRINGEMENT WITH RESPECT TO THE SOFTWARE, ANY MODIFICATIONS THERETO AND WITH RESPECT TO THE USE OF THE FOREGOING.\n\n   5. Limitation of Liability\n\n   IN NO EVENT WILL YAHOO! BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES OF ANY KIND (INCLUDING WITHOUT LIMITATION LOSS OF PROFITS, LOSS OF USE, BUSINESS INTERRUPTION, LOSS OF DATA, COST OF COVER) IN CONNECTION WITH OR ARISING OUT OF OR RELATING TO THE FURNISHING, PERFORMANCE OR USE OF THE SOFTWARE OR ANY OTHER RIGHTS GRANTED HEREUNDER, WHETHER ALLEGED AS A BREACH OF CONTRACT OR TORTIOUS CONDUCT, INCLUDING NEGLIGENCE, AND EVEN IF YAHOO! HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\n   6. Term and Termination\n\n      6.1 - This Agreement will continue in effect unless and until terminated earlier pursuant to this Section 6.\n\n      6.2 - In the event You violate the terms of this Agreement, Yahoo! may terminate this Agreement.\n\n      6.3 - All licenses granted hereunder shall terminate upon the termination of this Agreement. Termination will be in addition to any rights and remedies available to Yahoo! at law or equity or under this Agreement.\n\n      6.4 - Termination of this Agreement will not affect the provisions regarding reservation of rights (Section 3.1), provisions disclaiming or limiting Yahoo!'s liability (Sections 4 and 5), Termination (Section 6) or Miscellaneous (Section 7), which provisions will survive termination of this Agreement.\n\n   7. Miscellaneous\n\n   This Agreement contains the entire agreement of the parties with respect to the subject matter of this Agreement and supersedes all previous communications, representations, understandings and agreements, either oral or written, between the parties with respect to said subject matter. The relationship of the parties hereunder is that of independent contractors, and this Agreement will not be construed as creating an agency, partnership, joint venture or any other form of legal association between the parties. If any term, condition, or provision in this Agreement is found to be invalid, unlawful or unenforceable to any extent, this Agreement will be construed in a manner that most closely effectuates the intent of this Agreement. Such invalid term, condition or provision will be severed from the remaining terms, conditions and provisions, which will continue to be valid and enforceable to the fullest extent permitted by law. This Agreement will be interpreted and construed in accordance with the laws of the State of California and the United States of America, without regard to conflict of law principles. The U.N. Convention on Contracts for the International Sale of Goods shall not apply to this Agreement. All disputes arising out of this Agreement involving Yahoo! or any of its subsidiaries shall be subject to the jurisdiction of the federal or state courts of northern California, with venue lying in Santa Clara County, California. No rights may be assigned, no obligations may be delegated, and this Agreement may not be transferred by You, in whole or in part, whether voluntary or by operation of law, including by way of sale of assets, merger or consolidation, without the prior written consent of Yahoo!, and any purported assignment, delegation or transfer without such consent shall be void ab initio. Any waiver of the provisions of this Agreement or of a party's rights or remedies under this Agreement must be in writing to be effective. Failure, neglect or delay by a party to enforce the provisions of this Agreement or its rights or remedies at any time, will not be construed or be deemed to be a waiver of such party's rights under this Agreement and will not in any way affect the validity of the whole or any part of this Agreement or prejudice such party's right to take subsequent action."],"licenseIds":["YPL-1.1"],"keywords":["1 1 ypl","1 ypl this","version 1 1 ypl","1 1 ypl this","1 ypl this yahoo","license version 1 1 ypl","version 1 1 ypl this","1 1 ypl this yahoo","1 ypl this yahoo public","terms of this agreement yahoo","of this agreement yahoo may"]},{"licenseTexts":["Zope Public License (ZPL) Version 1.1 Copyright (c) Zope Corporation. All rights reserved. This license has been certified as open source.\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   1. Redistributions in source code must retain the above copyright notice, this list of conditions, and the following disclaimer.\n\n   2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions, and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   3. All advertising materials and documentation mentioning features derived from or use of this software must display the following acknowledgement:\n\n   \"This product includes software developed by Zope Corporation for use in the Z Object Publishing Environment (http://www.zope.com/).\"\n\n   In the event that the product being advertised includes an intact Zope distribution (with copyright and license included) then this clause is waived.\n\n   4. Names associated with Zope or Zope Corporation must not be used to endorse or promote products derived from this software without prior written permission from Zope Corporation.\n\n   5. Modified redistributions of any form whatsoever must retain the following acknowledgment:\n\n   \"This product includes software developed by Zope Corporation for use in the Z Object Publishing Environment (http://www.zope.com/).\"\n\n   Intact (re-)distributions of any official Zope release do not require an external acknowledgement.\n\n   6. Modifications are encouraged but must be packaged separately as patches to official Zope releases. Distributions that do not clearly separate the patches from the original work must be clearly labeled as unofficial distributions. Modifications which do not carry the name Zope may be packaged in any form, as long as they conform to all of the clauses above.\n\nDisclaimer\n\nTHIS SOFTWARE IS PROVIDED BY ZOPE CORPORATION ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL ZOPE CORPORATION OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. This software consists of contributions made by Zope Corporation and many individuals on behalf of Zope Corporation. Specific attributions are listed in the accompanying credits file."],"licenseIds":["ZPL-1.1"],"keywords":["zpl version 1","zope corporation all","open source redistribution","source redistribution and","advertising materials and","and documentation mentioning","documentation mentioning features","mentioning features derived","features derived from","from or use","zope com in","com in the","that the product","the product being","product being advertised","being advertised includes","advertised includes an","includes an intact","an intact zope","intact zope distribution","zope distribution with","distribution with copyright","with copyright and","and license included","license included then","included then this","then this clause","this clause is","clause is waived","is waived 4","waived 4 names","4 names associated","names associated with","associated with zope","with zope or","zope or zope","or zope corporation","zope corporation must","corporation must not","zope corporation 5","corporation 5 modified","5 modified redistributions","zope com intact","com intact re","intact re distributions","re distributions of","distributions of any","of any official","any official zope","official zope release","zope release do","release do not","not require an","require an external","an external acknowledgement","external acknowledgement 6","acknowledgement 6 modifications","6 modifications are","modifications are encouraged","are encouraged but","encouraged but must","but must be","must be packaged","be packaged separately","packaged separately as","separately as patches","patches to official","to official zope","official zope releases","zope releases distributions","releases distributions that","distributions that do","do not clearly","not clearly separate","clearly separate the","separate the patches","the patches from","patches from the","labeled as unofficial","as unofficial distributions","unofficial distributions modifications","distributions modifications which","modifications which do","do not carry","not carry the","carry the name","name zope may","zope may be","may be packaged","be packaged in","packaged in any","any form as","form as long","as they conform","they conform to","conform to all","of the clauses","the clauses above","clauses above disclaimer","above disclaimer this","license zpl version 1","zpl version 1 1","1 copyright c zope","c zope corporation all","zope corporation all rights","as open source redistribution","open source redistribution and","source redistribution and use","all advertising materials and","advertising materials and documentation","materials and documentation mentioning","and documentation mentioning features","documentation mentioning features derived","mentioning features derived from","features derived from or","derived from or use","from or use of","www zope com in","zope com in the","com in the event","event that the product","that the product being","the product being advertised","product being advertised includes","being advertised includes an","advertised includes an intact","includes an intact zope","an intact zope distribution","intact zope distribution with","zope distribution with copyright","distribution with copyright and","with copyright and license","copyright and license included","and license included then","license included then this","included then this clause","then this clause is","this clause is waived","clause is waived 4","is waived 4 names","waived 4 names associated","4 names associated with","names associated with zope","associated with zope or","with zope or zope","zope or zope corporation","or zope corporation must","zope corporation must not","corporation must not be","from zope corporation 5","zope corporation 5 modified","corporation 5 modified redistributions","5 modified redistributions of","modified redistributions of any","www zope com intact","zope com intact re","com intact re distributions","intact re distributions of","re distributions of any","distributions of any official","of any official zope","any official zope release","official zope release do","zope release do not","release do not require","do not require an","not require an external","require an external acknowledgement","an external acknowledgement 6","external acknowledgement 6 modifications","acknowledgement 6 modifications are","6 modifications are encouraged","modifications are encouraged but","are encouraged but must","encouraged but must be","but must be packaged","must be packaged separately","be packaged separately as","packaged separately as patches","separately as patches to","as patches to official","patches to official zope","to official zope releases","official zope releases distributions","zope releases distributions that","releases distributions that do","distributions that do not","that do not clearly","do not clearly separate","not clearly separate the","clearly separate the patches","separate the patches from","the patches from the","patches from the original","from the original work","must be clearly labeled","be clearly labeled as","clearly labeled as unofficial","labeled as unofficial distributions","as unofficial distributions modifications"]},{"licenseTexts":["Zope Public License (ZPL) Version 2.0 This software is Copyright (c) Zope Corporation (tm) and Contributors. All rights reserved. This license has been certified as open source. It has also been designated as GPL compatible by the Free Software Foundation (FSF).\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   1. Redistributions in source code must retain the above copyright notice, this list of conditions, and the following disclaimer.\n\n   2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions, and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   3. The name Zope Corporation (tm) must not be used to endorse or promote products derived from this software without prior written permission from Zope Corporation.\n\n   4. The right to distribute this software or to use it for any purpose does not give you the right to use Servicemarks (sm) or Trademarks (tm) of Zope Corporation. Use of them is covered in a separate agreement (see http://www.zope.com/Marks).\n\n   5. If any files are modified, you must cause the modified files to carry prominent notices stating that you changed the files and the date of any change.\n\nDisclaimer\n\nTHIS SOFTWARE IS PROVIDED BY ZOPE CORPORATION ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL ZOPE CORPORATION OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. This software consists of contributions made by Zope Corporation and many individuals on behalf of Zope Corporation. Specific attributions are listed in the accompanying credits file."],"licenseIds":["ZPL-2.0"],"keywords":["0 this software","corporation tm and","name zope corporation","corporation tm must","zope corporation 4","corporation 4 the","tm of zope","zope corporation use","corporation use of","is covered in","covered in a","a separate agreement","separate agreement see","agreement see http","zope com marks","com marks 5","marks 5 if","zpl version 2 0","2 0 this software","0 this software is","is copyright c zope","c zope corporation tm","zope corporation tm and","corporation tm and contributors","3 the name zope","the name zope corporation","name zope corporation tm","zope corporation tm must","corporation tm must not","from zope corporation 4","zope corporation 4 the","corporation 4 the right","trademarks tm of zope","tm of zope corporation","of zope corporation use","zope corporation use of","corporation use of them","them is covered in","is covered in a","covered in a separate","in a separate agreement","a separate agreement see","separate agreement see http","agreement see http www","see http www zope","www zope com marks","zope com marks 5","com marks 5 if","marks 5 if any","license zpl version 2 0","zpl version 2 0 this","version 2 0 this software","2 0 this software is","0 this software is copyright","software is copyright c zope","is copyright c zope corporation","copyright c zope corporation tm","c zope corporation tm and","zope corporation tm and contributors","corporation tm and contributors all","contributors all rights reserved this","distribution 3 the name zope","3 the name zope corporation","the name zope corporation tm","name zope corporation tm must","zope corporation tm must not","corporation tm must not be","permission from zope corporation 4","from zope corporation 4 the","zope corporation 4 the right","corporation 4 the right to","or trademarks tm of zope","trademarks tm of zope corporation","tm of zope corporation use","of zope corporation use of","zope corporation use of them","corporation use of them is","of them is covered in","them is covered in a","is covered in a separate","covered in a separate agreement","in a separate agreement see","a separate agreement see http","separate agreement see http www","agreement see http www zope","see http www zope com","http www zope com marks","www zope com marks 5","zope com marks 5 if","com marks 5 if any","marks 5 if any files"]},{"licenseTexts":["Zope Public License (ZPL) Version 2.1 A copyright notice accompanies this license document that identifies the copyright holders.\n\nThis license has been certified as open source. It has also been designated as GPL compatible by the Free Software Foundation (FSF).\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   1. Redistributions in source code must retain the accompanying copyright notice, this list of conditions, and the following disclaimer.\n\n   2. Redistributions in binary form must reproduce the accompanying copyright notice, this list of conditions, and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   3. Names of the copyright holders must not be used to endorse or promote products derived from this software without prior written permission from the copyright holders.\n\n   4. The right to distribute this software or to use it for any purpose does not give you the right to use Servicemarks (sm) or Trademarks (tm) of the copyright holders. Use of them is covered by separate agreement with the copyright holders.\n\n   5. If any files are modified, you must cause the modified files to carry prominent notices stating that you changed the files and the date of any change.\n\nDisclaimer\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."],"licenseIds":["ZPL-2.1"],"keywords":["1 a copyright","copyright notice accompanies","notice accompanies this","accompanies this license","license document that","document that identifies","that identifies the","identifies the copyright","holders this license","retain the accompanying","reproduce the accompanying","distribution 3 names","3 names of","copyright holders 4","holders 4 the","tm of the","copyright holders use","holders use of","covered by separate","by separate agreement","separate agreement with","copyright holders 5","holders 5 if","zpl version 2 1","version 2 1 a","2 1 a copyright","1 a copyright notice","a copyright notice accompanies","copyright notice accompanies this","notice accompanies this license","accompanies this license document","this license document that","license document that identifies","document that identifies the","that identifies the copyright","identifies the copyright holders","the copyright holders this","copyright holders this license","holders this license has","must retain the accompanying","retain the accompanying copyright","must reproduce the accompanying","reproduce the accompanying copyright","the distribution 3 names","distribution 3 names of","3 names of the","names of the copyright","the copyright holders must","permission from the copyright","from the copyright holders","the copyright holders 4","copyright holders 4 the","holders 4 the right","trademarks tm of the","tm of the copyright","the copyright holders use","copyright holders use of","holders use of them","them is covered by","is covered by separate","covered by separate agreement","by separate agreement with","separate agreement with the","agreement with the copyright","the copyright holders 5","copyright holders 5 if","holders 5 if any","holders as is and","license zpl version 2 1","zpl version 2 1 a","version 2 1 a copyright","2 1 a copyright notice","1 a copyright notice accompanies","a copyright notice accompanies this","copyright notice accompanies this license","notice accompanies this license document","accompanies this license document that","this license document that identifies","license document that identifies the","document that identifies the copyright","that identifies the copyright holders","identifies the copyright holders this","the copyright holders this license","copyright holders this license has","holders this license has been","code must retain the accompanying","must retain the accompanying copyright","retain the accompanying copyright notice","form must reproduce the accompanying","must reproduce the accompanying copyright","reproduce the accompanying copyright notice","with the distribution 3 names","the distribution 3 names of","distribution 3 names of the","3 names of the copyright","names of the copyright holders","of the copyright holders must","the copyright holders must not","written permission from the copyright","permission from the copyright holders","from the copyright holders 4","the copyright holders 4 the","copyright holders 4 the right","holders 4 the right to","or trademarks tm of the","trademarks tm of the copyright","tm of the copyright holders","of the copyright holders use","the copyright holders use of","copyright holders use of them","holders use of them is","of them is covered by","them is covered by separate","is covered by separate agreement","covered by separate agreement with","by separate agreement with the","separate agreement with the copyright","agreement with the copyright holders","with the copyright holders 5","the copyright holders 5 if","copyright holders 5 if any","holders 5 if any files","copyright holders as is and","holders as is and any"]},{"licenseTexts":["(c) Jim Davies, January 1995\n\nYou may copy and distribute this file freely. Any queries and complaints should be forwarded to Jim.Davies@comlab.ox.ac.uk.\n\nIf you make any changes to this file, please do not distribute the results under the name `zed-csp.sty'."],"licenseIds":["Zed"],"keywords":["c jim davies","jim davies january","davies january 1995","january 1995 you","1995 you may","distribute this file","this file freely","file freely any","freely any queries","any queries and","queries and complaints","and complaints should","complaints should be","should be forwarded","be forwarded to","forwarded to jim","to jim davies","jim davies comlab","davies comlab ox","comlab ox ac","ox ac uk","ac uk if","uk if you","changes to this","this file please","file please do","distribute the results","the results under","results under the","under the name","the name zed","name zed csp","zed csp sty","c jim davies january","jim davies january 1995","davies january 1995 you","january 1995 you may","1995 you may copy","and distribute this file","distribute this file freely","this file freely any","file freely any queries","freely any queries and","any queries and complaints","queries and complaints should","and complaints should be","complaints should be forwarded","should be forwarded to","be forwarded to jim","forwarded to jim davies","to jim davies comlab","jim davies comlab ox","davies comlab ox ac","comlab ox ac uk","ox ac uk if","ac uk if you","uk if you make","any changes to this","changes to this file","to this file please","this file please do","file please do not","please do not distribute","not distribute the results","distribute the results under","the results under the","results under the name","under the name zed","the name zed csp","name zed csp sty","c jim davies january 1995","jim davies january 1995 you","davies january 1995 you may","january 1995 you may copy","1995 you may copy and","may copy and distribute this","copy and distribute this file","and distribute this file freely","distribute this file freely any","this file freely any queries","file freely any queries and","freely any queries and complaints","any queries and complaints should","queries and complaints should be","and complaints should be forwarded","complaints should be forwarded to","should be forwarded to jim","be forwarded to jim davies","forwarded to jim davies comlab","to jim davies comlab ox","jim davies comlab ox ac","davies comlab ox ac uk","comlab ox ac uk if","ox ac uk if you","ac uk if you make","uk if you make any","if you make any changes","make any changes to this","any changes to this file","changes to this file please","to this file please do","this file please do not","file please do not distribute","please do not distribute the","do not distribute the results","not distribute the results under","distribute the results under the","the results under the name","results under the name zed","under the name zed csp","the name zed csp sty"]},{"licenseTexts":["The Zend Engine License, version 2.00 Copyright (c) 1999-2002 Zend Technologies Ltd. All rights reserved.\n\n\n\nRedistribution and use in source and binary forms, with or without modification, is permitted provided that the following conditions are met:\n\n   1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n   2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n   3. The names \"Zend\" and \"Zend Engine\" must not be used to endorse or promote products derived from this software without prior permission from Zend Technologies Ltd. For written permission, please contact license@zend.com.\n\n   4. Zend Technologies Ltd. may publish revised and/or new versions of the license from time to time. Each version will be given a distinguishing version number. Once covered code has been published under a particular version of the license, you may always continue to use it under the terms of that version. You may also choose to use such covered code under the terms of any subsequent version of the license published by Zend Technologies Ltd. No one other than Zend Technologies Ltd. has the right to modify the terms applicable to covered code created under this License.\n\n   5. Redistributions of any form whatsoever must retain the following acknowledgment: \"This product includes the Zend Engine, freely available at http://www.zend.com\"\n\n   6. All advertising materials mentioning features or use of this software must display the following acknowledgment: \"The Zend Engine is freely available at http://www.zend.com\"\n\nTHIS SOFTWARE IS PROVIDED BY ZEND TECHNOLOGIES LTD. ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL ZEND TECHNOLOGIES LTD. BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."],"licenseIds":["Zend-2.0"],"keywords":["zend engine license","engine license version","version 2 00","2 00 copyright","00 copyright c","1999 2002 zend","2002 zend technologies","technologies ltd all","the names zend","names zend and","zend and zend","and zend engine","zend engine must","engine must not","without prior permission","prior permission from","permission from zend","from zend technologies","technologies ltd for","ltd for written","contact license zend","license zend com","zend com 4","com 4 zend","4 zend technologies","technologies ltd may","ltd may publish","published by zend","technologies ltd no","ltd no one","other than zend","than zend technologies","technologies ltd has","ltd has the","license 5 redistributions","5 redistributions of","zend com 6","com 6 all","6 all advertising","following acknowledgment the","acknowledgment the zend","zend engine is","engine is freely","zend com this","provided by zend","technologies ltd as","ltd as is","event shall zend","shall zend technologies","technologies ltd be","ltd be liable","the zend engine license","zend engine license version","engine license version 2","license version 2 00","version 2 00 copyright","2 00 copyright c","00 copyright c 1999","c 1999 2002 zend","1999 2002 zend technologies","2002 zend technologies ltd","zend technologies ltd all","technologies ltd all rights","3 the names zend","the names zend and","names zend and zend","zend and zend engine","and zend engine must","zend engine must not","engine must not be","software without prior permission","without prior permission from","prior permission from zend","permission from zend technologies","from zend technologies ltd","zend technologies ltd for","technologies ltd for written","ltd for written permission","please contact license zend","contact license zend com","license zend com 4","zend com 4 zend","com 4 zend technologies","4 zend technologies ltd","zend technologies ltd may","technologies ltd may publish","ltd may publish revised","license published by zend","published by zend technologies","zend technologies ltd no","technologies ltd no one","ltd no one other","one other than zend","other than zend technologies","than zend technologies ltd","zend technologies ltd has","technologies ltd has the","ltd has the right","this license 5 redistributions","license 5 redistributions of","5 redistributions of any","www zend com 6","zend com 6 all","com 6 all advertising","6 all advertising materials","the following acknowledgment the","following acknowledgment the zend","acknowledgment the zend engine","the zend engine is","zend engine is freely","engine is freely available","is freely available at","www zend com this","zend com this software","is provided by zend","provided by zend technologies","zend technologies ltd as","technologies ltd as is","ltd as is and","no event shall zend","event shall zend technologies","shall zend technologies ltd","zend technologies ltd be","technologies ltd be liable","ltd be liable for","the zend engine license version","zend engine license version 2","engine license version 2 00","license version 2 00 copyright","version 2 00 copyright c","2 00 copyright c 1999","00 copyright c 1999 2002","copyright c 1999 2002 zend","c 1999 2002 zend technologies","1999 2002 zend technologies ltd","2002 zend technologies ltd all","zend technologies ltd all rights","technologies ltd all rights reserved","distribution 3 the names zend","3 the names zend and","the names zend and zend","names zend and zend engine","zend and zend engine must","and zend engine must not","zend engine must not be","engine must not be used","this software without prior permission","software without prior permission from","without prior permission from zend","prior permission from zend technologies","permission from zend technologies ltd","from zend technologies ltd for","zend technologies ltd for written","technologies ltd for written permission","ltd for written permission please","permission please contact license zend","please contact license zend com","contact license zend com 4","license zend com 4 zend","zend com 4 zend technologies","com 4 zend technologies ltd","4 zend technologies ltd may","zend technologies ltd may publish","technologies ltd may publish revised","ltd may publish revised and","the license published by zend","license published by zend technologies","published by zend technologies ltd","by zend technologies ltd no","zend technologies ltd no one","technologies ltd no one other","ltd no one other than","no one other than zend","one other than zend technologies","other than zend technologies ltd","than zend technologies ltd has","zend technologies ltd has the","technologies ltd has the right","ltd has the right to","created under this license 5","under this license 5 redistributions","this license 5 redistributions of","license 5 redistributions of any","5 redistributions of any form","acknowledgment this product includes the","http www zend com 6","www zend com 6 all","zend com 6 all advertising","com 6 all advertising materials","6 all advertising materials mentioning","display the following acknowledgment the","the following acknowledgment the zend","following acknowledgment the zend engine","acknowledgment the zend engine is","the zend engine is freely","zend engine is freely available","engine is freely available at","is freely available at http","http www zend com this","www zend com this software"]},{"licenseTexts":["Zimbra Public License, Version 1.3 (ZPL)\n\nThis Zimbra Public License (this \"Agreement\") is a legal agreement that describes the terms under which VMware, Inc., a Delaware corporation having its principal place of business at 3401 Hillview Avenue, Palo Alto, California 94304 (\"VMware\") will provide software to you via download or otherwise (\"Software\"). By using the Software, you, an individual or an entity (\"You\") agree to the terms of this Agreement.\n\nIn consideration of the mutual promises and upon the terms and conditions set forth below, the parties agree as follows:\n\n   1. Grant of Copyright License\n\n      1.1 - Subject to the terms and conditions of this Agreement, VMware hereby grants to You, under any and all of its copyright interest in and to the Software, a royalty-free, non-exclusive, non-transferable license to copy, modify, compile, execute, and distribute the Software and Modifications. For the purposes of this Agreement, any change to, addition to, or abridgement of the Software made by You is a \"Modification;\" however, any file You add to the Software that does not contain any part of the Software is not a \"Modification.\"\n\n      1.2 - If You are an individual acting on behalf of a corporation or other entity, Your use of the Software or any Modification is subject to Your having the authority to bind such corporation or entity to this Agreement. Providing copies to persons within such corporation or entity is not considered distribution for purposes of this Agreement.\n\n      1.3 - For the Software or any Modification You distribute in source code format, You must do so only under the terms of this Agreement, and You must include a complete copy of this Agreement with Your distribution. With respect to any Modification You distribute in source code format, the terms of this Agreement will apply to You in the same way those terms apply to VMware with respect to the Software. In other words, when You are distributing Modifications under this Agreement, You \"stand in the shoes\" of VMware in terms of the rights You grant and how the terms and conditions apply to You and the licensees of Your Modifications. Notwithstanding the foregoing, when You \"stand in the shoes\" of VMware, You are not subject to the jurisdiction provision under Section 7, which requires all disputes under this Agreement to be subject to the jurisdiction of federal or state courts of northern California.\n\n      1.4 - For the Software or any Modification You distribute in compiled or object code format, You must also provide recipients with access to the Software or Modification in source code format along with a complete copy of this Agreement. The distribution of the Software or Modifications in compiled or object code format may be under a license of Your choice, provided that You are in compliance with the terms of this Agreement. In addition, You must make absolutely clear that any license terms applying to such Software or Modification that differ from this Agreement are offered by You alone and not by VMware, and that such license does not restrict recipients from exercising rights in the source code to the Software granted by VMware under this Agreement or rights in the source code to any Modification granted by You as described in Section 1.3.\n\n      1.5 - This Agreement does not limit Your right to distribute files that are entirely Your own work (i.e., which do not incorporate any portion of the Software and are not Modifications) under any terms You choose.\n\n   2. Support\n\n   VMware has no obligation to provide technical support or updates to You. Nothing in this Agreement requires VMware to enter into any license with You for any other edition of the Software.\n\n   3. Intellectual Property Rights\n\n      3.1 - Except for the license expressly granted under copyright in Section 1.1, no rights, licenses or forbearances are granted or may arise in relation to this Agreement whether expressly, by implication, exhaustion, estoppel or otherwise. All rights, including all intellectual property rights, that are not expressly granted under this Agreement are hereby reserved.\n\n      3.2 - In any copy of the Software or in any Modification you create, You must retain and reproduce, any and all copyright, patent, trademark, and attribution notices that are included in the Software in the same form as they appear in the Software. This includes the preservation of attribution notices in the form of trademarks or logos that exist within a user interface of the Software.\n\n      3.3 - This license does not grant You rights to use any party's name, logo, or trademarks, except solely as necessary to comply with Section 3.2.\n\n   4. Disclaimer of Warranties\n\n   THE SOFTWARE IS PROVIDED \"AS IS\" AND WITHOUT WARRANTY OF ANY KIND. VMWARE MAKES NO WARRANTIES, WHETHER EXPRESS, IMPLIED, OR STATUTORY REGARDING OR RELATING TO THE SOFTWARE. SPECIFICALLY, VMWARE DOES NOT WARRANT THAT THE SOFTWARE WILL BE ERROR FREE OR WILL PERFORM IN AN UNINTERRUPTED MANNER. TO THE GREATEST EXTENT ALLOWED BY LAW, VMWARE SPECIFICALLY DISCLAIMS ALL IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE (EVEN IF VMWARE HAD BEEN INFORMED OF SUCH PURPOSE), AND NONINFRINGEMENT WITH RESPECT TO THE SOFTWARE, ANY MODIFICATIONS THERETO AND WITH RESPECT TO THE USE OF THE FOREGOING.\n\n   5. Limitation of Liability\n\n   IN NO EVENT WILL VMWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES OF ANY KIND (INCLUDING WITHOUT LIMITATION LOSS OF PROFITS, LOSS OF USE, BUSINESS INTERRUPTION, LOSS OF DATA, COST OF COVER) IN CONNECTION WITH OR ARISING OUT OF OR RELATING TO THE FURNISHING, PERFORMANCE OR USE OF THE SOFTWARE OR ANY OTHER RIGHTS GRANTED HEREUNDER, WHETHER ALLEGED AS A BREACH OF CONTRACT OR TORTIOUS CONDUCT, INCLUDING NEGLIGENCE, AND EVEN IF VMWARE HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\n   6. Term and Termination\n\n      6.1 - This Agreement will continue in effect unless and until terminated earlier pursuant to this Section 6.\n\n      6.2 - In the event You violate the terms of this Agreement, VMware may terminate this Agreement.\n\n      6.3 - All licenses granted hereunder shall terminate upon the termination of this Agreement. Termination will be in addition to any rights and remedies available to VMware at law or equity or under this Agreement.\n\n      6.4 - Termination of this Agreement will not affect the provisions regarding reservation of rights (Section 3.1), provisions disclaiming or limiting VMware's liability (Sections 4 and 5), Termination (Section 6) or Miscellaneous (Section 7), which provisions will survive termination of this Agreement.\n\n   7. Miscellaneous\n\n   This Agreement contains the entire agreement of the parties with respect to the subject matter of this Agreement and supersedes all previous communications, representations, understandings and agreements, either oral or written, between the parties with respect to said subject matter. The relationship of the parties hereunder is that of independent contractors, and this Agreement will not be construed as creating an agency, partnership, joint venture or any other form of legal association between the parties. If any term, condition, or provision in this Agreement is found to be invalid, unlawful or unenforceable to any extent, this Agreement will be construed in a manner that most closely effectuates the intent of this Agreement. Such invalid term, condition or provision will be severed from the remaining terms, conditions and provisions, which will continue to be valid and enforceable to the fullest extent permitted by law. This Agreement will be interpreted and construed in accordance with the laws of the State of California and the United States of America, without regard to conflict of law principles. The U.N. Convention on Contracts for the International Sale of Goods shall not apply to this Agreement. All disputes arising out of this Agreement involving VMware or any of its subsidiaries shall be subject to the jurisdiction of the federal or state courts of northern California, with venue lying in Santa Clara County, California. No rights may be assigned, no obligations may be delegated, and this Agreement may not be transferred by You, in whole or in part, whether voluntary or by operation of law, including by way of sale of assets, merger or consolidation, without the prior written consent of VMware, and any purported assignment, delegation or transfer without such consent shall be void ab initio. Any waiver of the provisions of this Agreement or of a party's rights or remedies under this Agreement must be in writing to be effective. Failure, neglect or delay by a party to enforce the provisions of this Agreement or its rights or remedies at any time, will not be construed or be deemed to be a waiver of such party's rights under this Agreement and will not in any way affect the validity of the whole or any part of this Agreement or prejudice such party's right to take subsequent action."],"licenseIds":["Zimbra-1.3"],"keywords":["1 3 zpl","3 zpl this","under which vmware","which vmware inc","vmware inc a","business at 3401","at 3401 hillview","3401 hillview avenue","hillview avenue palo","avenue palo alto","alto california 94304","california 94304 vmware","94304 vmware will","vmware will provide","agreement vmware hereby","vmware hereby grants","apply to vmware","to vmware with","vmware with respect","of vmware in","vmware in terms","of vmware you","vmware you are","not by vmware","by vmware and","vmware and that","granted by vmware","by vmware under","vmware under this","2 support vmware","support vmware has","vmware has no","agreement requires vmware","requires vmware to","vmware to enter","any kind vmware","kind vmware makes","vmware makes no","software specifically vmware","specifically vmware does","vmware does not","by law vmware","law vmware specifically","vmware specifically disclaims","if vmware had","vmware had been","event will vmware","will vmware be","vmware be liable","if vmware has","vmware has been","agreement vmware may","vmware may terminate","available to vmware","to vmware at","vmware at law","or limiting vmware","limiting vmware s","vmware s liability","agreement involving vmware","involving vmware or","vmware or any","consent of vmware","of vmware and","vmware and any","version 1 3 zpl","1 3 zpl this","3 zpl this zimbra","terms under which vmware","under which vmware inc","which vmware inc a","vmware inc a delaware","of business at 3401","business at 3401 hillview","at 3401 hillview avenue","3401 hillview avenue palo","hillview avenue palo alto","avenue palo alto california","palo alto california 94304","alto california 94304 vmware","california 94304 vmware will","94304 vmware will provide","vmware will provide software","this agreement vmware hereby","agreement vmware hereby grants","vmware hereby grants to","terms apply to vmware","apply to vmware with","to vmware with respect","vmware with respect to","shoes of vmware in","of vmware in terms","vmware in terms of","shoes of vmware you","of vmware you are","vmware you are not","and not by vmware","not by vmware and","by vmware and that","vmware and that such","software granted by vmware","granted by vmware under","by vmware under this","vmware under this agreement","choose 2 support vmware","2 support vmware has","support vmware has no","vmware has no obligation","this agreement requires vmware","agreement requires vmware to","requires vmware to enter","vmware to enter into","of any kind vmware","any kind vmware makes","kind vmware makes no","vmware makes no warranties","the software specifically vmware","software specifically vmware does","specifically vmware does not","vmware does not warrant","allowed by law vmware","by law vmware specifically","law vmware specifically disclaims","vmware specifically disclaims all","purpose even if vmware","even if vmware had","if vmware had been","vmware had been informed","no event will vmware","event will vmware be","will vmware be liable","vmware be liable for","and even if vmware","even if vmware has","if vmware has been","vmware has been advised","this agreement vmware may","agreement vmware may terminate","vmware may terminate this","remedies available to vmware","available to vmware at","to vmware at law","vmware at law or","disclaiming or limiting vmware","or limiting vmware s","limiting vmware s liability","vmware s liability sections","this agreement involving vmware","agreement involving vmware or","involving vmware or any","vmware or any of","written consent of vmware","consent of vmware and","of vmware and any","vmware and any purported","license version 1 3 zpl","version 1 3 zpl this","1 3 zpl this zimbra","3 zpl this zimbra public","the terms under which vmware","terms under which vmware inc","under which vmware inc a","which vmware inc a delaware","vmware inc a delaware corporation","place of business at 3401","of business at 3401 hillview","business at 3401 hillview avenue","at 3401 hillview avenue palo","3401 hillview avenue palo alto","hillview avenue palo alto california","avenue palo alto california 94304","palo alto california 94304 vmware","alto california 94304 vmware will","california 94304 vmware will provide","94304 vmware will provide software","vmware will provide software to","conditions of this agreement vmware","of this agreement vmware hereby","this agreement vmware hereby grants","agreement vmware hereby grants to","vmware hereby grants to you","those terms apply to vmware","terms apply to vmware with","apply to vmware with respect","to vmware with respect to","vmware with respect to the","the shoes of vmware in","shoes of vmware in terms","of vmware in terms of","vmware in terms of the","the shoes of vmware you","shoes of vmware you are","of vmware you are not","vmware you are not subject","alone and not by vmware","and not by vmware and","not by vmware and that","by vmware and that such","vmware and that such license","the software granted by vmware"]},{"licenseTexts":["Zimbra Public License, Version 1.4 (ZPL)\n\nThis Zimbra Public License (this \"Agreement\") is a legal agreement that describes the terms under which Zimbra, Inc., a Texas corporation (\"Zimbra\") will provide software to you via download or otherwise (\"Software\"). By using the Software, you, an individual or an entity (\"You\") agree to the terms of this Agreement.\n\nIn consideration of the mutual promises and upon the terms and conditions set forth below, the parties agree as follows:\n\n   1. Grant of Copyright License\n\n      1.1 - Subject to the terms and conditions of this Agreement, Zimbra hereby grants to You, under any and all of its copyright interest in and to the Software, a royalty-free, non-exclusive, non-transferable license to copy, modify, compile, execute, and distribute the Software and Modifications. For the purposes of this Agreement, any change to, addition to, or abridgement of the Software made by You is a \"Modification;\" however, any file You add to the Software that does not contain any part of the Software is not a \"Modification.\"\n\n      1.2 - If You are an individual acting on behalf of a corporation or other entity, Your use of the Software or any Modification is subject to Your having the authority to bind such corporation or entity to this Agreement. Providing copies to persons within such corporation or entity is not considered distribution for purposes of this Agreement.\n\n      1.3 - For the Software or any Modification You distribute in source code format, You must do so only under the terms of this Agreement, and You must include a complete copy of this Agreement with Your distribution. With respect to any Modification You distribute in source code format, the terms of this Agreement will apply to You in the same way those terms apply to Zimbra with respect to the Software. In other words, when You are distributing Modifications under this Agreement, You \"stand in the shoes\" of Zimbra in terms of the rights You grant and how the terms and conditions apply to You and the licensees of Your Modifications. Notwithstanding the foregoing, when You \"stand in the shoes\" of Zimbra, You are not subject to the jurisdiction provision under Section 7, which requires all disputes under this Agreement to be subject to the jurisdiction of federal or state courts of Northern Texas.\n\n      1.4 - For the Software or any Modification You distribute in compiled or object code format, You must also provide recipients with access to the Software or Modification in source code format along with a complete copy of this Agreement. The distribution of the Software or Modifications in compiled or object code format may be under a license of Your choice, provided that You are in compliance with the terms of this Agreement. In addition, You must make absolutely clear that any license terms applying to such Software or Modification that differ from this Agreement are offered by You alone and not by Zimbra, and that such license does not restrict recipients from exercising rights in the source code to the Software granted by Zimbra under this Agreement or rights in the source code to any Modification granted by You as described in Section 1.3.\n\n      1.5 - This Agreement does not limit Your right to distribute files that are entirely Your own work (i.e., which do not incorporate any portion of the Software and are not Modifications) under any terms You choose.\n\n   2. Support\n\n   Zimbra has no obligation to provide technical support or updates to You. Nothing in this Agreement requires Zimbra to enter into any license with You for any other edition of the Software.\n\n   3. Intellectual Property Rights\n\n      3.1 - Except for the license expressly granted under copyright in Section 1.1, no rights, licenses or forbearances are granted or may arise in relation to this Agreement whether expressly, by implication, exhaustion, estoppel or otherwise. All rights, including all intellectual property rights, that are not expressly granted under this Agreement are hereby reserved.\n\n      3.2 - In any copy of the Software or in any Modification you create, You must retain and reproduce any and all copyright, patent, trademark, and attribution notices that are included in the Software in the same form as they appear in the Software. This includes the preservation of attribution notices in the form of trademarks or logos that exist within a user interface of the Software.\n\n      3.3 - This license does not grant You rights to use any party's name, logo, or trademarks, except solely as necessary to comply with Section 3.2.\n\n   4. Disclaimer of Warranties\n\n   THE SOFTWARE IS PROVIDED \"AS IS\" AND WITHOUT WARRANTY OF ANY KIND. ZIMBRA MAKES NO WARRANTIES, WHETHER EXPRESS, IMPLIED, OR STATUTORY, REGARDING OR RELATING TO THE SOFTWARE. SPECIFICALLY, ZIMBRA DOES NOT WARRANT THAT THE SOFTWARE WILL BE ERROR FREE OR WILL PERFORM IN AN UNINTERRUPTED MANNER. TO THE GREATEST EXTENT ALLOWED BY LAW, ZIMBRA SPECIFICALLY DISCLAIMS ALL IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE (EVEN IF ZIMBRA HAD BEEN INFORMED OF SUCH PURPOSE), AND NONINFRINGEMENT WITH RESPECT TO THE SOFTWARE, ANY MODIFICATIONS THERETO, AND WITH RESPECT TO THE USE OF THE FOREGOING.\n\n   5. Limitation of Liability\n\n   IN NO EVENT WILL ZIMBRA BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES OF ANY KIND (INCLUDING WITHOUT LIMITATION LOSS OF PROFITS, LOSS OF USE, BUSINESS INTERRUPTION, LOSS OF DATA, AND COST OF COVER) IN CONNECTION WITH OR ARISING OUT OF OR RELATING TO THE FURNISHING, PERFORMANCE, OR USE OF THE SOFTWARE OR ANY OTHER RIGHTS GRANTED HEREUNDER, WHETHER ALLEGED AS A BREACH OF CONTRACT OR TORTIOUS CONDUCT, INCLUDING NEGLIGENCE, AND EVEN IF ZIMBRA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n\n   6. Term and Termination\n\n      6.1 - This Agreement will continue in effect unless and until terminated earlier pursuant to this Section 6.\n\n      6.2 - In the event You violate the terms of this Agreement, Zimbra may terminate this Agreement.\n\n      6.3 - All licenses granted hereunder shall terminate upon the termination of this Agreement. Termination will be in addition to any rights and remedies available to Zimbra at law or equity or under this Agreement.\n\n      6.4 - Termination of this Agreement will not affect the provisions regarding reservation of rights (Section 3.1), provisions disclaiming or limiting Zimbra's liability (Sections 4 and 5), Termination (Section 6), or Miscellaneous (Section 7), which provisions will survive termination of this Agreement.\n\n   7. Miscellaneous\n\n   This Agreement contains the entire agreement of the parties with respect to the subject matter of this Agreement and supersedes all previous communications, representations, understandings, and agreements, either oral or written, between the parties with respect to said subject matter. The relationship of the parties hereunder is that of independent contractors, and this Agreement will not be construed as creating an agency, partnership, joint venture, or any other form of legal association between the parties. If any term, condition, or provision in this Agreement is found to be invalid, unlawful, or unenforceable to any extent, this Agreement will be construed in a manner that most closely effectuates the intent of this Agreement. Such invalid term, condition or provision will be severed from the remaining terms, conditions, and provisions, which will continue to be valid and enforceable to the fullest extent permitted by law. This Agreement will be interpreted and construed in accordance with the laws of the State of Delaware and the United States of America, without regard to conflict of law principles. The U.N. Convention on Contracts for the International Sale of Goods shall not apply to this Agreement. All disputes arising out of this Agreement involving Zimbra or any of its parents or subsidiaries shall be subject to the jurisdiction of the federal or state courts of Northern Texas, with venue lying in Dallas County, Texas. No rights may be assigned, no obligations may be delegated, and this Agreement may not be transferred by You, in whole or in part, whether voluntary or by operation of law, including by way of sale of assets, merger, or consolidation, without the prior written consent of Zimbra, and any purported assignment, delegation, or transfer without such consent shall be void ab initio. Any waiver of the provisions of this Agreement or of a party's rights or remedies under this Agreement must be in writing to be effective. Failure, neglect, or delay by a party to enforce the provisions of this Agreement or its rights or remedies at any time will not be construed or be deemed to be a waiver of such party's rights under this Agreement and will not in any way affect the validity of the whole or any part of this Agreement or prejudice such party's right to take subsequent action."],"licenseIds":["Zimbra-1.4"],"keywords":["1 4 zpl","4 zpl this","under which zimbra","which zimbra inc","zimbra inc a","inc a texas","a texas corporation","texas corporation zimbra","corporation zimbra will","zimbra will provide","agreement zimbra hereby","zimbra hereby grants","apply to zimbra","to zimbra with","zimbra with respect","of zimbra in","zimbra in terms","of zimbra you","zimbra you are","northern texas 1","texas 1 4","not by zimbra","by zimbra and","zimbra and that","granted by zimbra","by zimbra under","zimbra under this","2 support zimbra","support zimbra has","zimbra has no","agreement requires zimbra","requires zimbra to","zimbra to enter","any kind zimbra","kind zimbra makes","zimbra makes no","software specifically zimbra","specifically zimbra does","zimbra does not","by law zimbra","law zimbra specifically","zimbra specifically disclaims","if zimbra had","zimbra had been","event will zimbra","will zimbra be","zimbra be liable","data and cost","and cost of","if zimbra has","zimbra has been","agreement zimbra may","zimbra may terminate","available to zimbra","to zimbra at","zimbra at law","or limiting zimbra","limiting zimbra s","zimbra s liability","state of delaware","of delaware and","delaware and the","agreement involving zimbra","involving zimbra or","zimbra or any","of its parents","its parents or","parents or subsidiaries","or subsidiaries shall","northern texas with","texas with venue","lying in dallas","in dallas county","dallas county texas","county texas no","texas no rights","consent of zimbra","of zimbra and","zimbra and any","version 1 4 zpl","1 4 zpl this","4 zpl this zimbra","terms under which zimbra","under which zimbra inc","which zimbra inc a","zimbra inc a texas","inc a texas corporation","a texas corporation zimbra","texas corporation zimbra will","corporation zimbra will provide","zimbra will provide software","this agreement zimbra hereby","agreement zimbra hereby grants","zimbra hereby grants to","terms apply to zimbra","apply to zimbra with","to zimbra with respect","zimbra with respect to","shoes of zimbra in","of zimbra in terms","zimbra in terms of","shoes of zimbra you","of zimbra you are","zimbra you are not","of northern texas 1","northern texas 1 4","texas 1 4 for","and not by zimbra","not by zimbra and","by zimbra and that","zimbra and that such","software granted by zimbra","granted by zimbra under","by zimbra under this","zimbra under this agreement","choose 2 support zimbra","2 support zimbra has","support zimbra has no","zimbra has no obligation","this agreement requires zimbra","agreement requires zimbra to","requires zimbra to enter","zimbra to enter into","of any kind zimbra","any kind zimbra makes","kind zimbra makes no","zimbra makes no warranties","the software specifically zimbra","software specifically zimbra does","specifically zimbra does not","zimbra does not warrant","allowed by law zimbra","by law zimbra specifically","law zimbra specifically disclaims","zimbra specifically disclaims all","purpose even if zimbra","even if zimbra had","if zimbra had been","zimbra had been informed","no event will zimbra","event will zimbra be","will zimbra be liable","zimbra be liable for","of data and cost","data and cost of","and cost of cover","and even if zimbra","even if zimbra has","if zimbra has been","zimbra has been advised","this agreement zimbra may","agreement zimbra may terminate","zimbra may terminate this","remedies available to zimbra","available to zimbra at","to zimbra at law","zimbra at law or","disclaiming or limiting zimbra","or limiting zimbra s","limiting zimbra s liability","zimbra s liability sections","the state of delaware","state of delaware and","of delaware and the","delaware and the united","this agreement involving zimbra","agreement involving zimbra or","involving zimbra or any","zimbra or any of","any of its parents","of its parents or","its parents or subsidiaries","parents or subsidiaries shall","or subsidiaries shall be","of northern texas with","northern texas with venue","texas with venue lying","venue lying in dallas","lying in dallas county","in dallas county texas","dallas county texas no","county texas no rights","texas no rights may","written consent of zimbra","consent of zimbra and","of zimbra and any","zimbra and any purported","license version 1 4 zpl","version 1 4 zpl this","1 4 zpl this zimbra","4 zpl this zimbra public","the terms under which zimbra","terms under which zimbra inc","under which zimbra inc a","which zimbra inc a texas","zimbra inc a texas corporation","inc a texas corporation zimbra","a texas corporation zimbra will","texas corporation zimbra will provide","corporation zimbra will provide software"]},{"licenseTexts":["zlib License Copyright (c) \u003cyear\u003e \u003ccopyright holders\u003e\n\nThis software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software.\n\nPermission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions:\n\n   1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.\n\n   2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.\n\n   3. This notice may not be removed or altered from any source distribution."],"licenseIds":["Zlib"],"keywords":["zlib license copyright","holders this software","zlib license copyright c","year copyright holders this","copyright holders this software","holders this software is","zlib license copyright c year","c year copyright holders this","year copyright holders this software","copyright holders this software is","holders this software is provided"]},{"licenseTexts":["The author disclaims copyright to this source code. In place of a legal notice, here is a blessing:\n\n   \n\n   May you do good and not evil.\n\n   \n\n   May you find forgiveness for yourself and forgive others.\n\n   \n\n   May you share freely, never taking more than you give."],"licenseIds":["blessing"],"keywords":["author disclaims copyright","disclaims copyright to","copyright to this","to this source","code in place","place of a","of a legal","legal notice here","notice here is","is a blessing","a blessing may","blessing may you","may you do","you do good","do good and","good and not","and not evil","not evil may","evil may you","may you find","you find forgiveness","find forgiveness for","forgiveness for yourself","for yourself and","yourself and forgive","and forgive others","forgive others may","others may you","may you share","you share freely","share freely never","freely never taking","never taking more","taking more than","more than you","than you give","the author disclaims copyright","author disclaims copyright to","disclaims copyright to this","copyright to this source","to this source code","source code in place","code in place of","in place of a","place of a legal","of a legal notice","a legal notice here","legal notice here is","notice here is a","here is a blessing","is a blessing may","a blessing may you","blessing may you do","may you do good","you do good and","do good and not","good and not evil","and not evil may","not evil may you","evil may you find","may you find forgiveness","you find forgiveness for","find forgiveness for yourself","forgiveness for yourself and","for yourself and forgive","yourself and forgive others","and forgive others may","forgive others may you","others may you share","may you share freely","you share freely never","share freely never taking","freely never taking more","never taking more than","taking more than you","more than you give","the author disclaims copyright to","author disclaims copyright to this","disclaims copyright to this source","copyright to this source code","to this source code in","this source code in place","source code in place of","code in place of a","in place of a legal","place of a legal notice","of a legal notice here","a legal notice here is","legal notice here is a","notice here is a blessing","here is a blessing may","is a blessing may you","a blessing may you do","blessing may you do good","may you do good and","you do good and not","do good and not evil","good and not evil may","and not evil may you","not evil may you find","evil may you find forgiveness","may you find forgiveness for","you find forgiveness for yourself","find forgiveness for yourself and","forgiveness for yourself and forgive","for yourself and forgive others","yourself and forgive others may","and forgive others may you","forgive others may you share","others may you share freely","may you share freely never","you share freely never taking","share freely never taking more","freely never taking more than","never taking more than you","taking more than you give"]},{"licenseTexts":["Version 1.0.5 of 10 December 2007 Copyright © 1996-2007 Julian Seward\n\nThis program, bzip2, the associated library libbzip2, and all documentation, are copyright © 1996-2007 Julian Seward. All rights reserved.\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   • Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n   • The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.\n\n   • Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.\n\n   • The name of the author may not be used to endorse or promote products derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE AUTHOR \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\nPATENTS: To the best of my knowledge, bzip2 and libbzip2 do not use any patented algorithms. However, I do not have the resources to carry out a patent search. Therefore I cannot give any guarantee of the above statement."],"licenseIds":["bzip2-1.0.5"],"keywords":["1 0 5","0 5 of","5 of 10","of 10 december","10 december 2007","december 2007 copyright","2007 copyright 1996","julian seward this","seward this program","are copyright 1996","julian seward all","following disclaimer the","disclaimer the origin","not required altered","required altered source","original software the","such damage patents","damage patents to","best of my","of my knowledge","my knowledge bzip2","knowledge bzip2 and","bzip2 and libbzip2","and libbzip2 do","libbzip2 do not","use any patented","any patented algorithms","patented algorithms however","algorithms however i","however i do","i do not","not have the","have the resources","the resources to","resources to carry","carry out a","out a patent","a patent search","patent search therefore","search therefore i","therefore i cannot","i cannot give","cannot give any","give any guarantee","any guarantee of","guarantee of the","the above statement","version 1 0 5","1 0 5 of","0 5 of 10","5 of 10 december","of 10 december 2007","10 december 2007 copyright","december 2007 copyright 1996","2007 copyright 1996 2007","2007 julian seward this","julian seward this program","seward this program bzip2","documentation are copyright 1996","are copyright 1996 2007","2007 julian seward all","julian seward all rights","the following disclaimer the","following disclaimer the origin","disclaimer the origin of","is not required altered","not required altered source","required altered source versions","the original software the","original software the name","software the name of","of such damage patents","such damage patents to","damage patents to the","patents to the best","the best of my","best of my knowledge","of my knowledge bzip2","my knowledge bzip2 and","knowledge bzip2 and libbzip2","bzip2 and libbzip2 do","and libbzip2 do not","libbzip2 do not use","do not use any","not use any patented","use any patented algorithms","any patented algorithms however","patented algorithms however i","algorithms however i do","however i do not","i do not have","do not have the","not have the resources","have the resources to","the resources to carry","resources to carry out","to carry out a","carry out a patent","out a patent search","a patent search therefore","patent search therefore i","search therefore i cannot","therefore i cannot give","i cannot give any","cannot give any guarantee","give any guarantee of","any guarantee of the","guarantee of the above","of the above statement","version 1 0 5 of","1 0 5 of 10","0 5 of 10 december","5 of 10 december 2007","of 10 december 2007 copyright","10 december 2007 copyright 1996","december 2007 copyright 1996 2007","2007 copyright 1996 2007 julian","1996 2007 julian seward this","2007 julian seward this program","julian seward this program bzip2","seward this program bzip2 the","all documentation are copyright 1996","documentation are copyright 1996 2007","are copyright 1996 2007 julian","1996 2007 julian seward all","2007 julian seward all rights","julian seward all rights reserved","and the following disclaimer the","the following disclaimer the origin","following disclaimer the origin of","disclaimer the origin of this","but is not required altered","is not required altered source","not required altered source versions","required altered source versions must","being the original software the","the original software the name","original software the name of","software the name of the","possibility of such damage patents","of such damage patents to","such damage patents to the","damage patents to the best","patents to the best of","to the best of my","the best of my knowledge","best of my knowledge bzip2","of my knowledge bzip2 and","my knowledge bzip2 and libbzip2","knowledge bzip2 and libbzip2 do","bzip2 and libbzip2 do not","and libbzip2 do not use","libbzip2 do not use any","do not use any patented","not use any patented algorithms","use any patented algorithms however","any patented algorithms however i","patented algorithms however i do","algorithms however i do not","however i do not have","i do not have the","do not have the resources","not have the resources to","have the resources to carry","the resources to carry out","resources to carry out a","to carry out a patent","carry out a patent search","out a patent search therefore","a patent search therefore i","patent search therefore i cannot","search therefore i cannot give","therefore i cannot give any","i cannot give any guarantee","cannot give any guarantee of","give any guarantee of the","any guarantee of the above","guarantee of the above statement"]},{"licenseTexts":["This program, \"bzip2\", the associated library \"libbzip2\", and all documentation, are copyright (C) 1996-2010 Julian R Seward. All rights reserved.\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n   2. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.\n\n   3. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.\n\n   4. The name of the author may not be used to endorse or promote products derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\nJulian Seward, jseward@bzip.org bzip2/libbzip2 version 1.0.6 of 6 September 2010"],"licenseIds":["bzip2-1.0.6"],"keywords":["1996 2010 julian","2010 julian r","julian r seward","r seward all","disclaimer 2 the","not required 3","required 3 altered","3 altered source","original software 4","software 4 the","such damage julian","damage julian seward","julian seward jseward","seward jseward bzip","jseward bzip org","bzip org bzip2","org bzip2 libbzip2","bzip2 libbzip2 version","libbzip2 version 1","0 6 of","6 of 6","of 6 september","6 september 2010","documentation are copyright c","c 1996 2010 julian","1996 2010 julian r","2010 julian r seward","julian r seward all","r seward all rights","following disclaimer 2 the","disclaimer 2 the origin","is not required 3","not required 3 altered","required 3 altered source","3 altered source versions","the original software 4","original software 4 the","software 4 the name","of such damage julian","such damage julian seward","damage julian seward jseward","julian seward jseward bzip","seward jseward bzip org","jseward bzip org bzip2","bzip org bzip2 libbzip2","org bzip2 libbzip2 version","bzip2 libbzip2 version 1","libbzip2 version 1 0","version 1 0 6","1 0 6 of","0 6 of 6","6 of 6 september","of 6 september 2010","all documentation are copyright c","documentation are copyright c 1996","are copyright c 1996 2010","copyright c 1996 2010 julian","c 1996 2010 julian r","1996 2010 julian r seward","2010 julian r seward all","julian r seward all rights","r seward all rights reserved","the following disclaimer 2 the","following disclaimer 2 the origin","disclaimer 2 the origin of","but is not required 3","is not required 3 altered","not required 3 altered source","required 3 altered source versions","3 altered source versions must","being the original software 4","the original software 4 the","original software 4 the name","software 4 the name of","4 the name of the","possibility of such damage julian","of such damage julian seward","such damage julian seward jseward","damage julian seward jseward bzip","julian seward jseward bzip org","seward jseward bzip org bzip2","jseward bzip org bzip2 libbzip2","bzip org bzip2 libbzip2 version","org bzip2 libbzip2 version 1","bzip2 libbzip2 version 1 0","libbzip2 version 1 0 6","version 1 0 6 of","1 0 6 of 6","0 6 of 6 september","6 of 6 september 2010"]},{"licenseTexts":["copyleft-next 0.3.0 (\"this License\")\n\nRelease date: 2013-05-16\n\n   1. License Grants; No Trademark License\n\n   Subject to the terms of this License, I grant You:\n\n      a) A non-exclusive, worldwide, perpetual, royalty-free, irrevocable copyright license, to reproduce, Distribute, prepare derivative works of, publicly perform and publicly display My Work.\n\n      b) A non-exclusive, worldwide, perpetual, royalty-free, irrevocable patent license under Licensed Patents to make, have made, use, sell, offer for sale, and import Covered Works.\n\n   This License does not grant any rights in My name, trademarks, service marks, or logos.\n\n   2. Distribution: General Conditions\n\n   You may Distribute Covered Works, provided that You (i) inform recipients how they can obtain a copy of this License; (ii) satisfy the applicable conditions of sections 3 through 6; and (iii) preserve all Legal Notices contained in My Work (to the extent they remain pertinent). \"Legal Notices\" means copyright notices, license notices, license texts, and author attributions, but does not include logos, other graphical images, trademarks or trademark legends.\n\n   3. Conditions for Distributing Derived Works; Outbound GPL Compatibility\n\n   If You Distribute a Derived Work, You must license the entire Derived Work as a whole under this License, with prominent notice of such licensing. This condition may not be avoided through such means as separate Distribution of portions of the Derived Work. You may additionally license the Derived Work under the GPL, so that the recipient may further Distribute the Derived Work under either this License or the GPL.\n\n   4. Condition Against Further Restrictions; Inbound License Compatibility\n\n   When Distributing a Covered Work, You may not impose further restrictions on the exercise of rights in the Covered Work granted under this License. This condition is not excused merely because such restrictions result from Your compliance with conditions or obligations extrinsic to this License (such as a court order or an agreement with a third party).\n\n   However, You may Distribute a Covered Work incorporating material governed by a license that is both OSI-Approved and FSF-Free as of the release date of this License, provided that Your Distribution complies with such other license.\n\n   5. Conditions for Distributing Object Code\n\n   You may Distribute an Object Code form of a Covered Work, provided that you accompany the Object Code with a URL through which the Corresponding Source is made available, at no charge, by some standard or customary means of providing network access to source code.\n\n   If you Distribute the Object Code in a physical product or tangible storage medium (\"Product\"), the Corresponding Source must be available through such URL for two years from the date of Your most recent Distribution of the Object Code in the Product. However, if the Product itself contains or is accompanied by the Corresponding Source (made available in a customarily accessible manner), You need not also comply with the first paragraph of this section.\n\n   Each recipient of the Covered Work from You is an intended third-party beneficiary of this License solely as to this section 5, with the right to enforce its terms.\n\n   6. Symmetrical Licensing Condition for Upstream Contributions\n\n   If You Distribute a work to Me specifically for inclusion in or modification of a Covered Work (a \"Patch\"), and no explicit licensing terms apply to the Patch, You license the Patch under this License, to the extent of Your copyright in the Patch. This condition does not negate the other conditions of this License, if applicable to the Patch.\n\n   7. Nullification of Copyleft/Proprietary Dual Licensing\n\n   If I offer to license, for a fee, a Covered Work under terms other than a license that is OSI-Approved or FSF-Free as of the release date of this License or a numbered version of copyleft-next released by the Copyleft-Next Project, then the license I grant You under section 1 is no longer subject to the conditions in sections 2 through 5.\n\n   8. Copyleft Sunset\n\n   The conditions in sections 2 through 5 no longer apply once fifteen years have elapsed from the date of My first Distribution of My Work under this License.\n\n   9. Pass-Through\n\n   When You Distribute a Covered Work, the recipient automatically receives a license to My Work from Me, subject to the terms of this License.\n\n   10. Termination\n\n   Your license grants under section 1 are automatically terminated if You\n\n      a) fail to comply with the conditions of this License, unless You cure such noncompliance within thirty days after becoming aware of it, or\n\n      b) initiate a patent infringement litigation claim (excluding declaratory judgment actions, counterclaims, and cross-claims) alleging that any part of My Work directly or indirectly infringes any patent.\n\n   Termination of Your license grants extends to all copies of Covered Works You subsequently obtain. Termination does not terminate the rights of those who have received copies or rights from You subject to this License.\n\n   To the extent permission to make copies of a Covered Work is necessary merely for running it, such permission is not terminable.\n\n   11. Later License Versions\n\n   The Copyleft-Next Project may release new versions of copyleft-next, designated by a distinguishing version number (\"Later Versions\"). Unless I explicitly remove the option of Distributing Covered Works under Later Versions, You may Distribute Covered Works under any Later Version.\n\n   12. No Warranty\n\n   My Work is provided \"as-is\", without warranty. You bear the risk of using it. To the extent permitted by applicable law, each Distributor of My Work excludes the implied warranties of title, merchantability, fitness for a particular purpose and non-infringement.\n\n   13. Limitation of Liability\n\n   To the extent permitted by applicable law, in no event will any Distributor of My Work be liable to You for any damages whatsoever, whether direct, indirect, special, incidental, or consequential damages, whether arising under contract, tort (including negligence), or otherwise, even where the Distributor knew or should have known about the possibility of such damages.\n\n   14. Severability\n\n   The invalidity or unenforceability of any provision of this License does not affect the validity or enforceability of the remainder of this License. Such provision is to be reformed to the minimum extent necessary to make it valid and enforceable.\n\n   15. Definitions\n\n   \"Copyleft-Next Project\" means the project that maintains the source code repository at \u003chttps://gitorious.org/copyleft-next/\u003e as of the release date of this License.\n\n   \"Corresponding Source\" of a Covered Work in Object Code form means (i) the Source Code form of the Covered Work; (ii) all scripts, instructions and similar information that are reasonably necessary for a skilled developer to generate such Object Code from the Source Code provided under (i); and (iii) a list clearly identifying all Separate Works (other than those provided in compliance with (ii)) that were specifically used in building and (if applicable) installing the Covered Work (for example, a specified proprietary compiler including its version number). Corresponding Source must be machine-readable.\n\n   \"Covered Work\" means My Work or a Derived Work.\n\n   \"Derived Work\" means a work of authorship that copies from, modifies, adapts, is based on, is a derivative work of, transforms, translates or contains all or part of My Work, such that copyright permission is required. The following are not Derived Works: (i) Mere Aggregation; (ii) a mere reproduction of My Work; and (iii) if My Work fails to explicitly state an expectation otherwise, a work that merely makes reference to My Work.\n\n   \"Distribute\" means to distribute, transfer or make a copy available to someone else, such that copyright permission is required.\n\n   \"Distributor\" means Me and anyone else who Distributes a Covered Work.\n\n   \"FSF-Free\" means classified as 'free' by the Free Software Foundation.\n\n   \"GPL\" means a version of the GNU General Public License or the GNU Affero General Public License.\n\n   \"I\"/\"Me\"/\"My\" refers to the individual or legal entity that places My Work under this License. \"You\"/\"Your\" refers to the individual or legal entity exercising rights in My Work under this License. A legal entity includes each entity that controls, is controlled by, or is under common control with such legal entity. \"Control\" means (a) the power to direct the actions of such legal entity, whether by contract or otherwise, or (b) ownership of more than fifty percent of the outstanding shares or beneficial ownership of such legal entity.\n\n   \"Licensed Patents\" means all patent claims licensable royalty-free by Me, now or in the future, that are necessarily infringed by making, using, or selling My Work, and excludes claims that would be infringed only as a consequence of further modification of My Work.\n\n   \"Mere Aggregation\" means an aggregation of a Covered Work with a Separate Work.\n\n   \"My Work\" means the particular work of authorship I license to You under this License.\n\n   \"Object Code\" means any form of a work that is not Source Code.\n\n   \"OSI-Approved\" means approved as 'Open Source' by the Open Source Initiative.\n\n   \"Separate Work\" means a work that is separate from and independent of a particular Covered Work and is not by its nature an extension or enhancement of the Covered Work, and/or a runtime library, standard library or similar component that is used to generate an Object Code form of a Covered Work.\n\n   \"Source Code\" means the preferred form of a work for making modifications to it."],"licenseIds":["copyleft-next-0.3.0"],"keywords":["0 3 0","release date 2013","date 2013 05","2013 05 16","05 16 1","16 1 license","you may additionally","may additionally license","additionally license the","the gpl so","gpl so that","recipient may further","may further distribute","work under either","under either this","or the gpl","that your distribution","your distribution complies","complies with such","other license 5","section each recipient","at https gitorious","https gitorious org","gitorious org copyleft","org copyleft next","copyleft next as","next as of","next 0 3 0","0 3 0 this","3 0 this license","0 this license release","license release date 2013","release date 2013 05","date 2013 05 16","2013 05 16 1","05 16 1 license","16 1 license grants","the derived work you","work you may additionally","you may additionally license","may additionally license the","additionally license the derived","under the gpl so","the gpl so that","gpl so that the","that the recipient may","the recipient may further","recipient may further distribute","may further distribute the","further distribute the derived","derived work under either","work under either this","under either this license","license or the gpl","or the gpl 4","license provided that your","provided that your distribution","that your distribution complies","your distribution complies with","distribution complies with such","complies with such other","such other license 5","other license 5 conditions","this section each recipient","section each recipient of","2 through 5 8","2 through 5 no","repository at https gitorious","at https gitorious org","https gitorious org copyleft","gitorious org copyleft next","org copyleft next as","copyleft next as of","next as of the","copyleft next 0 3 0","next 0 3 0 this","0 3 0 this license","3 0 this license release","0 this license release date","this license release date 2013","license release date 2013 05","release date 2013 05 16","date 2013 05 16 1","2013 05 16 1 license","05 16 1 license grants","16 1 license grants no","of the derived work you","the derived work you may","derived work you may additionally","work you may additionally license","you may additionally license the","may additionally license the derived","additionally license the derived work","work under the gpl so","under the gpl so that","the gpl so that the","gpl so that the recipient","so that the recipient may","that the recipient may further","the recipient may further distribute","recipient may further distribute the","may further distribute the derived","further distribute the derived work","distribute the derived work under","the derived work under either","derived work under either this","work under either this license","under either this license or","either this license or the","this license or the gpl","license or the gpl 4","or the gpl 4 condition","this license provided that your","license provided that your distribution","provided that your distribution complies","that your distribution complies with","your distribution complies with such","distribution complies with such other","complies with such other license","with such other license 5","such other license 5 conditions","other license 5 conditions for","of this section each recipient","this section each recipient of","section each recipient of the","each recipient of the covered","sections 2 through 5 8","2 through 5 8 copyleft","sections 2 through 5 no","2 through 5 no longer","code repository at https gitorious","repository at https gitorious org","at https gitorious org copyleft","https gitorious org copyleft next","gitorious org copyleft next as","org copyleft next as of","copyleft next as of the","next as of the release"]},{"licenseTexts":["copyleft-next 0.3.1 (\"this License\")\n\nRelease date: 2016-04-29\n\n   1. License Grants; No Trademark License\n\n   Subject to the terms of this License, I grant You:\n\n      a) A non-exclusive, worldwide, perpetual, royalty-free, irrevocable copyright license, to reproduce, Distribute, prepare derivative works of, publicly perform and publicly display My Work.\n\n      b) A non-exclusive, worldwide, perpetual, royalty-free, irrevocable patent license under Licensed Patents to make, have made, use, sell, offer for sale, and import Covered Works.\n\n   This License does not grant any rights in My name, trademarks, service marks, or logos.\n\n   2. Distribution: General Conditions\n\n   You may Distribute Covered Works, provided that You (i) inform recipients how they can obtain a copy of this License; (ii) satisfy the applicable conditions of sections 3 through 6; and (iii) preserve all Legal Notices contained in My Work (to the extent they remain pertinent). \"Legal Notices\" means copyright notices, license notices, license texts, and author attributions, but does not include logos, other graphical images, trademarks or trademark legends.\n\n   3. Conditions for Distributing Derived Works; Outbound GPL Compatibility\n\n   If You Distribute a Derived Work, You must license the entire Derived Work as a whole under this License, with prominent notice of such licensing. This condition may not be avoided through such means as separate Distribution of portions of the Derived Work.\n\n   If the Derived Work includes material licensed under the GPL, You may instead license the Derived Work under the GPL.\n\n   4. Condition Against Further Restrictions; Inbound License Compatibility\n\n   When Distributing a Covered Work, You may not impose further restrictions on the exercise of rights in the Covered Work granted under this License. This condition is not excused merely because such restrictions result from Your compliance with conditions or obligations extrinsic to this License (such as a court order or an agreement with a third party).\n\n   However, You may Distribute a Covered Work incorporating material governed by a license that is both OSI-Approved and FSF-Free as of the release date of this License, provided that compliance with such other license would not conflict with any conditions stated in other sections of this License.\n\n   5. Conditions for Distributing Object Code\n\n   You may Distribute an Object Code form of a Covered Work, provided that you accompany the Object Code with a URL through which the Corresponding Source is made available, at no charge, by some standard or customary means of providing network access to source code.\n\n   If you Distribute the Object Code in a physical product or tangible storage medium (\"Product\"), the Corresponding Source must be available through such URL for two years from the date of Your most recent Distribution of the Object Code in the Product. However, if the Product itself contains or is accompanied by the Corresponding Source (made available in a customarily accessible manner), You need not also comply with the first paragraph of this section.\n\n   Each direct and indirect recipient of the Covered Work from You is an intended third-party beneficiary of this License solely as to this section 5, with the right to enforce its terms.\n\n   6. Symmetrical Licensing Condition for Upstream Contributions\n\n   If You Distribute a work to Me specifically for inclusion in or modification of a Covered Work (a \"Patch\"), and no explicit licensing terms apply to the Patch, You license the Patch under this License, to the extent of Your copyright in the Patch. This condition does not negate the other conditions of this License, if applicable to the Patch.\n\n   7. Nullification of Copyleft/Proprietary Dual Licensing\n\n   If I offer to license, for a fee, a Covered Work under terms other than a license that is OSI-Approved or FSF-Free as of the release date of this License or a numbered version of copyleft-next released by the Copyleft-Next Project, then the license I grant You under section 1 is no longer subject to the conditions in sections 3 through 5.\n\n   8. Copyleft Sunset\n\n   The conditions in sections 3 through 5 no longer apply once fifteen years have elapsed from the date of My first Distribution of My Work under this License.\n\n   9. Pass-Through\n\n   When You Distribute a Covered Work, the recipient automatically receives a license to My Work from Me, subject to the terms of this License.\n\n   10. Termination\n\n   Your license grants under section 1 are automatically terminated if You\n\n      a) fail to comply with the conditions of this License, unless You cure such noncompliance within thirty days after becoming aware of it, or\n\n      b) initiate a patent infringement litigation claim (excluding declaratory judgment actions, counterclaims, and cross-claims) alleging that any part of My Work directly or indirectly infringes any patent.\n\n   Termination of Your license grants extends to all copies of Covered Works You subsequently obtain. Termination does not terminate the rights of those who have received copies or rights from You subject to this License.\n\n   To the extent permission to make copies of a Covered Work is necessary merely for running it, such permission is not terminable.\n\n   11. Later License Versions\n\n   The Copyleft-Next Project may release new versions of copyleft-next, designated by a distinguishing version number (\"Later Versions\"). Unless I explicitly remove the option of Distributing Covered Works under Later Versions, You may Distribute Covered Works under any Later Version.\n\n   12. No Warranty\n\n   My Work is provided \"as-is\", without warranty. You bear the risk of using it. To the extent permitted by applicable law, each Distributor of My Work excludes the implied warranties of title, merchantability, fitness for a particular purpose and non-infringement.\n\n   13. Limitation of Liability\n\n   To the extent permitted by applicable law, in no event will any Distributor of My Work be liable to You for any damages whatsoever, whether direct, indirect, special, incidental, or consequential damages, whether arising under contract, tort (including negligence), or otherwise, even where the Distributor knew or should have known about the possibility of such damages.\n\n   14. Severability\n\n   The invalidity or unenforceability of any provision of this License does not affect the validity or enforceability of the remainder of this License. Such provision is to be reformed to the minimum extent necessary to make it valid and enforceable.\n\n   15. Definitions\n\n   \"Copyleft-Next Project\" means the project that maintains the source code repository at \u003chttps://github.com/copyleft-next/copyleft-next.git/\u003e as of the release date of this License.\n\n   \"Corresponding Source\" of a Covered Work in Object Code form means (i) the Source Code form of the Covered Work; (ii) all scripts, instructions and similar information that are reasonably necessary for a skilled developer to generate such Object Code from the Source Code provided under (i); and (iii) a list clearly identifying all Separate Works (other than those provided in compliance with (ii)) that were specifically used in building and (if applicable) installing the Covered Work (for example, a specified proprietary compiler including its version number). Corresponding Source must be machine-readable.\n\n   \"Covered Work\" means My Work or a Derived Work.\n\n   \"Derived Work\" means a work of authorship that copies from, modifies, adapts, is based on, is a derivative work of, transforms, translates or contains all or part of My Work, such that copyright permission is required. The following are not Derived Works: (i) Mere Aggregation; (ii) a mere reproduction of My Work; and (iii) if My Work fails to explicitly state an expectation otherwise, a work that merely makes reference to My Work.\n\n   \"Distribute\" means to distribute, transfer or make a copy available to someone else, such that copyright permission is required.\n\n   \"Distributor\" means Me and anyone else who Distributes a Covered Work.\n\n   \"FSF-Free\" means classified as 'free' by the Free Software Foundation.\n\n   \"GPL\" means a version of the GNU General Public License or the GNU Affero General Public License.\n\n   \"I\"/\"Me\"/\"My\" refers to the individual or legal entity that places My Work under this License. \"You\"/\"Your\" refers to the individual or legal entity exercising rights in My Work under this License. A legal entity includes each entity that controls, is controlled by, or is under common control with such legal entity. \"Control\" means (a) the power to direct the actions of such legal entity, whether by contract or otherwise, or (b) ownership of more than fifty percent of the outstanding shares or beneficial ownership of such legal entity.\n\n   \"Licensed Patents\" means all patent claims licensable royalty-free by Me, now or in the future, that are necessarily infringed by making, using, or selling My Work, and excludes claims that would be infringed only as a consequence of further modification of My Work.\n\n   \"Mere Aggregation\" means an aggregation of a Covered Work with a Separate Work.\n\n   \"My Work\" means the particular work of authorship I license to You under this License.\n\n   \"Object Code\" means any form of a work that is not Source Code.\n\n   \"OSI-Approved\" means approved as 'Open Source' by the Open Source Initiative.\n\n   \"Separate Work\" means a work that is separate from and independent of a particular Covered Work and is not by its nature an extension or enhancement of the Covered Work, and/or a runtime library, standard library or similar component that is used to generate an Object Code form of a Covered Work.\n\n   \"Source Code\" means the preferred form of a work for making modifications to it."],"licenseIds":["copyleft-next-0.3.1"],"keywords":["0 3 1","3 1 this","release date 2016","date 2016 04","2016 04 29","04 29 1","29 1 license","derived work includes","work includes material","includes material licensed","the gpl you","you may instead","may instead license","instead license the","provided that compliance","that compliance with","compliance with such","other license would","would not conflict","conflict with any","with any conditions","any conditions stated","stated in other","in other sections","other sections of","section each direct","each direct and","direct and indirect","and indirect recipient","indirect recipient of","at https github","https github com","github com copyleft","com copyleft next","copyleft next copyleft","next copyleft next","copyleft next git","next git as","git as of","next 0 3 1","0 3 1 this","3 1 this license","1 this license release","license release date 2016","release date 2016 04","date 2016 04 29","2016 04 29 1","04 29 1 license","29 1 license grants","the derived work if","derived work if the","work if the derived","the derived work includes","derived work includes material","work includes material licensed","includes material licensed under","material licensed under the","licensed under the gpl","under the gpl you","the gpl you may","gpl you may instead","you may instead license","may instead license the","instead license the derived","under the gpl 4","license provided that compliance","provided that compliance with","that compliance with such","compliance with such other","such other license would","other license would not","license would not conflict","would not conflict with","not conflict with any","conflict with any conditions","with any conditions stated","any conditions stated in","conditions stated in other","stated in other sections","in other sections of","other sections of this","this license 5 conditions","this section each direct","section each direct and","each direct and indirect","direct and indirect recipient","and indirect recipient of","indirect recipient of the","3 through 5 8","3 through 5 no","repository at https github","at https github com","https github com copyleft","github com copyleft next","com copyleft next copyleft","copyleft next copyleft next","next copyleft next git","copyleft next git as","next git as of","git as of the","copyleft next 0 3 1","next 0 3 1 this","0 3 1 this license","3 1 this license release","1 this license release date","this license release date 2016","license release date 2016 04","release date 2016 04 29","date 2016 04 29 1","2016 04 29 1 license","04 29 1 license grants","29 1 license grants no","of the derived work if","the derived work if the","derived work if the derived","work if the derived work","if the derived work includes","the derived work includes material","derived work includes material licensed","work includes material licensed under","includes material licensed under the","material licensed under the gpl","licensed under the gpl you","under the gpl you may","the gpl you may instead","gpl you may instead license","you may instead license the","may instead license the derived","instead license the derived work","work under the gpl 4","under the gpl 4 condition","this license provided that compliance","license provided that compliance with","provided that compliance with such","that compliance with such other","compliance with such other license","with such other license would","such other license would not","other license would not conflict","license would not conflict with","would not conflict with any","not conflict with any conditions","conflict with any conditions stated","with any conditions stated in","any conditions stated in other","conditions stated in other sections","stated in other sections of","in other sections of this","other sections of this license","sections of this license 5","of this license 5 conditions","this license 5 conditions for","of this section each direct","this section each direct and","section each direct and indirect","each direct and indirect recipient","direct and indirect recipient of","and indirect recipient of the","indirect recipient of the covered","sections 3 through 5 8","3 through 5 8 copyleft","sections 3 through 5 no","3 through 5 no longer","code repository at https github","repository at https github com","at https github com copyleft","https github com copyleft next","github com copyleft next copyleft","com copyleft next copyleft next","copyleft next copyleft next git","next copyleft next git as","copyleft next git as of","next git as of the","git as of the release"]},{"licenseTexts":["COPYRIGHT AND PERMISSION NOTICE Copyright (c) 1996 - 2015, Daniel Stenberg, \u003cdaniel@haxx.se\u003e.\n\nAll rights reserved.\n\nPermission to use, copy, modify, and distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nExcept as contained in this notice, the name of a copyright holder shall not be used in advertising or otherwise to promote the sale, use or other dealings in this Software without prior written authorization of the copyright holder."],"licenseIds":["curl"],"keywords":["c 1996 2015","1996 2015 daniel","2015 daniel stenberg","daniel stenberg daniel","stenberg daniel haxx","daniel haxx se","haxx se all","se all rights","notice copyright c 1996","copyright c 1996 2015","c 1996 2015 daniel","1996 2015 daniel stenberg","2015 daniel stenberg daniel","daniel stenberg daniel haxx","stenberg daniel haxx se","daniel haxx se all","haxx se all rights","se all rights reserved","permission notice copyright c 1996","notice copyright c 1996 2015","copyright c 1996 2015 daniel","c 1996 2015 daniel stenberg","1996 2015 daniel stenberg daniel","2015 daniel stenberg daniel haxx","daniel stenberg daniel haxx se","stenberg daniel haxx se all","daniel haxx se all rights","haxx se all rights reserved","se all rights reserved permission"]},{"licenseTexts":["\n\n   1. you can do what you want with it\n\n   2. I refuse any responsibility for the consequences"],"licenseIds":["diffmark"],"keywords":["1 you can","can do what","do what you","want with it","with it 2","it 2 i","2 i refuse","i refuse any","refuse any responsibility","any responsibility for","1 you can do","you can do what","can do what you","do what you want","what you want with","you want with it","want with it 2","with it 2 i","it 2 i refuse","2 i refuse any","i refuse any responsibility","refuse any responsibility for","any responsibility for the","1 you can do what","you can do what you","can do what you want","do what you want with","what you want with it","you want with it 2","want with it 2 i","with it 2 i refuse","it 2 i refuse any","2 i refuse any responsibility","i refuse any responsibility for","refuse any responsibility for the","any responsibility for the consequences"]},{"licenseTexts":["A modified version of this file may be distributed, but it should be distributed with a *different* name. Changed files must be distributed *together with a complete and unchanged* distribution of these files."],"licenseIds":["dvipdfm"],"keywords":["be distributed but","distributed but it","but it should","it should be","should be distributed","be distributed with","distributed with a","with a different","a different name","different name changed","name changed files","be distributed together","distributed together with","complete and unchanged","and unchanged distribution","unchanged distribution of","distribution of these","file may be distributed","may be distributed but","be distributed but it","distributed but it should","but it should be","it should be distributed","should be distributed with","be distributed with a","distributed with a different","with a different name","a different name changed","different name changed files","name changed files must","must be distributed together","be distributed together with","distributed together with a","together with a complete","with a complete and","a complete and unchanged","complete and unchanged distribution","and unchanged distribution of","unchanged distribution of these","distribution of these files","modified version of this file","version of this file may","this file may be distributed","file may be distributed but","may be distributed but it","be distributed but it should","distributed but it should be","but it should be distributed","it should be distributed with","should be distributed with a","be distributed with a different","distributed with a different name","with a different name changed","a different name changed files","different name changed files must","name changed files must be","files must be distributed together","must be distributed together with","be distributed together with a","distributed together with a complete","together with a complete and","with a complete and unchanged","a complete and unchanged distribution","complete and unchanged distribution of","and unchanged distribution of these","unchanged distribution of these files"]},{"licenseTexts":["The eCos license version 2.0\n\nThis file is part of eCos, the Embedded Configurable Operating System. Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.\n\neCos is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 or (at your option) any later version.\n\neCos is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.\n\nYou should have received a copy of the GNU General Public License along with eCos; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.\n\nAs a special exception, if other files instantiate templates or use macros or inline functions from this file, or you compile this file and link it with other works to produce a work based on this file, this file does not by itself cause the resulting work to be covered by the GNU General Public License. However the source code for this file must still be made available in accordance with section (3) of the GNU General Public License.\n\nThis exception does not invalidate any other reasons why a work based on this file might be covered by the GNU General Public License.\n\nAlternative licenses for eCos may be arranged by contacting Red Hat, Inc. at http://sources.redhat.com/ecos/ecos-license/ ------------------------------------------- ####ECOSGPLCOPYRIGHTEND####"],"licenseIds":["eCos-2.0"],"keywords":["the ecos license","ecos license version","0 this file","part of ecos","of ecos the","ecos the embedded","the embedded configurable","operating system copyright","system copyright c","1999 2000 2001","2001 2002 red","2002 red hat","hat inc ecos","inc ecos is","ecos is free","2 or at","later version ecos","version ecos is","ecos is distributed","along with ecos","with ecos if","ecos if not","1301 usa as","usa as a","exception if other","if other files","other files instantiate","files instantiate templates","instantiate templates or","templates or use","or use macros","use macros or","macros or inline","or inline functions","inline functions from","functions from this","from this file","file or you","or you compile","you compile this","compile this file","file and link","and link it","link it with","works to produce","this file this","this file does","resulting work to","however the source","for this file","this file must","file must still","must still be","still be made","available in accordance","not invalidate any","reasons why a","why a work","this file might","file might be","public license alternative","license alternative licenses","licenses for ecos","for ecos may","ecos may be","may be arranged","be arranged by","arranged by contacting","by contacting red","contacting red hat","hat inc at","at http sources","http sources redhat","sources redhat com","redhat com ecos","com ecos ecos","ecos ecos license","ecos license ecosgplcopyrightend","the ecos license version","ecos license version 2","2 0 this file","0 this file is","is part of ecos","part of ecos the","of ecos the embedded","ecos the embedded configurable","the embedded configurable operating","configurable operating system copyright","operating system copyright c","system copyright c 1998","1998 1999 2000 2001","1999 2000 2001 2002","2000 2001 2002 red","2001 2002 red hat","2002 red hat inc","red hat inc ecos","hat inc ecos is","inc ecos is free","ecos is free software","either version 2 or","version 2 or at","2 or at your","any later version ecos","later version ecos is","version ecos is distributed","ecos is distributed in","license along with ecos","along with ecos if","with ecos if not","ecos if not write","02110 1301 usa as","1301 usa as a","usa as a special","special exception if other","exception if other files","if other files instantiate","other files instantiate templates","files instantiate templates or","instantiate templates or use","templates or use macros","or use macros or","use macros or inline","macros or inline functions","or inline functions from","inline functions from this","functions from this file","from this file or","this file or you","file or you compile","or you compile this","you compile this file","compile this file and","this file and link","file and link it","and link it with","link it with other","it with other works","other works to produce","works to produce a","produce a work based","on this file this","this file this file","file this file does","this file does not","file does not by","cause the resulting work","the resulting work to","resulting work to be","work to be covered","license however the source","however the source code","code for this file","for this file must","this file must still","file must still be","must still be made","still be made available","made available in accordance","available in accordance with","with section 3 of","exception does not invalidate","does not invalidate any","not invalidate any other","other reasons why a","reasons why a work","why a work based","on this file might","this file might be","file might be covered","general public license alternative","public license alternative licenses","license alternative licenses for","alternative licenses for ecos","licenses for ecos may","for ecos may be","ecos may be arranged","may be arranged by","be arranged by contacting","arranged by contacting red","by contacting red hat","contacting red hat inc","red hat inc at","hat inc at http","inc at http sources","at http sources redhat","http sources redhat com","sources redhat com ecos","redhat com ecos ecos","com ecos ecos license","ecos ecos license ecosgplcopyrightend","the ecos license version 2","ecos license version 2 0","license version 2 0 this","version 2 0 this file","2 0 this file is","0 this file is part","file is part of ecos","is part of ecos the","part of ecos the embedded","of ecos the embedded configurable"]},{"licenseTexts":["EGENIX.COM PUBLIC LICENSE AGREEMENT\n\nVersion 1.1.0 This license agreement is based on the Python CNRI License Agreement, a widely accepted open- source license.\n\n   1. Introduction\n\n   This \"License Agreement\" is between eGenix.com Software, Skills and Services GmbH (\"eGenix.com\"), having an office at Pastor-Loeh-Str. 48, D-40764 Langenfeld, Germany, and the Individual or Organization (\"Licensee\") accessing and otherwise using this software in source or binary form and its associated documentation (\"the Software\").\n\n   2. License\n\n   Subject to the terms and conditions of this eGenix.com Public License Agreement, eGenix.com hereby grants Licensee a non-exclusive, royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivative works, distribute, and otherwise use the Software alone or in any derivative version, provided, however, that the eGenix.com Public License Agreement is retained in the Software, or in any derivative version of the Software prepared by Licensee.\n\n   3. NO WARRANTY\n\n   eGenix.com is making the Software available to Licensee on an \"AS IS\" basis. SUBJECT TO ANY STATUTORY WARRANTIES WHICH CAN NOT BE EXCLUDED, EGENIX.COM MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, EGENIX.COM MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.\n\n   4. LIMITATION OF LIABILITY\n\n   EGENIX.COM SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE SOFTWARE FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR OTHER PECUNIARY LOSS) AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OR LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THE ABOVE EXCLUSION OR LIMITATION MAY NOT APPLY TO LICENSEE.\n\n   5. Termination\n\n   This License Agreement will automatically terminate upon a material breach of its terms and conditions.\n\n   6. Third Party Rights\n\n   Any software or documentation in source or binary form provided along with the Software that is associated with a separate license agreement is licensed to Licensee under the terms of that license agreement. This License Agreement does not apply to those portions of the Software. Copies of the third party licenses are included in the Software Distribution.\n\n   7. General\n\n   Nothing in this License Agreement affects any statutory rights of consumers that cannot be waived or limited by contract.\n\n   Nothing in this License Agreement shall be deemed to create any relationship of agency, partnership, or joint venture between eGenix.com and Licensee.\n\n   If any provision of this License Agreement shall be unlawful, void, or for any reason unenforceable, such provision shall be modified to the extent necessary to render it enforceable without losing its intent, or, if no such modification is possible, be severed from this License Agreement and shall not affect the validity and enforceability of the remaining provisions of this License Agreement.\n\n   This License Agreement shall be governed by and interpreted in all respects by the law of Germany, excluding conflict of law provisions. It shall not be governed by the United Nations Convention on Contracts for International Sale of Goods. This License Agreement does not grant permission to use eGenix.com trademarks or trade names in a trademark sense to endorse or promote products or services of Licensee, or any third party.\n\n   The controlling language of this License Agreement is English. If Licensee has received a translation into another language, it has been provided for Licensee's convenience only.\n\n   8. Agreement\n\nBy downloading, copying, installing or otherwise using the Software, Licensee agrees to be bound by the terms and conditions of this License Agreement. For question regarding this License Agreement, please write to:\n\neGenix.com Software, Skills and Services GmbH\n\nPastor-Loeh-Str. 48\n\nD-40764 Langenfeld\n\nGermany"],"licenseIds":["eGenix"],"keywords":["agreement is based","on the python","the python cnri","python cnri license","cnri license agreement","agreement a widely","a widely accepted","widely accepted open","accepted open source","license 1 introduction","1 introduction this","introduction this license","is between egenix","services gmbh egenix","gmbh egenix com","egenix com having","com having an","office at pastor","at pastor loeh","langenfeld germany and","germany and the","software 2 license","2 license subject","of this egenix","this egenix com","license agreement egenix","agreement egenix com","egenix com hereby","com hereby grants","that the egenix","the egenix com","derivative version of","the software prepared","software prepared by","licensee 3 no","3 no warranty","no warranty egenix","warranty egenix com","egenix com is","com is making","is basis subject","basis subject to","to any statutory","any statutory warranties","statutory warranties which","warranties which can","which can not","can not be","be excluded egenix","excluded egenix com","not limitation egenix","limitation egenix com","rights 4 limitation","4 limitation of","of liability egenix","liability egenix com","egenix com shall","com shall not","or loss including","loss including without","of business profits","business profits business","profits business interruption","of business information","business information or","information or other","or other pecuniary","other pecuniary loss","pecuniary loss as","thereof some jurisdictions","damages so the","the above exclusion","above exclusion or","or limitation may","to licensee 5","licensee 5 termination","5 termination this","conditions 6 third","6 third party","party rights any","rights any software","any software or","documentation in source","form provided along","that is associated","is associated with","associated with a","agreement is licensed","licensed to licensee","that license agreement","the software copies","software copies of","of the third","third party licenses","party licenses are","licenses are included","the software distribution","software distribution 7","distribution 7 general","7 general nothing","general nothing in","license agreement affects","agreement affects any","affects any statutory","any statutory rights","rights of consumers","of consumers that","consumers that cannot","be waived or","waived or limited","limited by contract","by contract nothing","contract nothing in","venture between egenix","egenix com and","com and licensee","and licensee if","licensee if any","shall be unlawful","be unlawful void","unlawful void or","void or for","any reason unenforceable","reason unenforceable such","modified to the","necessary to render","to render it","render it enforceable","it enforceable without","enforceable without losing","without losing its","losing its intent","its intent or","intent or if","if no such","no such modification","modification is possible","is possible be","possible be severed","the validity and","validity and enforceability","law of germany","of germany excluding","germany excluding conflict","law provisions it","provisions it shall","not be governed","contracts for international","for international sale","of goods this","goods this license","to use egenix","use egenix com","egenix com trademarks","com trademarks or","third party the","party the controlling","the controlling language","controlling language of","language of this","agreement is english","is english if","english if licensee","licensee has received","has received a","received a translation","a translation into","translation into another","another language it","language it has","been provided for","provided for licensee","for licensee s","licensee s convenience","s convenience only","convenience only 8","only 8 agreement","8 agreement by","by downloading copying","downloading copying installing","agreement for question","for question regarding","question regarding this","regarding this license","license agreement please","agreement please write","please write to","write to egenix","to egenix com","services gmbh pastor","gmbh pastor loeh","public license agreement version","version 1 1 0","1 1 0 this","license agreement is based","agreement is based on","based on the python","on the python cnri","the python cnri license","python cnri license agreement"]},{"licenseTexts":["LICENCE OUVERTE / OPEN LICENCE ===================================================================\n\n- Version 2.0\n\n- Avril 2017\n\n« RÉUTILISATION » DE L'« INFORMATION » SOUS CETTE LICENCE -------------------------------------------------------------------\n\nLe « Concédant » concède au « Réutilisateur » un droit non exclusif et gratuit de libre « Réutilisation » de l'« Information » objet de la présente licence, à des fins commerciales ou non, dans le monde entier et pour une durée illimitée, dans les conditions exprimées ci-dessous.\n\nLe « Réutilisateur » est libre de réutiliser l'« Information » :\n\n   - de la reproduire, la copier,\n\n   - de l'adapter, la modifier, l'extraire et la transformer, pour créer des « Informations dérivées », des produits ou des services,\n\n   - de la communiquer, la diffuser, la redistribuer, la publier et la transmettre,\n\n   - de l'exploiter à titre commercial, par exemple en la combinant avec d'autres informations, ou en l'incluant dans son propre produit ou application.\n\nSous réserve de :\n\n   - mentionner la paternité de l'« Information » : sa source (au moins le nom du « Concédant ») et la date de dernière mise à jour de l'« Information » réutilisée.\n\nLe « Réutilisateur » peut notamment s'acquitter de cette condition en renvoyant, par un lien hypertexte, vers la source de « l'Information » et assurant une mention effective de sa paternité.\n\nPar exemple :\n\n« Ministère de xxx - Données originales téléchargées sur http://www.data.gouv.fr/fr/datasets/xxx/, mise à jour du 14 février 2017 ».\n\nCette mention de paternité ne confère aucun caractère officiel à la « Réutilisation » de l'« Information », et ne doit pas suggérer une quelconque reconnaissance ou caution par le « Concédant », ou par toute autre entité publique, du « Réutilisateur » ou de sa « Réutilisation ».\n\n« DONNÉES À CARACTÈRE PERSONNEL » -------------------------------------------------------------------\n\nL'« Information » mise à disposition peut contenir des « Données à caractère personnel » pouvant faire l'objet d'une « Réutilisation ». Si tel est le cas, le « Concédant » informe le « Réutilisateur » de leur présence.\n\nL'« Information » peut être librement réutilisée, dans le cadre des droits accordés par la présente licence, à condition de respecter le cadre légal relatif à la protection des données à caractère personnel.\n\n« DROITS DE PROPRIÉTÉ INTELLECTUELLE » -------------------------------------------------------------------\n\nIl est garanti au « Réutilisateur » que les éventuels « Droits de propriété intellectuelle » détenus par des tiers ou par le « Concédant » sur l'« Information » ne font pas obstacle aux droits accordés par la présente licence.\n\nLorsque le « Concédant » détient des « Droits de propriété intellectuelle » cessibles sur l'« Information », il les cède au « Réutilisateur » de façon non exclusive, à titre gracieux, pour le monde entier, pour toute la durée des « Droits de propriété intellectuelle », et le « Réutilisateur » peut faire tout usage de l'« Information » conformément aux libertés et aux conditions définies par la présente licence.\n\nRESPONSABILITÉ -------------------------------------------------------------------\n\nL'« Information » est mise à disposition telle que produite ou reçue par le « Concédant », sans autre garantie expresse ou tacite que celles prévues par la présente licence. L'absence de défauts ou d'erreurs éventuellement contenues dans l'« Information », comme la fourniture continue de l'« Information » n'est pas garantie par le « Concédant ». Il ne peut être tenu pour responsable de toute perte, préjudice ou dommage de quelque sorte causé à des tiers du fait de la « Réutilisation ».\n\nLe « Réutilisateur » est seul responsable de la « Réutilisation » de l'« Information ».\n\nLa « Réutilisation » ne doit pas induire en erreur des tiers quant au contenu de l'« Information », sa source et sa date de mise à jour.\n\nDROIT APPLICABLE -------------------------------------------------------------------\n\nLa présente licence est régie par le droit français.\n\nCOMPATIBILITÉ DE LA PRÉSENTE LICENCE -------------------------------------------------------------------\n\nLa présente licence a été conçue pour être compatible avec toute licence libre qui exige au moins la mention de paternité et notamment avec la version antérieure de la présente licence ainsi qu'avec les licences :\n\n   - « Open Government Licence » (OGL) du Royaume-Uni,\n\n   - « Creative Commons Attribution » (CC-BY) de Creative Commons et\n\n   - « Open Data Commons Attribution » (ODC-BY) de l'Open Knowledge Foundation.\n\nDÉFINITIONS -------------------------------------------------------------------\n\nSont considérés, au sens de la présente licence comme :\n\nLe « Concédant » : toute personne concédant un droit de « Réutilisation » sur l'« Information » dans les libertés et les conditions prévues par la présente licence\n\nL'« Information » :\n\n   - toute information publique figurant dans des documents communiqués ou publiés par une administration mentionnée au premier alinéa de l'article L.300-2 du CRPA;\n\n   - toute information mise à disposition par toute personne selon les termes et conditions de la présente licence.\n\nLa « Réutilisation » : l'utilisation de l'« Information » à d'autres fins que celles pour lesquelles elle a été produite ou reçue.\n\nLe « Réutilisateur »: toute personne qui réutilise les « Informations » conformément aux conditions de la présente licence.\n\nDes « Données à caractère personnel » : toute information se rapportant à une personne physique identifiée ou identifiable, pouvant être identifiée directement ou indirectement. Leur « Réutilisation » est subordonnée au respect du cadre juridique en vigueur.\n\nUne « Information dérivée » : toute nouvelle donnée ou information créées directement à partir de l'« Information » ou à partir d'une combinaison de l'« Information » et d'autres données ou informations non soumises à cette licence.\n\nLes « Droits de propriété intellectuelle » : tous droits identifiés comme tels par le Code de la propriété intellectuelle (notamment le droit d'auteur, droits voisins au droit d'auteur, droit sui generis des producteurs de bases de données…).\n\nÀ PROPOS DE CETTE LICENCE -------------------------------------------------------------------\n\nLa présente licence a vocation à être utilisée par les administrations pour la réutilisation de leurs informations publiques. Elle peut également être utilisée par toute personne souhaitant mettre à disposition de l'« Information » dans les conditions définies par la présente licence.\n\nLa France est dotée d'un cadre juridique global visant à une diffusion spontanée par les administrations de leurs informations publiques afin d'en permettre la plus large réutilisation.\n\nLe droit de la « Réutilisation » de l'« Information » des administrations est régi par le code des relations entre le public et l'administration (CRPA).\n\nCette licence facilite la réutilisation libre et gratuite des informations publiques et figure parmi les licences qui peuvent être utilisées par l'administration en vertu du décret pris en application de l'article L.323-2 du CRPA.\n\nEtalab est la mission chargée, sous l'autorité du Premier ministre, d'ouvrir le plus grand nombre de données publiques des administrations de l'Etat et de ses établissements publics. Elle a réalisé la Licence Ouverte pour faciliter la réutilisation libre et gratuite de ces informations publiques, telles que définies par l'article L321-1 du CRPA.\n\nCette licence est la version 2.0 de la Licence Ouverte.\n\nEtalab se réserve la faculté de proposer de nouvelles versions de la Licence Ouverte. Cependant, les « Réutilisateurs » pourront continuer à réutiliser les informations qu'ils ont obtenues sous cette licence s'ils le souhaitent."],"licenseIds":["etalab-2.0"],"keywords":["licence ouverte open","ouverte open licence","open licence version","2 0 avril","0 avril 2017","avril 2017 r","2017 r utilisation","l information sous","information sous cette","cette licence le","r utilisateur un","utilisateur un droit","un droit non","droit non exclusif","non exclusif et","exclusif et gratuit","et gratuit de","gratuit de libre","de libre r","libre r utilisation","l information objet","information objet de","objet de la","licence des fins","des fins commerciales","fins commerciales ou","commerciales ou non","dans le monde","monde entier et","entier et pour","et pour une","pour une dur","dur e illimit","e illimit e","illimit e dans","e dans les","les conditions exprim","conditions exprim es","exprim es ci","es ci dessous","ci dessous le","dessous le r","utilisateur est libre","libre de r","de r utiliser","r utiliser l","utiliser l information","l information de","information de la","de la reproduire","la reproduire la","reproduire la copier","la copier de","copier de l","de l adapter","l adapter la","adapter la modifier","la modifier l","modifier l extraire","l extraire et","extraire et la","et la transformer","la transformer pour","transformer pour cr","pour cr er","cr er des","er des informations","des informations d","informations d riv","d riv es","riv es des","es des produits","des produits ou","produits ou des","ou des services","des services de","services de la","de la communiquer","la communiquer la","communiquer la diffuser","la diffuser la","diffuser la redistribuer","la redistribuer la","redistribuer la publier","la publier et","publier et la","et la transmettre","la transmettre de","transmettre de l","de l exploiter","l exploiter titre","exploiter titre commercial","titre commercial par","par exemple en","exemple en la","en la combinant","la combinant avec","combinant avec d","avec d autres","d autres informations","autres informations ou","informations ou en","ou en l","en l incluant","l incluant dans","incluant dans son","dans son propre","son propre produit","propre produit ou","produit ou application","ou application sous","application sous r","de mentionner la","mentionner la paternit","sa source au","source au moins","au moins le","moins le nom","nom du conc","dant et la","date de derni","de derni re","derni re mise","re mise jour","mise jour de","jour de l","l information r","information r utilis","utilis e le","e le r","utilisateur peut notamment","peut notamment s","notamment s acquitter","s acquitter de","acquitter de cette","de cette condition","cette condition en","condition en renvoyant","en renvoyant par","renvoyant par un","un lien hypertexte","lien hypertexte vers","hypertexte vers la","vers la source","la source de","source de l","information et assurant","et assurant une","assurant une mention","une mention effective","mention effective de","effective de sa","de sa paternit","sa paternit par","paternit par exemple","par exemple minist","exemple minist re","minist re de","re de xxx","de xxx donn","xxx donn es","donn es originales","es originales t","originales t l","t l charg","l charg es","charg es sur","es sur http","sur http www","http www data","www data gouv","data gouv fr","gouv fr fr","fr fr datasets","fr datasets xxx","datasets xxx mise","xxx mise jour","mise jour du","jour du 14","du 14 f","14 f vrier","f vrier 2017","vrier 2017 cette","2017 cette mention","cette mention de","de paternit ne","paternit ne conf","ne conf re","conf re aucun","re aucun caract","aucun caract re","caract re officiel","re officiel la","officiel la r","information et ne","et ne doit","doit pas sugg","pas sugg rer","sugg rer une","rer une quelconque"]},{"licenseTexts":["gSOAP Public License\n\nVersion 1.3b The gSOAP public license is derived from the Mozilla Public License (MPL1.1). The sections that were deleted from the original MPL1.1 text are 1.0.1, 2.1.(c),(d), 2.2.(c),(d), 8.2.(b), 10, and 11. Section 3.8 was added. The modified sections are 2.1.(b), 2.2.(b), 3.2 (simplified), 3.5 (deleted the last sentence), and 3.6 (simplified).\n\nThis license applies to the gSOAP software package, with the exception of the soapcpp2 and wsdl2h source code located in gsoap/src and gsoap/wsdl, all code generated by soapcpp2 and wsdl2h, the UDDI source code gsoap/uddi2, and the Web server sample source code samples/webserver. To use any of these software tools and components commercially, a commercial license is required and can be obtained from www.genivia.com.\n\n   1 DEFINITIONS.\n\n      1.0.1.\n\n      1.1. \"Contributor\" means each entity that creates or contributes to the creation of Modifications.\n\n      1.2. \"Contributor Version\" means the combination of the Original Code, prior Modifications used by a Contributor, and the Modifications made by that particular Contributor.\n\n      1.3. \"Covered Code\" means the Original Code, or Modifications or the combination of the Original Code, and Modifications, in each case including portions thereof.\n\n      1.4. \"Electronic Distribution Mechanism\" means a mechanism generally accepted in the software development community for the electronic transfer of data.\n\n      1.5. \"Executable\" means Covered Code in any form other than Source Code.\n\n      1.6. \"Initial Developer\" means the individual or entity identified as the Initial Developer in the Source Code notice required by Exhibit A.\n\n      1.7. \"Larger Work\" means a work which combines Covered Code or portions thereof with code not governed by the terms of this License.\n\n      1.8. \"License\" means this document.\n\n      1.8.1. \"Licensable\" means having the right to grant, to the maximum extent possible, whether at the time of the initial grant or subsequently acquired, any and all of the rights conveyed herein.\n\n      1.9. \"Modifications\" means any addition to or deletion from the substance or structure of either the Original Code or any previous Modifications. When Covered Code is released as a series of files, a Modification is:\n\n         A. Any addition to or deletion from the contents of a file containing Original Code or previous Modifications.\n\n         B. Any new file that contains any part of the Original Code, or previous Modifications.\n\n      1.10. \"Original Code\" means Source Code of computer software code which is described in the Source Code notice required by Exhibit A as Original Code, and which, at the time of its release under this License is not already Covered Code governed by this License.\n\n      1.10.1. \"Patent Claims\" means any patent claim(s), now owned or hereafter acquired, including without limitation, method, process, and apparatus claims, in any patent Licensable by grantor.\n\n      1.11. \"Source Code\" means the preferred form of the Covered Code for making modifications to it, including all modules it contains, plus any associated interface definition files, scripts used to control compilation and installation of an Executable, or source code differential comparisons against either the Original Code or another well known, available Covered Code of the Contributor's choice. The Source Code can be in a compressed or archival form, provided the appropriate decompression or de-archiving software is widely available for no charge.\n\n      1.12. \"You\" (or \"Your\") means an individual or a legal entity exercising rights under, and complying with all of the terms of, this License or a future version of this License issued under Section 6.1. For legal entities, \"You\" includes any entity which controls, is controlled by, or is under common control with You. For purposes of this definition, \"control\" means (a) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (b) ownership of more than fifty percent (50%) of the outstanding shares or beneficial ownership of such entity.\n\n   2 SOURCE CODE LICENSE.\n\n      2.1. The Initial Developer Grant.\n\n      The Initial Developer hereby grants You a world-wide, royalty-free, non-exclusive license, subject to third party intellectual property claims:\n\n         (a) under intellectual property rights (other than patent or trademark) Licensable by Initial Developer to use, reproduce, modify, display, perform, sublicense and distribute the Original Code (or portions thereof) with or without Modifications, and/or as part of a Larger Work; and\n\n         (b) under patents now or hereafter owned or controlled by Initial Developer, to make, have made, use and sell (\"offer to sell and import\") the Original Code, Modifications, or portions thereof, but solely to the extent that any such patent is reasonably necessary to enable You to utilize, alone or in combination with other software, the Original Code, Modifications, or any combination or portions thereof.\n\n         (c)\n\n         (d)\n\n      2.2. Contributor Grant.\n\n      Subject to third party intellectual property claims, each Contributor hereby grants You a world-wide, royalty-free, non-exclusive license\n\n         (a) under intellectual property rights (other than patent or trademark) Licensable by Contributor, to use, reproduce, modify, display, perform, sublicense and distribute the Modifications created by such Contributor (or portions thereof) either on an unmodified basis, with other Modifications, as Covered Code and/or as part of a Larger Work; and\n\n         (b) under patents now or hereafter owned or controlled by Contributor, to make, have made, use and sell (\"offer to sell and import\") the Contributor Version (or portions thereof), but solely to the extent that any such patent is reasonably necessary to enable You to utilize, alone or in combination with other software, the Contributor Version (or portions thereof).\n\n         (c)\n\n         (d)\n\n   3 DISTRIBUTION OBLIGATIONS.\n\n      3.1. Application of License.\n\n      The Modifications which You create or to which You contribute are governed by the terms of this License, including without limitation Section 2.2. The Source Code version of Covered Code may be distributed only under the terms of this License or a future version of this License released under Section 6.1, and You must include a copy of this License with every copy of the Source Code You distribute. You may not offer or impose any terms on any Source Code version that alters or restricts the applicable version of this License or the recipients' rights hereunder. However, You may include an additional document offering the additional rights described in Section 3.5.\n\n      3.2. Availability of Source Code.\n\n      Any Modification created by You shall be provided to the Initial Developer in Source Code form and are subject to the terms of the License.\n\n      3.3. Description of Modifications.\n\n      You must cause all Covered Code to which You contribute to contain a file documenting the changes You made to create that Covered Code and the date of any change. You must include a prominent statement that the Modification is derived, directly or indirectly, from Original Code provided by the Initial Developer and including the name of the Initial Developer in (a) the Source Code, and (b) in any notice in an Executable version or related documentation in which You describe the origin or ownership of the Covered Code.\n\n      3.4. Intellectual Property Matters.\n\n         (a) Third Party Claims. If Contributor has knowledge that a license under a third party's intellectual property rights is required to exercise the rights granted by such Contributor under Sections 2.1 or 2.2, Contributor must include a text file with the Source Code distribution titled \"LEGAL\" which describes the claim and the party making the claim in sufficient detail that a recipient will know whom to contact. If Contributor obtains such knowledge after the Modification is made available as described in Section 3.2, Contributor shall promptly modify the LEGAL file in all copies Contributor makes available thereafter and shall take other steps (such as notifying appropriate mailing lists or newsgroups) reasonably calculated to inform those who received the Covered Code that new knowledge has been obtained.\n\n         (b) Contributor APIs. If Contributor's Modifications include an application programming interface and Contributor has knowledge of patent licenses which are reasonably necessary to implement that API, Contributor must also include this information in the LEGAL file.\n\n         (c) Representations. Contributor represents that, except as disclosed pursuant to Section 3.4(a) above, Contributor believes that Contributor's Modifications are Contributor's original creation(s) and/or Contributor has sufficient rights to grant the rights conveyed by this License.\n\n      3.5. Required Notices.\n\n      You must duplicate the notice in Exhibit A in each file of the Source Code. If it is not possible to put such notice in a particular Source Code file due to its structure, then You must include such notice in a location (such as a relevant directory) where a user would be likely to look for such a notice. If You created one or more Modification(s) You may add your name as a Contributor to the notice described in Exhibit A. You must also duplicate this License in any documentation for the Source Code where You describe recipients' rights or ownership rights relating to Covered Code. You may choose to offer, and to charge a fee for, warranty, support, indemnity or liability obligations to one or more recipients of Covered Code. However, You may do so only on Your own behalf, and not on behalf of the Initial Developer or any Contributor.\n\n      3.6. Distribution of Executable Versions.\n\n      You may distribute Covered Code in Executable form only if the requirements of Section 3.1-3.5 have been met for that Covered Code. You may distribute the Executable version of Covered Code or ownership rights under a license of Your choice, which may contain terms different from this License, provided that You are in compliance with the terms of this License and that the license for the Executable version does not attempt to limit or alter the recipient's rights in the Source Code version from the rights set forth in this License. If You distribute the Executable version under a different license You must make it absolutely clear that any terms which differ from this License are offered by You alone, not by the Initial Developer or any Contributor. If you distribute executable versions containing Covered Code as part of a product, you must reproduce the notice in Exhibit B in the documentation and/or other materials provided with the product.\n\n      3.7. Larger Works.\n\n      You may create a Larger Work by combining Covered Code with other code not governed by the terms of this License and distribute the Larger Work as a single product. In such a case, You must make sure the requirements of this License are fulfilled for the Covered Code.\n\n      3.8. Restrictions.\n\n      You may not remove any product identification, copyright, proprietary notices or labels from gSOAP.\n\n   4 INABILITY TO COMPLY DUE TO STATUTE OR REGULATION.\n\n   If it is impossible for You to comply with any of the terms of this License with respect to some or all of the Covered Code due to statute, judicial order, or regulation then You must: (a) comply with the terms of this License to the maximum extent possible; and (b) describe the limitations and the code they affect. Such description must be included in the LEGAL file described in Section 3.4 and must be included with all distributions of the Source Code. Except to the extent prohibited by statute or regulation, such description must be sufficiently detailed for a recipient of ordinary skill to be able to understand it.\n\n   5 APPLICATION OF THIS LICENSE.\n\n   This License applies to code to which the Initial Developer has attached the notice in Exhibit A and to related Covered Code.\n\n   6 VERSIONS OF THE LICENSE.\n\n      6.1. New Versions.\n\n      Grantor may publish revised and/or new versions of the License from time to time. Each version will be given a distinguishing version number.\n\n      6.2. Effect of New Versions.\n\n      Once Covered Code has been published under a particular version of the License, You may always continue to use it under the terms of that version. You may also choose to use such Covered Code under the terms of any subsequent version of the License.\n\n      6.3. Derivative Works.\n\n      If You create or use a modified version of this License (which you may only do in order to apply it to code which is not already Covered Code governed by this License), You must (a) rename Your license so that the phrase \"gSOAP\" or any confusingly similar phrase do not appear in your license (except to note that you license differs from this License) and (b) otherwise make it clear that Your version of the license contains terms which differ from the gSOAP Public License. (Filling in the name of the Initial Developer, Original Code or Contributor in the notice described in Exhibit A shall not of themselves be deemed to be modifications of this License.)\n\n   7 DISCLAIMER OF WARRANTY.\n\n   COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN \"AS IS\" BASIS, WITHOUT WARRANTY OF ANY KIND, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTABILITY, OF FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT OF THIRD PARTY INTELLECTUAL PROPERTY RIGHTS, AND ANY WARRANTY THAT MAY ARISE BY REASON OF TRADE USAGE, CUSTOM, OR COURSE OF DEALING. WITHOUT LIMITING THE FOREGOING, YOU ACKNOWLEDGE THAT THE SOFTWARE IS PROVIDED \"AS IS\" AND THAT THE AUTHORS DO NOT WARRANT THE SOFTWARE WILL RUN UNINTERRUPTED OR ERROR FREE. LIMITED LIABILITY THE ENTIRE RISK AS TO RESULTS AND PERFORMANCE OF THE SOFTWARE IS ASSUMED BY YOU. UNDER NO CIRCUMSTANCES WILL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES OF ANY KIND OR NATURE WHATSOEVER, WHETHER BASED ON CONTRACT, WARRANTY, TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, ARISING OUT OF OR IN ANY WAY RELATED TO THE SOFTWARE, EVEN IF THE AUTHORS HAVE BEEN ADVISED ON THE POSSIBILITY OF SUCH DAMAGE OR IF SUCH DAMAGE COULD HAVE BEEN REASONABLY FORESEEN, AND NOTWITHSTANDING ANY FAILURE OF ESSENTIAL PURPOSE OF ANY EXCLUSIVE REMEDY PROVIDED. SUCH LIMITATION ON DAMAGES INCLUDES, BUT IS NOT LIMITED TO, DAMAGES FOR LOSS OF GOODWILL, LOST PROFITS, LOSS OF DATA OR SOFTWARE, WORK STOPPAGE, COMPUTER FAILURE OR MALFUNCTION OR IMPAIRMENT OF OTHER GOODS. IN NO EVENT WILL THE AUTHORS BE LIABLE FOR THE COSTS OF PROCUREMENT OF SUBSTITUTE SOFTWARE OR SERVICES. YOU ACKNOWLEDGE THAT THIS SOFTWARE IS NOT DESIGNED FOR USE IN ON-LINE EQUIPMENT IN HAZARDOUS ENVIRONMENTS SUCH AS OPERATION OF NUCLEAR FACILITIES, AIRCRAFT NAVIGATION OR CONTROL, OR LIFE-CRITICAL APPLICATIONS. THE AUTHORS EXPRESSLY DISCLAIM ANY LIABILITY RESULTING FROM USE OF THE SOFTWARE IN ANY SUCH ON-LINE EQUIPMENT IN HAZARDOUS ENVIRONMENTS AND ACCEPTS NO LIABILITY IN RESPECT OF ANY ACTIONS OR CLAIMS BASED ON THE USE OF THE SOFTWARE IN ANY SUCH ON-LINE EQUIPMENT IN HAZARDOUS ENVIRONMENTS BY YOU. FOR PURPOSES OF THIS PARAGRAPH, THE TERM \"LIFE-CRITICAL APPLICATION\" MEANS AN APPLICATION IN WHICH THE FUNCTIONING OR MALFUNCTIONING OF THE SOFTWARE MAY RESULT DIRECTLY OR INDIRECTLY IN PHYSICAL INJURY OR LOSS OF HUMAN LIFE. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER.\n\n   8 TERMINATION.\n\n      8.1. This License and the rights granted hereunder will terminate automatically if You fail to comply with terms herein and fail to cure such breach within 30 days of becoming aware of the breach. All sublicenses to the Covered Code which are properly granted shall survive any termination of this License. Provisions which, by their nature, must remain in effect beyond the termination of this License shall survive.\n\n      8.2.\n\n      8.3. If You assert a patent infringement claim against Participant alleging that such Participant's Contributor Version directly or indirectly infringes any patent where such claim is resolved (such as by license or settlement) prior to the initiation of patent infringement litigation, then the reasonable value of the licenses granted by such Participant under Sections 2.1 or 2.2 shall be taken into account in determining the amount or value of any payment or license.\n\n      8.4. In the event of termination under Sections 8.1 or 8.2 above, all end user license agreements (excluding distributors and resellers) which have been validly granted by You or any distributor hereunder prior to termination shall survive termination.\n\n   9 LIMITATION OF LIABILITY.\n\n   UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER TORT (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL YOU, THE INITIAL DEVELOPER, ANY OTHER CONTRIBUTOR, OR ANY DISTRIBUTOR OF COVERED CODE, OR ANY SUPPLIER OF ANY OF SUCH PARTIES, BE LIABLE TO ANY PERSON FOR ANY INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, COMPUTER FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER COMMERCIAL DAMAGES OR LOSSES, EVEN IF SUCH PARTY SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF LIABILITY SHALL NOT APPLY TO LIABILITY FOR DEATH OR PERSONAL INJURY RESULTING FROM SUCH PARTY'S NEGLIGENCE TO THE EXTENT APPLICABLE LAW PROHIBITS SUCH LIMITATION. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OR LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THIS EXCLUSION AND LIMITATION MAY NOT APPLY TO YOU.\n\n   10 U.S. GOVERNMENT END USERS.\n\n   11 MISCELLANEOUS.\n\n   12 RESPONSIBILITY FOR CLAIMS.\n\n   As between Initial Developer and the Contributors, each party is responsible for claims and damages arising, directly or indirectly, out of its utilization of rights under this License and You agree to work with Initial Developer and Contributors to distribute such responsibility on an equitable basis. Nothing herein is intended or shall be deemed to constitute any admission of liability. \n\n   \n\n   EXHIBIT A.\n\n   \"The contents of this file are subject to the gSOAP Public License Version 1.3 (the \"License\"); you may not use this file except in compliance with the License. You may obtain a copy of the License at\n\n   http://www.cs.fsu.edu/ engelen/soaplicense.html\n\n   Software distributed under the License is distributed on an \"AS IS\" basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the specific language governing rights and limitations under the License.\n\n   The Original Code of the gSOAP Software is: stdsoap.h, stdsoap2.h, stdsoap.c, stdsoap2.c, stdsoap.cpp, stdsoap2.cpp, soapcpp2.h, soapcpp2.c, soapcpp2_lex.l, soapcpp2_yacc.y, error2.h, error2.c, symbol2.c, init2.c, soapdoc2.html, and soapdoc2.pdf, httpget.h, httpget.c, stl.h, stldeque.h, stllist.h, stlvector.h, stlset.h.\n\n   The Initial Developer of the Original Code is Robert A. van Engelen. Portions created by Robert A. van Engelen are Copyright (C) 2001-2004 Robert A. van Engelen, Genivia inc. All Rights Reserved.\n\n   Contributor(s):\n\n   \"________________________.\"\n\n   [Note: The text of this Exhibit A may differ slightly form the text of the notices in the Source Code files of the Original code. You should use the text of this Exhibit A rather than the text found in the Original Code Source Code for Your Modifications.]\n\n   \n\n   EXHIBIT B.\n\n   \"Part of the software embedded in this product is gSOAP software.\n\n   Portions created by gSOAP are Copyright (C) 2001-2009 Robert A. van Engelen, Genivia inc. All Rights Reserved.\n\n   THE SOFTWARE IN THIS PRODUCT WAS IN PART PROVIDED BY GENIVIA INC AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\""],"licenseIds":["gSOAP-1.3b"],"keywords":["version 1 3b","1 3b the","3b the gsoap","public license mpl1","license mpl1 1","mpl1 1 the","1 the sections","the sections that","sections that were","that were deleted","were deleted from","the original mpl1","original mpl1 1","mpl1 1 text","1 text are","text are 1","are 1 0","0 1 2","2 1 c","1 c d","2 2 c","2 c d","c d 8","d 8 2","8 2 b","2 b 10","b 10 and","and 11 section","11 section 3","3 8 was","8 was added","was added the","added the modified","the modified sections","modified sections are","sections are 2","are 2 1","1 b 2","b 2 2","2 b 3","3 2 simplified","2 simplified 3","simplified 3 5","3 5 deleted","5 deleted the","deleted the last","the last sentence","last sentence and","sentence and 3","and 3 6","3 6 simplified","6 simplified this","simplified this license","gsoap software package","software package with","with the exception","the exception of","exception of the","of the soapcpp2","the soapcpp2 and","and wsdl2h source","wsdl2h source code","source code located","code located in","located in gsoap","in gsoap src","gsoap src and","src and gsoap","and gsoap wsdl","gsoap wsdl all","wsdl all code","all code generated","generated by soapcpp2","by soapcpp2 and","and wsdl2h the","wsdl2h the uddi","the uddi source","uddi source code","source code gsoap","code gsoap uddi2","gsoap uddi2 and","uddi2 and the","and the web","the web server","web server sample","server sample source","sample source code","source code samples","code samples webserver","samples webserver to","webserver to use","of these software","these software tools","software tools and","tools and components","and components commercially","components commercially a","commercially a commercial","a commercial license","commercial license is","required and can","obtained from www","from www genivia","www genivia com","genivia com 1","com 1 definitions","0 1 1","software the original","any combination or","combination or portions","software the contributor","c d 3","d 3 distribution","any modification created","modification created by","developer in source","form and are","any contributor 3","contributor 3 6","any contributor if","contributor if you","code as part","a product you","code 3 8","3 8 restrictions","8 restrictions you","remove any product","any product identification","product identification copyright","identification copyright proprietary","copyright proprietary notices","proprietary notices or","notices or labels","or labels from","labels from gsoap","from gsoap 4","gsoap 4 inability","new versions grantor","versions grantor may","grantor may publish","that the phrase","the phrase gsoap","phrase gsoap or","gsoap or any","note that you","that you license","you license differs","from the gsoap","any kind whether","kind whether express","merchantability of fitness","purpose noninfringement of","warranty that may","may arise by","arise by reason","reason of trade","of trade usage","trade usage custom","usage custom or","custom or course","or course of","of dealing without","dealing without limiting","foregoing you acknowledge","is and that","that the authors","the authors do","authors do not","do not warrant","not warrant the","warrant the software","software will run","will run uninterrupted","run uninterrupted or","error free limited","free limited liability","limited liability the","liability the entire","as to results","to results and","results and performance","software is assumed","is assumed by","assumed by you","you under no","no circumstances will","circumstances will the","indirect incidental exemplary","incidental exemplary or","kind or nature","or nature whatsoever","nature whatsoever whether","whatsoever whether based","based on contract","on contract warranty","been advised on","advised on the","on the possibility","damage or if","or if such"]},{"licenseTexts":["Copyright 1986 - 1993, 1998, 2004 Thomas Williams, Colin Kelley\n\nPermission to use, copy, and distribute this software and its documentation for any purpose with or without fee is hereby granted, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation.\n\nPermission to modify the software is granted, but not the right to distribute the complete modified source code. Modifications are to be distributed as patches to the released version. Permission to distribute binaries produced by compiling modified sources is granted, provided you\n\n   1. distribute the corresponding source modifications from the released version in the form of a patch file along with the binaries,\n\n   2. add special version identification to distinguish your version in addition to the base release version number,\n\n   3. provide your name and address as the primary contact for the support of your modified version, and\n\n   4. retain our contact information in regard to use of the base software.\n\nPermission to distribute the released version of the source code along with corresponding source modifications in the form of a patch file is granted with same provisions 2 through 4 for binary distributions.\n\nThis software is provided \"as is\" without express or implied warranty to the extent permitted by applicable law."],"licenseIds":["gnuplot"],"keywords":["copyright 1986 1993","1986 1993 1998","1993 1998 2004","1998 2004 thomas","2004 thomas williams","thomas williams colin","williams colin kelley","colin kelley permission","kelley permission to","is granted but","granted but not","but not the","not the right","distribute the complete","the complete modified","complete modified source","source code modifications","code modifications are","modifications are to","are to be","distributed as patches","to the released","released version permission","version permission to","to distribute binaries","distribute binaries produced","binaries produced by","produced by compiling","by compiling modified","compiling modified sources","modified sources is","sources is granted","granted provided you","provided you 1","you 1 distribute","1 distribute the","distribute the corresponding","source modifications from","modifications from the","from the released","released version in","patch file along","with the binaries","the binaries 2","binaries 2 add","2 add special","add special version","special version identification","version identification to","identification to distinguish","to distinguish your","distinguish your version","your version in","to the base","the base release","base release version","release version number","number 3 provide","3 provide your","provide your name","name and address","and address as","address as the","primary contact for","contact for the","for the support","the support of","support of your","version and 4","and 4 retain","4 retain our","retain our contact","our contact information","contact information in","information in regard","the base software","base software permission","software permission to","distribute the released","along with corresponding","with corresponding source","source modifications in","patch file is","file is granted","is granted with","granted with same","with same provisions","same provisions 2","provisions 2 through","2 through 4","through 4 for","4 for binary","for binary distributions","binary distributions this","distributions this software","implied warranty to","warranty to the","copyright 1986 1993 1998","1986 1993 1998 2004","1993 1998 2004 thomas","1998 2004 thomas williams","2004 thomas williams colin","thomas williams colin kelley","williams colin kelley permission","colin kelley permission to","kelley permission to use","permission to modify the","modify the software is","the software is granted","software is granted but","is granted but not","granted but not the","but not the right","not the right to","right to distribute the","to distribute the complete","distribute the complete modified","the complete modified source","complete modified source code","modified source code modifications","source code modifications are","code modifications are to","modifications are to be","are to be distributed","to be distributed as","be distributed as patches","distributed as patches to","as patches to the","patches to the released","to the released version","the released version permission","released version permission to","version permission to distribute","permission to distribute binaries","to distribute binaries produced","distribute binaries produced by","binaries produced by compiling","produced by compiling modified","by compiling modified sources","compiling modified sources is","modified sources is granted","sources is granted provided","is granted provided you","granted provided you 1","provided you 1 distribute","you 1 distribute the","1 distribute the corresponding","distribute the corresponding source","the corresponding source modifications","corresponding source modifications from","source modifications from the","modifications from the released","from the released version","the released version in","released version in the","version in the form","a patch file along","patch file along with","file along with the","along with the binaries","with the binaries 2","the binaries 2 add","binaries 2 add special","2 add special version","add special version identification","special version identification to","version identification to distinguish","identification to distinguish your","to distinguish your version","distinguish your version in","your version in addition","version in addition to","addition to the base","to the base release","the base release version","base release version number","release version number 3","version number 3 provide","number 3 provide your","3 provide your name","provide your name and","your name and address","name and address as","and address as the","address as the primary","as the primary contact","the primary contact for","primary contact for the","contact for the support","for the support of","the support of your","support of your modified","your modified version and","modified version and 4","version and 4 retain","and 4 retain our","4 retain our contact","retain our contact information","our contact information in","contact information in regard"]},{"licenseTexts":["The SFL License Agreement\n\nThis license agreement covers your use of the iMatix STANDARD FUNCTION LIBRARY (SFL), its source code, documentation, and executable files, hereinafter referred to as \"the Product\".\n\nThe Product is Copyright (c) 1991-2000 iMatix Corporation. You may use it and distribute it according to this following License Agreement. If you do not agree with these terms, please remove the Product from your system. By incorporating the Product in your work or distributing the Product to others you implicitly agree to these license terms.\n\nStatement Of Copyright\n\nThe Product is, and remains, Copyright © 1991-2000 iMatix Corporation, with exception of specific copyrights as noted in the individual source files.\n\nConditions Of Use\n\n   You do not need to provide the source code for the Product as part of your product. However, you must do one of these things to comply with the Product License Agreement:\n\n      1. Provide the source code for Product modules that you use, or\n\n      2. Make your product freely available according to a license similar to the GNU General Public License, or the Perl Artistic License, or\n\n      3. Add this phrase to the documentation for your product: \"This product uses parts of the iMatix SFL, Copyright © 1991-2000 iMatix Corporation \u003chttp://www.imatix.com\u003e\".\n\nRights Of Usage\n\n   You may freely and at no cost use the Product in any project, commercial, academic, military, or private, so long as you respect the License Agreement. The License Agreement does not affect any software except the Product. In particular, any application that uses the Product does not itself fall under the License Agreement.\n\n   You may modify any part of the Product, including sources and documentation, except this License Agreement, which you may not modify.\n\n   You must clearly indicate any modifications at the start of each source file. The user of any modified Product code must know that the source file is not original.\n\n   \n\n   At your discretion, you may rewrite or reuse any part of the Product so that your derived code is not obviously part of the Product. This derived code does not fall under the Product License Agreement directly, but you must include a credit at the start of each source file indicating the original authorship and source of the code, and a statement of copyright as follows:\n\n   \"Parts copyright (c) 1991-2000 iMatix Corporation.\"\n\nRights Of Distribution\n\n   You may freely distribute the Product, or any subset of the Product, by any means. The License, in the form of the file called \"LICENSE.TXT\" must accompany any such distribution.\n\n   You may charge a fee for distributing the Product, for providing a warranty on the Product, for making modifications to the Product, or for any other service provided in relation to the Product. You are not required to ask our permission for any of these activities.\n\n   At no time will iMatix associate itself with any distribution of the Product except that supplied from the Internet site http://www.imatix.com.\n\nDisclaimer Of Warranty\n\n   The Product is provided as free software, in the hope that it will be useful. It is provided \"as-is\", without warranty of any kind, either expressed or implied, including, but not limited to, the implied warranties of merchantability and fitness for a particular purpose. The entire risk as to the quality and performance of the Product is with you. Should the Product prove defective, the full cost of repair, servicing, or correction lies with you."],"licenseIds":["iMatix"],"keywords":["the sfl license","sfl license agreement","license agreement covers","agreement covers your","covers your use","the imatix standard","imatix standard function","standard function library","function library sfl","library sfl its","sfl its source","documentation and executable","executable files hereinafter","files hereinafter referred","hereinafter referred to","as the product","the product the","product the product","product is copyright","imatix corporation you","corporation you may","use it and","it and distribute","distribute it according","it according to","to this following","this following license","following license agreement","license agreement if","terms please remove","please remove the","remove the product","the product from","product from your","from your system","your system by","system by incorporating","by incorporating the","incorporating the product","product in your","your work or","work or distributing","the product to","product to others","others you implicitly","you implicitly agree","implicitly agree to","agree to these","to these license","license terms statement","terms statement of","of copyright the","copyright the product","product is and","is and remains","and remains copyright","remains copyright 1991","imatix corporation with","corporation with exception","with exception of","exception of specific","of specific copyrights","specific copyrights as","copyrights as noted","as noted in","the individual source","individual source files","source files conditions","files conditions of","of use you","use you do","need to provide","the product as","product as part","of your product","your product however","things to comply","agreement 1 provide","1 provide the","code for product","for product modules","product modules that","modules that you","you use or","use or 2","or 2 make","2 make your","make your product","your product freely","product freely available","freely available according","available according to","according to a","a license similar","license similar to","to the gnu","or the perl","the perl artistic","perl artistic license","artistic license or","license or 3","or 3 add","3 add this","add this phrase","this phrase to","phrase to the","documentation for your","your product this","product this product","this product uses","product uses parts","uses parts of","the imatix sfl","imatix sfl copyright","sfl copyright 1991","imatix corporation http","corporation http www","imatix com rights","com rights of","rights of usage","of usage you","usage you may","may freely and","freely and at","no cost use","cost use the","product in any","in any project","any project commercial","project commercial academic","commercial academic military","academic military or","military or private","or private so","private so long","as you respect","you respect the","respect the license","agreement the license","affect any software","any software except","software except the","except the product","product in particular","in particular any","particular any application","any application that","uses the product","the product does","does not itself","not itself fall","itself fall under","may modify any","modify any part","the product including","product including sources","including sources and","sources and documentation","and documentation except","documentation except this","except this license","license agreement which","agreement which you","not modify you","modify you must","clearly indicate any","indicate any modifications","any modifications at","modifications at the","source file the","file the user","user of any","any modified product","modified product code","product code must","code must know","must know that","know that the","the source file","source file is","is not original","not original at","original at your","your discretion you","discretion you may","you may rewrite","may rewrite or","rewrite or reuse","or reuse any","reuse any part","the product so","product so that","so that your","that your derived","your derived code","derived code is","is not obviously","not obviously part","obviously part of","the product this"]},{"licenseTexts":["PNG Reference Library License version 2 --------------------------------------- \n\n   * Copyright (c) 1995-2018 The PNG Reference Library Authors.\n\n   * Copyright (c) 2018 Cosmin Truta.\n\n   * Copyright (c) 2000-2002, 2004, 2006-2018 Glenn Randers-Pehrson.\n\n   * Copyright (c) 1996-1997 Andreas Dilger.\n\n   * Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.\n\nThe software is supplied \"as is\", without warranty of any kind, express or implied, including, without limitation, the warranties of merchantability, fitness for a particular purpose, title, and non-infringement. In no even shall the Copyright owners, or anyone distributing the software, be liable for any damages or other liability, whether in contract, tort or otherwise, arising from, out of, or in connection with the software, or the use or other dealings in the software, even if advised of the possibility of such damage.\n\nPermission is hereby granted to use, copy, modify, and distribute this software, or portions hereof, for any purpose, without fee, subject to the following restrictions:\n\n   1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated, but is not required.\n\n   2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.\n\n   3. This Copyright notice may not be removed or altered from any source or altered source distribution."],"licenseIds":["libpng-2.0"],"keywords":["reference library license","library license version","version 2 copyright","c 1995 2018","1995 2018 the","2018 the png","reference library authors","library authors copyright","authors copyright c","c 2018 cosmin","2018 cosmin truta","cosmin truta copyright","truta copyright c","2000 2002 2004","2002 2004 2006","2004 2006 2018","2006 2018 glenn","2018 glenn randers","randers pehrson copyright","pehrson copyright c","1997 andreas dilger","andreas dilger copyright","dilger copyright c","42 inc the","inc the software","in no even","no even shall","even shall the","the copyright owners","copyright owners or","owners or anyone","png reference library license","reference library license version","library license version 2","license version 2 copyright","version 2 copyright c","2 copyright c 1995","copyright c 1995 2018","c 1995 2018 the","1995 2018 the png","2018 the png reference","png reference library authors","reference library authors copyright","library authors copyright c","authors copyright c 2018","copyright c 2018 cosmin","c 2018 cosmin truta","2018 cosmin truta copyright","cosmin truta copyright c","truta copyright c 2000","c 2000 2002 2004","2000 2002 2004 2006","2002 2004 2006 2018","2004 2006 2018 glenn","2006 2018 glenn randers","2018 glenn randers pehrson","glenn randers pehrson copyright","randers pehrson copyright c","pehrson copyright c 1996","1996 1997 andreas dilger","1997 andreas dilger copyright","andreas dilger copyright c","dilger copyright c 1995","group 42 inc the","42 inc the software","inc the software is","supplied as is without","infringement in no even","in no even shall","no even shall the","even shall the copyright","shall the copyright owners","the copyright owners or","copyright owners or anyone","owners or anyone distributing","in the software even","software or portions hereof","software 3 this copyright","png reference library license version","reference library license version 2","library license version 2 copyright","license version 2 copyright c","version 2 copyright c 1995","2 copyright c 1995 2018","copyright c 1995 2018 the","c 1995 2018 the png","1995 2018 the png reference","2018 the png reference library","the png reference library authors","png reference library authors copyright","reference library authors copyright c","library authors copyright c 2018","authors copyright c 2018 cosmin","copyright c 2018 cosmin truta","c 2018 cosmin truta copyright","2018 cosmin truta copyright c","cosmin truta copyright c 2000","truta copyright c 2000 2002","copyright c 2000 2002 2004","c 2000 2002 2004 2006","2000 2002 2004 2006 2018","2002 2004 2006 2018 glenn","2004 2006 2018 glenn randers","2006 2018 glenn randers pehrson","2018 glenn randers pehrson copyright","glenn randers pehrson copyright c","randers pehrson copyright c 1996","pehrson copyright c 1996 1997","c 1996 1997 andreas dilger","1996 1997 andreas dilger copyright","1997 andreas dilger copyright c","andreas dilger copyright c 1995","dilger copyright c 1995 1996","schalnat group 42 inc the","group 42 inc the software","42 inc the software is","inc the software is supplied","is supplied as is without","supplied as is without warranty","non infringement in no even","infringement in no even shall","in no even shall the","no even shall the copyright","even shall the copyright owners","shall the copyright owners or","the copyright owners or anyone","copyright owners or anyone distributing","owners or anyone distributing the","dealings in the software even","in the software even if","the software even if advised","this software or portions hereof","software or portions hereof for","original software 3 this copyright","software 3 this copyright notice"]},{"licenseTexts":["This library (libselinux) is public domain software, i.e. not copyrighted.\n\nWarranty Exclusion ------------------\n\nYou agree that this software is a non-commercially developed program that may contain \"bugs\" (as that term is used in the industry) and that it may not function as intended. The software is licensed \"as is\". NSA makes no, and hereby expressly disclaims all, warranties, express, implied, statutory, or otherwise with respect to the software, including noninfringement and the implied warranties of merchantability and fitness for a particular purpose.\n\nLimitation of Liability -----------------------\n\nIn no event will NSA be liable for any damages, including loss of data, lost profits, cost of cover, or other special, incidental, consequential, direct or indirect damages arising from the software or the use thereof, however caused and on any theory of liability. This limitation will apply even if NSA has been advised of the possibility of such damage. You acknowledge that this is a reasonable allocation of risk."],"licenseIds":["libselinux-1.0"],"keywords":["this library libselinux","library libselinux is","libselinux is public","is public domain","domain software i","software i e","e not copyrighted","not copyrighted warranty","copyrighted warranty exclusion","warranty exclusion you","exclusion you agree","agree that this","a non commercially","non commercially developed","commercially developed program","developed program that","program that may","may contain bugs","contain bugs as","bugs as that","term is used","in the industry","the industry and","industry and that","may not function","not function as","function as intended","as intended the","intended the software","as is nsa","is nsa makes","nsa makes no","no and hereby","and hereby expressly","hereby expressly disclaims","warranties express implied","software including noninfringement","including noninfringement and","noninfringement and the","and the implied","particular purpose limitation","purpose limitation of","event will nsa","will nsa be","nsa be liable","damages including loss","including loss of","of data lost","data lost profits","lost profits cost","profits cost of","of cover or","cover or other","other special incidental","incidental consequential direct","consequential direct or","indirect damages arising","use thereof however","thereof however caused","liability this limitation","this limitation will","limitation will apply","will apply even","apply even if","even if nsa","if nsa has","nsa has been","that this is","is a reasonable","a reasonable allocation","reasonable allocation of","this library libselinux is","library libselinux is public","libselinux is public domain","is public domain software","public domain software i","domain software i e","software i e not","i e not copyrighted","e not copyrighted warranty","not copyrighted warranty exclusion","copyrighted warranty exclusion you","warranty exclusion you agree","exclusion you agree that","you agree that this","agree that this software","this software is a","software is a non","is a non commercially","a non commercially developed","non commercially developed program","commercially developed program that","developed program that may","program that may contain","that may contain bugs","may contain bugs as","contain bugs as that","bugs as that term","that term is used","term is used in","is used in the","used in the industry","in the industry and","the industry and that","industry and that it","and that it may","it may not function","may not function as","not function as intended","function as intended the","as intended the software","intended the software is","licensed as is nsa","as is nsa makes","is nsa makes no","nsa makes no and","makes no and hereby","no and hereby expressly","and hereby expressly disclaims","hereby expressly disclaims all","expressly disclaims all warranties","all warranties express implied","warranties express implied statutory","statutory or otherwise with","to the software including","the software including noninfringement","software including noninfringement and","including noninfringement and the","noninfringement and the implied","and the implied warranties","a particular purpose limitation","particular purpose limitation of","purpose limitation of liability","no event will nsa","event will nsa be","will nsa be liable","nsa be liable for","any damages including loss","damages including loss of","including loss of data","loss of data lost","of data lost profits","data lost profits cost","lost profits cost of","profits cost of cover","cost of cover or","of cover or other","cover or other special","or other special incidental","other special incidental consequential","special incidental consequential direct","incidental consequential direct or","consequential direct or indirect","or indirect damages arising","indirect damages arising from","arising from the software","or the use thereof","the use thereof however","use thereof however caused","thereof however caused and","theory of liability this","of liability this limitation","liability this limitation will","this limitation will apply","limitation will apply even","will apply even if","apply even if nsa","even if nsa has","if nsa has been","nsa has been advised","acknowledge that this is","that this is a","this is a reasonable","is a reasonable allocation","a reasonable allocation of","reasonable allocation of risk","this library libselinux is public","library libselinux is public domain","libselinux is public domain software","is public domain software i","public domain software i e","domain software i e not","software i e not copyrighted","i e not copyrighted warranty","e not copyrighted warranty exclusion","not copyrighted warranty exclusion you","copyrighted warranty exclusion you agree","warranty exclusion you agree that","exclusion you agree that this","you agree that this software","agree that this software is","that this software is a","this software is a non","software is a non commercially","is a non commercially developed","a non commercially developed program","non commercially developed program that","commercially developed program that may","developed program that may contain","program that may contain bugs"]},{"licenseTexts":["Copyright (c) 1988-1997 Sam Leffler\n\nCopyright (c) 1991-1997 Silicon Graphics, Inc.\n\nPermission to use, copy, modify, distribute, and sell this software and its documentation for any purpose is hereby granted without fee, provided that (i) the above copyright notices and this permission notice appear in all copies of the software and related documentation, and (ii) the names of Sam Leffler and Silicon Graphics may not be used in any advertising or publicity relating to the software without the specific, prior written permission of Sam Leffler and Silicon Graphics.\n\nTHE SOFTWARE IS PROVIDED \"AS-IS\" AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.\n\nIN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE."],"licenseIds":["libtiff"],"keywords":["c 1988 1997","1988 1997 sam","1997 sam leffler","sam leffler copyright","leffler copyright c","c 1991 1997","1991 1997 silicon","1997 silicon graphics","graphics inc permission","provided that i","that i the","i the above","documentation and ii","ii the names","names of sam","silicon graphics may","graphics may not","without the specific","the specific prior","permission of sam","silicon graphics the","graphics the software","implied or otherwise","event shall sam","shall sam leffler","sam leffler or","leffler or silicon","or silicon graphics","silicon graphics be","graphics be liable","profits whether or","or not advised","not advised of","possibility of damage","of damage and","damage and on","copyright c 1988 1997","c 1988 1997 sam","1988 1997 sam leffler","1997 sam leffler copyright","sam leffler copyright c","leffler copyright c 1991","copyright c 1991 1997","c 1991 1997 silicon","1991 1997 silicon graphics","1997 silicon graphics inc","silicon graphics inc permission","graphics inc permission to","fee provided that i","provided that i the","that i the above","i the above copyright","and related documentation and","related documentation and ii","documentation and ii the","and ii the names","ii the names of","the names of sam","names of sam leffler","and silicon graphics may","silicon graphics may not","graphics may not be","publicity relating to the","the software without the","software without the specific","without the specific prior","the specific prior written","written permission of sam","permission of sam leffler","and silicon graphics the","silicon graphics the software","graphics the software is","express implied or otherwise","implied or otherwise including","no event shall sam","event shall sam leffler","shall sam leffler or","sam leffler or silicon","leffler or silicon graphics","or silicon graphics be","silicon graphics be liable","graphics be liable for","or profits whether or","profits whether or not","whether or not advised","or not advised of","not advised of the","the possibility of damage","possibility of damage and","of damage and on","damage and on any","copyright c 1988 1997 sam","c 1988 1997 sam leffler","1988 1997 sam leffler copyright","1997 sam leffler copyright c","sam leffler copyright c 1991","leffler copyright c 1991 1997","copyright c 1991 1997 silicon","c 1991 1997 silicon graphics","1991 1997 silicon graphics inc","1997 silicon graphics inc permission","silicon graphics inc permission to","graphics inc permission to use","without fee provided that i","fee provided that i the","provided that i the above","that i the above copyright","i the above copyright notices","of the software and related","software and related documentation and","and related documentation and ii","related documentation and ii the","documentation and ii the names","and ii the names of","ii the names of sam","the names of sam leffler","names of sam leffler and","leffler and silicon graphics may","and silicon graphics may not","silicon graphics may not be","graphics may not be used","any advertising or publicity relating","or publicity relating to the","publicity relating to the software","relating to the software without","to the software without the","the software without the specific","software without the specific prior","without the specific prior written","the specific prior written permission","prior written permission of sam","written permission of sam leffler","permission of sam leffler and","leffler and silicon graphics the","and silicon graphics the software","silicon graphics the software is","graphics the software is provided","kind express implied or otherwise","express implied or otherwise including","implied or otherwise including without","otherwise including without limitation any","in no event shall sam","no event shall sam leffler","event shall sam leffler or","shall sam leffler or silicon","sam leffler or silicon graphics","leffler or silicon graphics be","or silicon graphics be liable","silicon graphics be liable for","graphics be liable for any","data or profits whether or","or profits whether or not","profits whether or not advised","whether or not advised of","or not advised of the","not advised of the possibility","of the possibility of damage","the possibility of damage and","possibility of damage and on","of damage and on any","damage and on any theory"]},{"licenseTexts":["COPYRIGHT\n\nThe following is a notice of limited availability of the code, and disclaimer which must be included in the prologue of the code and in all source listings of the code.\n\nCopyright Notice\n\n+ 2002 University of Chicago\n\nPermission is hereby granted to use, reproduce, prepare derivative works, and to redistribute to others. This software was authored by:\n\nArgonne National Laboratory Group W. Gropp: (630) 252-4318; FAX: (630) 252-5986; e-mail: gropp@mcs.anl.gov E. Lusk: (630) 252-7852; FAX: (630) 252-5986; e-mail: lusk@mcs.anl.gov Mathematics and Computer Science Division Argonne National Laboratory, Argonne IL 60439\n\nGOVERNMENT LICENSE\n\nPortions of this material resulted from work developed under a U.S. Government Contract and are subject to the following license: the Government is granted for itself and others acting on its behalf a paid-up, nonexclusive, irrevocable worldwide license in this computer software to reproduce, prepare derivative works, and perform publicly and display publicly.\n\nDISCLAIMER\n\nThis computer code material was prepared, in part, as an account of work sponsored by an agency of the United States Government. Neither the United States, nor the University of Chicago, nor any of their employees, makes any warranty express or implied, or assumes any legal liability or responsibility for the accuracy, completeness, or usefulness of any information, apparatus, product, or process disclosed, or represents that its use would not infringe privately owned rights."],"licenseIds":["mpich2"],"keywords":["copyright the following","the following is","following is a","is a notice","notice of limited","of limited availability","limited availability of","availability of the","code and disclaimer","and disclaimer which","disclaimer which must","in the prologue","the prologue of","prologue of the","in all source","all source listings","source listings of","listings of the","the code copyright","code copyright notice","copyright notice 2002","notice 2002 university","2002 university of","of chicago permission","chicago permission is","to others this","others this software","authored by argonne","by argonne national","national laboratory group","laboratory group w","group w gropp","w gropp 630","gropp 630 252","630 252 4318","252 4318 fax","4318 fax 630","e mail gropp","mail gropp mcs","gropp mcs anl","anl gov e","gov e lusk","e lusk 630","lusk 630 252","630 252 7852","252 7852 fax","7852 fax 630","e mail lusk","mail lusk mcs","lusk mcs anl","anl gov mathematics","gov mathematics and","il 60439 government","60439 government license","government license portions","this material resulted","material resulted from","resulted from work","from work developed","work developed under","developed under a","under a u","s government contract","government contract and","contract and are","following license the","license the government","government is granted","is granted for","granted for itself","for itself and","itself and others","others acting on","its behalf a","behalf a paid","a paid up","paid up nonexclusive","up nonexclusive irrevocable","nonexclusive irrevocable worldwide","irrevocable worldwide license","worldwide license in","in this computer","this computer software","computer software to","software to reproduce","works and perform","publicly and display","and display publicly","display publicly disclaimer","publicly disclaimer this","disclaimer this computer","this computer code","computer code material","code material was","material was prepared","was prepared in","prepared in part","part as an","united states nor","states nor the","their employees makes","employees makes any","copyright the following is","the following is a","following is a notice","is a notice of","a notice of limited","notice of limited availability","of limited availability of","limited availability of the","availability of the code","the code and disclaimer","code and disclaimer which","and disclaimer which must","disclaimer which must be","which must be included","included in the prologue","in the prologue of","the prologue of the","prologue of the code","the code and in","code and in all","and in all source","in all source listings","all source listings of","source listings of the","listings of the code","of the code copyright","the code copyright notice","code copyright notice 2002","copyright notice 2002 university","notice 2002 university of","2002 university of chicago","university of chicago permission","of chicago permission is","chicago permission is hereby","redistribute to others this","to others this software","others this software was","was authored by argonne","authored by argonne national","by argonne national laboratory","argonne national laboratory group","national laboratory group w","laboratory group w gropp","group w gropp 630","w gropp 630 252","gropp 630 252 4318","630 252 4318 fax","252 4318 fax 630","4318 fax 630 252","5986 e mail gropp","e mail gropp mcs","mail gropp mcs anl","gropp mcs anl gov","mcs anl gov e","anl gov e lusk","gov e lusk 630","e lusk 630 252","lusk 630 252 7852","630 252 7852 fax","252 7852 fax 630","7852 fax 630 252","5986 e mail lusk","e mail lusk mcs","mail lusk mcs anl","lusk mcs anl gov","mcs anl gov mathematics","anl gov mathematics and","gov mathematics and computer","argonne il 60439 government","il 60439 government license","60439 government license portions","government license portions of","portions of this material","of this material resulted","this material resulted from","material resulted from work","resulted from work developed","from work developed under","work developed under a","developed under a u","under a u s","u s government contract","s government contract and","government contract and are","contract and are subject","the following license the","following license the government","license the government is","the government is granted","government is granted for","is granted for itself","granted for itself and","for itself and others","itself and others acting","and others acting on","others acting on its","on its behalf a","its behalf a paid"]},{"licenseTexts":["psfrag.dtx Copyright (C) 1996 Craig Barratt, Michael C. Grant, and David Carlisle.\n\nAll rights are reserved.\n\nThis system is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. Don't come complaining to us if you modify this file and it doesn't work! If this file is modified by anyone but the authors, those changes and their authors must be explicitly stated HERE."],"licenseIds":["psfrag"],"keywords":["psfrag dtx copyright","dtx copyright c","c 1996 craig","1996 craig barratt","craig barratt michael","barratt michael c","michael c grant","c grant and","grant and david","and david carlisle","david carlisle all","carlisle all rights","all rights are","rights are reserved","reserved this system","this system is","system is distributed","particular purpose don","purpose don t","don t come","t come complaining","come complaining to","complaining to us","to us if","us if you","modify this file","file and it","and it doesn","it doesn t","t work if","file is modified","modified by anyone","by anyone but","anyone but the","but the authors","the authors those","authors those changes","those changes and","and their authors","their authors must","authors must be","must be explicitly","be explicitly stated","explicitly stated here","psfrag dtx copyright c","dtx copyright c 1996","copyright c 1996 craig","c 1996 craig barratt","1996 craig barratt michael","craig barratt michael c","barratt michael c grant","michael c grant and","c grant and david","grant and david carlisle","and david carlisle all","david carlisle all rights","carlisle all rights are","all rights are reserved","rights are reserved this","are reserved this system","reserved this system is","this system is distributed","system is distributed in","a particular purpose don","particular purpose don t","purpose don t come","don t come complaining","t come complaining to","come complaining to us","complaining to us if","to us if you","us if you modify","you modify this file","modify this file and","this file and it","file and it doesn","and it doesn t","it doesn t work","doesn t work if","t work if this","work if this file","if this file is","this file is modified","file is modified by","is modified by anyone","modified by anyone but","by anyone but the","anyone but the authors","but the authors those","the authors those changes","authors those changes and","those changes and their","changes and their authors","and their authors must","their authors must be","authors must be explicitly","must be explicitly stated","be explicitly stated here","psfrag dtx copyright c 1996","dtx copyright c 1996 craig","copyright c 1996 craig barratt","c 1996 craig barratt michael","1996 craig barratt michael c","craig barratt michael c grant","barratt michael c grant and","michael c grant and david","c grant and david carlisle","grant and david carlisle all","and david carlisle all rights","david carlisle all rights are","carlisle all rights are reserved","all rights are reserved this","rights are reserved this system","are reserved this system is","reserved this system is distributed","this system is distributed in","system is distributed in the","for a particular purpose don","a particular purpose don t","particular purpose don t come","purpose don t come complaining","don t come complaining to","t come complaining to us","come complaining to us if","complaining to us if you","to us if you modify","us if you modify this","if you modify this file","you modify this file and","modify this file and it","this file and it doesn","file and it doesn t","and it doesn t work","it doesn t work if","doesn t work if this","t work if this file","work if this file is","if this file is modified","this file is modified by","file is modified by anyone","is modified by anyone but","modified by anyone but the","by anyone but the authors","anyone but the authors those","but the authors those changes","the authors those changes and","authors those changes and their","those changes and their authors","changes and their authors must","and their authors must be","their authors must be explicitly","authors must be explicitly stated","must be explicitly stated here"]},{"licenseTexts":["PS Utilities Package The constituent files of this package listed below are copyright (C) 1991-1995 Angus J. C. Duggan.\n\nLICENSE Makefile.msc Makefile.nt Makefile.os2\n\nMakefile.unix README config.h descrip.mms\n\nepsffit.c epsffit.man extractres.man extractres.pl\n\nfixdlsrps.man fixdlsrps.pl fixfmps.man fixfmps.pl\n\nfixmacps.man fixmacps.pl fixpsditps.man fixpsditps.pl\n\nfixpspps.man fixpspps.pl fixscribeps.man fixscribeps.pl\n\nfixtpps.man fixtpps.pl fixwfwps.man fixwfwps.pl\n\nfixwpps.man fixwpps.pl fixwwps.man fixwwps.pl\n\ngetafm getafm.man includeres.man includeres.pl\n\nmaketext patchlev.h psbook.c psbook.man\n\npserror.c pserror.h psmerge.man psmerge.pl\n\npsnup.c psnup.man psresize.c psresize.man\n\npsselect.c psselect.man psspec.c psspec.h\n\npstops.c pstops.man psutil.c psutil.h\n\nshowchar\n\nThey may be copied and used for any purpose (including distribution as part of a for-profit product), provided:\n\n   1) The original attribution of the programs is clearly displayed in the product and/or documentation, even if the programs are modified and/or renamed as part of the product.\n\n   2) The original source code of the programs is provided free of charge (except for reasonable distribution costs). For a definition of reasonable distribution costs, see the Gnu General Public License or Larry Wall's Artistic License (provided with the Perl 4 kit). The GPL and Artistic License in NO WAY affect this license; they are merely used as examples of the spirit in which it is intended.\n\n   3) These programs are provided \"as-is\". No warranty or guarantee of their fitness for any particular task is provided. Use of these programs is completely at your own risk.\n\nBasically, I don't mind how you use the programs so long as you acknowledge the author, and give people the originals if they want them."],"licenseIds":["psutils"],"keywords":["ps utilities package","utilities package the","package the constituent","the constituent files","constituent files of","this package listed","package listed below","listed below are","below are copyright","1991 1995 angus","1995 angus j","angus j c","j c duggan","c duggan license","duggan license makefile","license makefile msc","makefile msc makefile","msc makefile nt","makefile nt makefile","nt makefile os2","makefile os2 makefile","os2 makefile unix","makefile unix readme","unix readme config","readme config h","config h descrip","h descrip mms","descrip mms epsffit","mms epsffit c","epsffit c epsffit","c epsffit man","epsffit man extractres","man extractres man","extractres man extractres","man extractres pl","extractres pl fixdlsrps","pl fixdlsrps man","fixdlsrps man fixdlsrps","man fixdlsrps pl","fixdlsrps pl fixfmps","pl fixfmps man","fixfmps man fixfmps","man fixfmps pl","fixfmps pl fixmacps","pl fixmacps man","fixmacps man fixmacps","man fixmacps pl","fixmacps pl fixpsditps","pl fixpsditps man","fixpsditps man fixpsditps","man fixpsditps pl","fixpsditps pl fixpspps","pl fixpspps man","fixpspps man fixpspps","man fixpspps pl","fixpspps pl fixscribeps","pl fixscribeps man","fixscribeps man fixscribeps","man fixscribeps pl","fixscribeps pl fixtpps","pl fixtpps man","fixtpps man fixtpps","man fixtpps pl","fixtpps pl fixwfwps","pl fixwfwps man","fixwfwps man fixwfwps","man fixwfwps pl","fixwfwps pl fixwpps","pl fixwpps man","fixwpps man fixwpps","man fixwpps pl","fixwpps pl fixwwps","pl fixwwps man","fixwwps man fixwwps","man fixwwps pl","fixwwps pl getafm","pl getafm getafm","getafm getafm man","getafm man includeres","man includeres man","includeres man includeres","man includeres pl","includeres pl maketext","pl maketext patchlev","maketext patchlev h","patchlev h psbook","h psbook c","psbook c psbook","c psbook man","psbook man pserror","man pserror c","pserror c pserror","c pserror h","pserror h psmerge","h psmerge man","psmerge man psmerge","man psmerge pl","psmerge pl psnup","pl psnup c","psnup c psnup","c psnup man","psnup man psresize","man psresize c","psresize c psresize","c psresize man","psresize man psselect","man psselect c","psselect c psselect","c psselect man","psselect man psspec","man psspec c","psspec c psspec","c psspec h","psspec h pstops","h pstops c","pstops c pstops","c pstops man","pstops man psutil","man psutil c","psutil c psutil","c psutil h","psutil h showchar","h showchar they","showchar they may","they may be","copied and used","and used for","purpose including distribution","including distribution as","distribution as part","of a for","a for profit","for profit product","profit product provided","product provided 1","provided 1 the","1 the original","the original attribution","original attribution of","programs is clearly","is clearly displayed","clearly displayed in","displayed in the","product and or","or documentation even","if the programs","the programs are","programs are modified","are modified and","modified and or","and or renamed","or renamed as","renamed as part","the product 2","product 2 the","2 the original","programs is provided","is provided free","provided free of","of charge except","charge except for","except for reasonable","for reasonable distribution","distribution costs for","costs for a","for a definition","definition of reasonable","of reasonable distribution","distribution costs see","costs see the","license or larry","or larry wall","larry wall s","wall s artistic","s artistic license","artistic license provided","the perl 4","perl 4 kit","4 kit the","kit the gpl","the gpl and","gpl and artistic","and artistic license","artistic license in","license in no","in no way","no way affect","way affect this","affect this license","they are merely","are merely used","merely used as","used as examples","as examples of","examples of the","of the spirit","the spirit in","spirit in which","is intended 3","intended 3 these"]},{"licenseTexts":["ORIGINAL LICENSE: This software is (c) Copyright 1992 by Panagiotis Tsirigotis\n\nThe author (Panagiotis Tsirigotis) grants permission to use, copy, and distribute this software and its documentation for any purpose and without fee, provided that the above copyright notice extant in files in this distribution is not removed from files included in any redistribution and that this copyright notice is also included in any redistribution.\n\nModifications to this software may be distributed, either by distributing the modified software or by distributing patches to the original software, under the following additional terms:\n\n   1. The version number will be modified as follows:\n\n      a. The first 3 components of the version number (i.e \u003cnumber\u003e.\u003cnumber\u003e.\u003cnumber\u003e) will remain unchanged.\n\n      b. A new component will be appended to the version number to indicate the modification level. The form of this component is up to the author of the modifications.\n\n   2. The author of the modifications will include his/her name by appending it along with the new version number to this file and will be responsible for any wrong behavior of the modified software.\n\nThe author makes no representations about the suitability of this software for any purpose. It is provided \"as is\" without any express or implied warranty.\n\nModifications: Version: 2.1.8.7-current Copyright 1998-2001 by Rob Braun\n\nSensor Addition Version: 2.1.8.9pre14a Copyright 2001 by Steve Grubb\n\nThis is an exerpt from an email I recieved from the original author, allowing xinetd as maintained by me (Rob Braun), to use the higher version numbers:\n\nI appreciate your maintaining the version string guidelines as specified in the copyright. But I did not mean them to last as long as they did.\n\nSo, if you want, you may use any 2.N.* (N \u003e= 3) version string for future xinetd versions that you release. Note that I am excluding the 2.2.* line; using that would only create confusion. Naming the next release 2.3.0 would put to rest the confusion about 2.2.1 and 2.1.8.*."],"licenseIds":["xinetd"],"keywords":["original license this","software is c","is c copyright","c copyright 1992","copyright 1992 by","1992 by panagiotis","by panagiotis tsirigotis","panagiotis tsirigotis the","tsirigotis the author","the author panagiotis","author panagiotis tsirigotis","panagiotis tsirigotis grants","tsirigotis grants permission","copyright notice extant","notice extant in","extant in files","in files in","distribution is not","not removed from","removed from files","from files included","any redistribution and","redistribution and that","that this copyright","notice is also","is also included","also included in","any redistribution modifications","redistribution modifications to","be distributed either","distributed either by","either by distributing","by distributing the","modified software or","software or by","or by distributing","by distributing patches","distributing patches to","following additional terms","additional terms 1","terms 1 the","1 the version","version number will","number will be","will be modified","modified as follows","a the first","the first 3","first 3 components","3 components of","version number i","number i e","i e number","e number number","number number number","number number will","number will remain","will remain unchanged","remain unchanged b","unchanged b a","b a new","a new component","new component will","component will be","will be appended","be appended to","appended to the","number to indicate","to indicate the","indicate the modification","the modification level","modification level the","level the form","this component is","component is up","the modifications 2","modifications 2 the","2 the author","the modifications will","modifications will include","will include his","include his her","his her name","her name by","name by appending","by appending it","appending it along","it along with","new version number","number to this","file and will","for any wrong","any wrong behavior","wrong behavior of","modified software the","software the author","the author makes","author makes no","implied warranty modifications","warranty modifications version","modifications version 2","1 8 7","8 7 current","7 current copyright","current copyright 1998","copyright 1998 2001","1998 2001 by","2001 by rob","by rob braun","rob braun sensor","braun sensor addition","sensor addition version","addition version 2","1 8 9pre14a","8 9pre14a copyright","9pre14a copyright 2001","copyright 2001 by","2001 by steve","by steve grubb","steve grubb this","grubb this is","is an exerpt","an exerpt from","exerpt from an","from an email","an email i","email i recieved","i recieved from","recieved from the","original author allowing","author allowing xinetd","allowing xinetd as","xinetd as maintained","maintained by me","by me rob","me rob braun","rob braun to","braun to use","use the higher","the higher version","higher version numbers","version numbers i","numbers i appreciate","i appreciate your","appreciate your maintaining","your maintaining the","maintaining the version","the version string","version string guidelines","string guidelines as","guidelines as specified","as specified in","the copyright but","copyright but i","but i did","i did not","did not mean","not mean them","mean them to","them to last","to last as","last as long","as they did","they did so","did so if","want you may","may use any","use any 2","any 2 n","2 n n","n n 3","n 3 version","3 version string","version string for","string for future","for future xinetd","future xinetd versions","xinetd versions that","versions that you","you release note","release note that","note that i","that i am","i am excluding","am excluding the","excluding the 2","the 2 2","2 2 line","2 line using","line using that","using that would","that would only","would only create","only create confusion","create confusion naming","confusion naming the","naming the next","the next release","next release 2","release 2 3"]},{"licenseTexts":["LICENSE FOR THE Extreme! Lab PullParser Copyright (c) 2002 The Trustees of Indiana University. All rights reserved.\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n   1) All redistributions of source code must retain the above copyright notice, the list of authors in the original source code, this list of conditions and the disclaimer listed in this license;\n\n   2) All redistributions in binary form must reproduce the above copyright notice, this list of conditions and the disclaimer listed in this license in the documentation and/or other materials provided with the distribution;\n\n   3) Any documentation included with all redistributions must include the following acknowledgement:\n\n   \"This product includes software developed by the Indiana University Extreme! Lab. For further information please visit http://www.extreme.indiana.edu/\"\n\n   Alternatively, this acknowledgment may appear in the software itself, and wherever such third-party acknowledgments normally appear.\n\n   4) The name \"Indiana Univeristy\" and \"Indiana Univeristy Extreme! Lab\" shall not be used to endorse or promote products derived from this software without prior written permission from Indiana University. For written permission, please contact http://www.extreme.indiana.edu/.\n\n   5) Products derived from this software may not use \"Indiana Univeristy\" name nor may \"Indiana Univeristy\" appear in their name, without prior written permission of the Indiana University. Indiana University provides no reassurances that the source code provided does not infringe the patent or any other intellectual property rights of any other entity. Indiana University disclaims any liability to any recipient for claims brought by any other entity based on infringement of intellectual property rights or otherwise.\n\nLICENSEE UNDERSTANDS THAT SOFTWARE IS PROVIDED \"AS IS\" FOR WHICH NO WARRANTIES AS TO CAPABILITIES OR ACCURACY ARE MADE. INDIANA UNIVERSITY GIVES NO WARRANTIES AND MAKES NO REPRESENTATION THAT SOFTWARE IS FREE OF INFRINGEMENT OF THIRD PARTY PATENT, COPYRIGHT, OR OTHER PROPRIETARY RIGHTS. INDIANA UNIVERSITY MAKES NO WARRANTIES THAT SOFTWARE IS FREE FROM \"BUGS\", \"VIRUSES\", \"TROJAN HORSES\", \"TRAP DOORS\", \"WORMS\", OR OTHER HARMFUL CODE. LICENSEE ASSUMES THE ENTIRE RISK AS TO THE PERFORMANCE OF SOFTWARE AND/OR ASSOCIATED MATERIALS, AND TO THE PERFORMANCE AND VALIDITY OF INFORMATION GENERATED USING SOFTWARE."],"licenseIds":["xpp"],"keywords":["for the extreme","the extreme lab","extreme lab pullparser","lab pullparser copyright","pullparser copyright c","c 2002 the","2002 the trustees","indiana university all","by the indiana","indiana university extreme","university extreme lab","extreme lab for","lab for further","for further information","further information please","information please visit","visit http www","indiana edu alternatively","edu alternatively this","alternatively this acknowledgment","the name indiana","name indiana univeristy","indiana univeristy and","univeristy and indiana","and indiana univeristy","indiana univeristy extreme","univeristy extreme lab","extreme lab shall","lab shall not","permission from indiana","from indiana university","university for written","please contact http","contact http www","indiana edu 5","edu 5 products","not use indiana","use indiana univeristy","indiana univeristy name","univeristy name nor","name nor may","nor may indiana","may indiana univeristy","indiana univeristy appear","univeristy appear in","of the indiana","indiana university indiana","university indiana university","indiana university provides","university provides no","provides no reassurances","other entity indiana","entity indiana university","indiana university disclaims","university disclaims any","are made indiana","made indiana university","indiana university gives","university gives no","warranties and makes","proprietary rights indiana","rights indiana university","indiana university makes","university makes no","license for the extreme","for the extreme lab","the extreme lab pullparser","extreme lab pullparser copyright","lab pullparser copyright c","pullparser copyright c 2002","copyright c 2002 the","c 2002 the trustees","2002 the trustees of","of indiana university all","indiana university all rights","developed by the indiana","by the indiana university","the indiana university extreme","indiana university extreme lab","university extreme lab for","extreme lab for further","lab for further information","for further information please","further information please visit","information please visit http","please visit http www","visit http www extreme","extreme indiana edu alternatively","indiana edu alternatively this","edu alternatively this acknowledgment","alternatively this acknowledgment may","4 the name indiana","the name indiana univeristy","name indiana univeristy and","indiana univeristy and indiana","univeristy and indiana univeristy","and indiana univeristy extreme","indiana univeristy extreme lab","univeristy extreme lab shall","extreme lab shall not","lab shall not be","written permission from indiana","permission from indiana university","from indiana university for","indiana university for written","university for written permission","permission please contact http","please contact http www","contact http www extreme","extreme indiana edu 5","indiana edu 5 products","edu 5 products derived","software may not use","may not use indiana","not use indiana univeristy","use indiana univeristy name","indiana univeristy name nor","univeristy name nor may","name nor may indiana","nor may indiana univeristy","may indiana univeristy appear","indiana univeristy appear in","univeristy appear in their","permission of the indiana","of the indiana university","the indiana university indiana","indiana university indiana university","university indiana university provides","indiana university provides no","university provides no reassurances","provides no reassurances that","any other entity indiana","other entity indiana university","entity indiana university disclaims","indiana university disclaims any","university disclaims any liability","accuracy are made indiana","are made indiana university","made indiana university gives","indiana university gives no","university gives no warranties","gives no warranties and","no warranties and makes","warranties and makes no","and makes no representation","other proprietary rights indiana","proprietary rights indiana university","rights indiana university makes","indiana university makes no","university makes no warranties","makes no warranties that","license for the extreme lab","for the extreme lab pullparser","the extreme lab pullparser copyright","extreme lab pullparser copyright c","lab pullparser copyright c 2002","pullparser copyright c 2002 the","copyright c 2002 the trustees","c 2002 the trustees of","2002 the trustees of indiana","trustees of indiana university all","of indiana university all rights","indiana university all rights reserved","software developed by the indiana","developed by the indiana university","by the indiana university extreme","the indiana university extreme lab","indiana university extreme lab for","university extreme lab for further","extreme lab for further information","lab for further information please","for further information please visit","further information please visit http","information please visit http www","please visit http www extreme","visit http www extreme indiana","www extreme indiana edu alternatively","extreme indiana edu alternatively this","indiana edu alternatively this acknowledgment","edu alternatively this acknowledgment may","alternatively this acknowledgment may appear","appear 4 the name indiana","4 the name indiana univeristy","the name indiana univeristy and","name indiana univeristy and indiana","indiana univeristy and indiana univeristy","univeristy and indiana univeristy extreme","and indiana univeristy extreme lab","indiana univeristy extreme lab shall","univeristy extreme lab shall not","extreme lab shall not be","lab shall not be used","prior written permission from indiana","written permission from indiana university","permission from indiana university for","from indiana university for written","indiana university for written permission","university for written permission please","written permission please contact http","permission please contact http www"]},{"licenseTexts":["Copyright (c) 2002-2007 Charlie Poole\n\nCopyright (c) 2002-2004 James W. Newkirk, Michael C. Two, Alexei A. Vorontsov\n\nCopyright (c) 2000-2002 Philip A. Craig\n\nThis software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software.\n\nPermission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions:\n\n   1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment (see the following) in the product documentation is required.\n\n   Portions Copyright (c) 2002-2007 Charlie Poole or Copyright (c) 2002-2004 James W. Newkirk, Michael C. Two, Alexei A. Vorontsov or Copyright (c) 2000-2002 Philip A. Craig\n\n   2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.\n\n   3. This notice may not be removed or altered from any source distribution."],"licenseIds":["zlib-acknowledgement"],"keywords":["poole copyright c","a vorontsov copyright","vorontsov copyright c","a vorontsov or","vorontsov or copyright","2007 charlie poole copyright","charlie poole copyright c","poole copyright c 2002","alexei a vorontsov copyright","a vorontsov copyright c","vorontsov copyright c 2000","required portions copyright c","portions copyright c 2002","2007 charlie poole or","poole or copyright c","or copyright c 2002","alexei a vorontsov or","a vorontsov or copyright","vorontsov or copyright c","or copyright c 2000","2002 2007 charlie poole copyright","2007 charlie poole copyright c","charlie poole copyright c 2002","poole copyright c 2002 2004","two alexei a vorontsov copyright","alexei a vorontsov copyright c","a vorontsov copyright c 2000","vorontsov copyright c 2000 2002","2002 philip a craig this","is required portions copyright c","required portions copyright c 2002","portions copyright c 2002 2007","2002 2007 charlie poole or","2007 charlie poole or copyright","charlie poole or copyright c","poole or copyright c 2002","or copyright c 2002 2004","two alexei a vorontsov or","alexei a vorontsov or copyright","a vorontsov or copyright c","vorontsov or copyright c 2000","or copyright c 2000 2002","2002 philip a craig 2"]}]` +) diff --git a/pkg/detector.go b/pkg/detector.go new file mode 100644 index 0000000..66dc29b --- /dev/null +++ b/pkg/detector.go @@ -0,0 +1,112 @@ +// SPDX-License-Identifier: AGPL-3.0 + +package pkg + +import ( + "encoding/base64" + "encoding/json" + "github.com/boyter/lc/pkg/levenshtein" + "math" + "strings" +) + +type LicenceDetector struct { + Database []License +} + +func NewLicenceDetector() *LicenceDetector { + l := new(LicenceDetector) + l.LoadDatabase() + return l +} + +type License struct { + LicenseTexts []string `json:"licenseTexts"` // examples of text that we have for these licences + LicenseIds []string `json:"licenseIds"` // SPDX ids where licences are considered identical + Keywords []string `json:"keywords"` // keywords that are unique and can be used to identify this group of licences +} + +// LoadDatabase will initialize the database values and should only be called once such as in an init +func (l *LicenceDetector) LoadDatabase() { + if len(l.Database) != 0 { + return + } + + data, _ := base64.StdEncoding.DecodeString(database_keywords) + _ = json.Unmarshal(data, &l.Database) +} + +type LicenseGuess struct { + Name string +} + +func (l *LicenceDetector) Guess(filename string, content string) []LicenseGuess { + if IsLicenceFile(filename) { + // Check if the filename matches on of the common licences in which case return that + // since it seems unlikely someone would add a file called LGPL-2.0 without + // it actually being that licence + for _, li := range commonLicences { + if strings.EqualFold(filename, li) { + return []LicenseGuess{ + { + Name: li, + }, + } + } + } + + // at this point we are confident we have a licence file, but we don't know which one, so lets + // start by firstly assuming there is only 1 license in the file + // and then try to determine what is actually inside the file + var bestGuess License + bestMatch := math.MaxInt + con := []rune(compareOptimize(content)) + for _, li := range l.Database { + for _, lic := range li.LicenseTexts { + m := levenshtein.DistanceForStrings([]rune(compareOptimize(lic)), con, levenshtein.DefaultOptions) + if m < bestMatch { + bestGuess = li + bestMatch = m + } + } + } + + if len(bestGuess.LicenseIds) != 0 { + return []LicenseGuess{ + { + Name: bestGuess.LicenseIds[0], + }, + } + } + + return nil + } + + if IsReadmeFile(filename) { + // at this point we are confident we have a licence file, but we don't know which one, so lets + // start by firstly assuming there is only 1 license in the file + // and then try to determine what is actually inside the file + var bestGuess License + bestMatch := math.MaxInt + con := []rune(compareOptimize(content)) + for _, li := range l.Database { + for _, lic := range li.LicenseTexts { + m := levenshtein.DistanceForStrings([]rune(compareOptimize(lic)), con, levenshtein.DefaultOptions) + if m < bestMatch { + bestGuess = li + bestMatch = m + } + } + } + + if len(bestGuess.LicenseIds) != 0 { + return []LicenseGuess{ + { + Name: bestGuess.LicenseIds[0], + }, + } + } + } + + return nil +} diff --git a/pkg/detector_test.go b/pkg/detector_test.go new file mode 100644 index 0000000..9ba5776 --- /dev/null +++ b/pkg/detector_test.go @@ -0,0 +1,171 @@ +// SPDX-License-Identifier: AGPL-3.0 + +package pkg + +import ( + "reflect" + "testing" +) + +func TestLicenceDetector_LoadDatabase(t *testing.T) { + tests := []struct { + name string + }{ + { + name: "load", + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + l := &LicenceDetector{} + l.LoadDatabase() + if len(l.Database) == 0 { + t.Errorf("LicenceDetector.LoadDatabase() database is empty") + } + + if len(l.Database[0].LicenseIds) == 0 { + t.Errorf("LicenceDetector.LoadDatabase() database license ids is empty") + } + }) + } +} + +func TestLicenceDetector_GuessFilenameLogic(t *testing.T) { + type args struct { + filename string + content string + } + tests := []struct { + name string + args args + want []LicenseGuess + }{ + { + name: "Unlicense", + args: args{ + filename: "unlicense", + content: "", + }, + want: []LicenseGuess{ + { + Name: "Unlicense", + }, + }, + }, + { + name: "LGPL-2.0", + args: args{ + filename: "LGPL-2.0", + content: "", + }, + want: []LicenseGuess{ + { + Name: "LGPL-2.0", + }, + }, + }, + { + name: "MIT", + args: args{ + filename: "license", + content: mitLicence, + }, + want: []LicenseGuess{ + { + Name: "MIT", + }, + }, + }, + { + name: "ISC", + args: args{ + filename: "license", + content: iscLicense, + }, + want: []LicenseGuess{ + { + Name: "ISC", + }, + }, + }, + { + name: "Unlicense 2", + args: args{ + filename: "license", + content: unlicense, + }, + want: []LicenseGuess{ + { + Name: "Unlicense", + }, + }, + }, + { + name: "BSD-2-Clause", + args: args{ + filename: "BSD-2-Clause", + content: unlicense, + }, + want: []LicenseGuess{ + { + Name: "BSD-2-Clause", + }, + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + l := NewLicenceDetector() + if got := l.Guess(tt.args.filename, tt.args.content); !reflect.DeepEqual(got, tt.want) { + t.Errorf("Guess() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestLicenceDetector_GuessFilenameReadmeLogic(t *testing.T) { + type args struct { + filename string + content string + } + tests := []struct { + name string + args args + want []LicenseGuess + }{ + { + name: "README Unlicence", + args: args{ + filename: "README.md", + content: unlicense, + }, + want: []LicenseGuess{ + { + Name: "Unlicense", + }, + }, + }, + { + name: "README MIT", + args: args{ + filename: "README.md", + content: mitLicence, + }, + want: []LicenseGuess{ + { + Name: "MIT", + }, + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + l := NewLicenceDetector() + if got := l.Guess(tt.args.filename, tt.args.content); !reflect.DeepEqual(got, tt.want) { + t.Errorf("Guess() = %v, want %v", got, tt.want) + } + }) + } +} diff --git a/pkg/levenshtein/levenshtein.go b/pkg/levenshtein/levenshtein.go new file mode 100755 index 0000000..1d53ea6 --- /dev/null +++ b/pkg/levenshtein/levenshtein.go @@ -0,0 +1,257 @@ +// Taken from https://github.com/texttheater/golang-levenshtein as its under MIT licence + +// This package implements the Levenshtein algorithm for computing the +// similarity between two strings. The central function is MatrixForStrings, +// which computes the Levenshtein matrix. The functions DistanceForMatrix, +// EditScriptForMatrix and RatioForMatrix read various interesting properties +// off the matrix. The package also provides the convenience functions +// DistanceForStrings, EditScriptForStrings and RatioForStrings for going +// directly from two strings to the property of interest. +package levenshtein + +import ( + "fmt" + "io" + "os" +) + +type EditOperation int + +const ( + Ins = iota + Del + Sub + Match +) + +type EditScript []EditOperation + +type MatchFunction func(rune, rune) bool + +// IdenticalRunes is the default MatchFunction: it checks whether two runes are +// identical. +func IdenticalRunes(a rune, b rune) bool { + return a == b +} + +type Options struct { + InsCost int + DelCost int + SubCost int + Matches MatchFunction +} + +// DefaultOptions is the default options without substitution: insertion cost +// is 1, deletion cost is 1, substitution cost is 2 (meaning insert and delete +// will be used instead), and two runes match iff they are identical. +var DefaultOptions Options = Options{ + InsCost: 1, + DelCost: 1, + SubCost: 2, + Matches: IdenticalRunes, +} + +// DefaultOptionsWithSub is the default options with substitution: insertion +// cost is 1, deletion cost is 1, substitution cost is 1, and two runes match +// iff they are identical. +var DefaultOptionsWithSub Options = Options{ + InsCost: 1, + DelCost: 1, + SubCost: 1, + Matches: IdenticalRunes, +} + +func (operation EditOperation) String() string { + if operation == Match { + return "match" + } else if operation == Ins { + return "ins" + } else if operation == Sub { + return "sub" + } + return "del" +} + +// DistanceForStrings returns the edit distance between source and target. +// +// It has a runtime proportional to len(source) * len(target) and memory use +// proportional to len(target). +func DistanceForStrings(source []rune, target []rune, op Options) int { + // Note: This algorithm is a specialization of MatrixForStrings. + // MatrixForStrings returns the full edit matrix. However, we only need a + // single value (see DistanceForMatrix) and the main loop of the algorithm + // only uses the current and previous row. As such we create a 2D matrix, + // but with height 2 (enough to store current and previous row). + height := len(source) + 1 + width := len(target) + 1 + matrix := make([][]int, 2) + + // Initialize trivial distances (from/to empty string). That is, fill + // the left column and the top row with row/column indices multiplied + // by deletion/insertion cost. + for i := 0; i < 2; i++ { + matrix[i] = make([]int, width) + matrix[i][0] = i * op.DelCost + } + for j := 1; j < width; j++ { + matrix[0][j] = j * op.InsCost + } + + // Fill in the remaining cells: for each prefix pair, choose the + // (edit history, operation) pair with the lowest cost. + for i := 1; i < height; i++ { + cur := matrix[i%2] + prev := matrix[(i-1)%2] + cur[0] = i * op.DelCost + for j := 1; j < width; j++ { + delCost := prev[j] + op.DelCost + matchSubCost := prev[j-1] + if !op.Matches(source[i-1], target[j-1]) { + matchSubCost += op.SubCost + } + insCost := cur[j-1] + op.InsCost + cur[j] = min(delCost, min(matchSubCost, insCost)) + } + } + return matrix[(height-1)%2][width-1] +} + +// DistanceForMatrix reads the edit distance off the given Levenshtein matrix. +func DistanceForMatrix(matrix [][]int) int { + return matrix[len(matrix)-1][len(matrix[0])-1] +} + +// RatioForStrings returns the Levenshtein ratio for the given strings. The +// ratio is computed as follows: +// +// (sourceLength + targetLength - distance) / (sourceLength + targetLength) +func RatioForStrings(source []rune, target []rune, op Options) float64 { + matrix := MatrixForStrings(source, target, op) + return RatioForMatrix(matrix) +} + +// RatioForMatrix returns the Levenshtein ratio for the given matrix. The ratio +// is computed as follows: +// +// (sourceLength + targetLength - distance) / (sourceLength + targetLength) +func RatioForMatrix(matrix [][]int) float64 { + sourcelength := len(matrix) - 1 + targetlength := len(matrix[0]) - 1 + sum := sourcelength + targetlength + + if sum == 0 { + return 0 + } + + dist := DistanceForMatrix(matrix) + return float64(sum-dist) / float64(sum) +} + +// MatrixForStrings generates a 2-D array representing the dynamic programming +// table used by the Levenshtein algorithm, as described e.g. here: +// http://www.let.rug.nl/kleiweg/lev/ +// The reason for putting the creation of the table into a separate function is +// that it cannot only be used for reading of the edit distance between two +// strings, but also e.g. to backtrace an edit script that provides an +// alignment between the characters of both strings. +func MatrixForStrings(source []rune, target []rune, op Options) [][]int { + // Make a 2-D matrix. Rows correspond to prefixes of source, columns to + // prefixes of target. Cells will contain edit distances. + // Cf. http://www.let.rug.nl/~kleiweg/lev/levenshtein.html + height := len(source) + 1 + width := len(target) + 1 + matrix := make([][]int, height) + + // Initialize trivial distances (from/to empty string). That is, fill + // the left column and the top row with row/column indices multiplied + // by deletion/insertion cost. + for i := 0; i < height; i++ { + matrix[i] = make([]int, width) + matrix[i][0] = i * op.DelCost + } + for j := 1; j < width; j++ { + matrix[0][j] = j * op.InsCost + } + + // Fill in the remaining cells: for each prefix pair, choose the + // (edit history, operation) pair with the lowest cost. + for i := 1; i < height; i++ { + for j := 1; j < width; j++ { + delCost := matrix[i-1][j] + op.DelCost + matchSubCost := matrix[i-1][j-1] + if !op.Matches(source[i-1], target[j-1]) { + matchSubCost += op.SubCost + } + insCost := matrix[i][j-1] + op.InsCost + matrix[i][j] = min(delCost, min(matchSubCost, + insCost)) + } + } + //LogMatrix(source, target, matrix) + return matrix +} + +// EditScriptForStrings returns an optimal edit script to turn source into +// target. +func EditScriptForStrings(source []rune, target []rune, op Options) EditScript { + return backtrace(len(source), len(target), + MatrixForStrings(source, target, op), op) +} + +// EditScriptForMatrix returns an optimal edit script based on the given +// Levenshtein matrix. +func EditScriptForMatrix(matrix [][]int, op Options) EditScript { + return backtrace(len(matrix)-1, len(matrix[0])-1, matrix, op) +} + +// WriteMatrix writes a visual representation of the given matrix for the given +// strings to the given writer. +func WriteMatrix(source []rune, target []rune, matrix [][]int, writer io.Writer) { + fmt.Fprintf(writer, " ") + for _, targetRune := range target { + fmt.Fprintf(writer, " %c", targetRune) + } + fmt.Fprintf(writer, "\n") + fmt.Fprintf(writer, " %2d", matrix[0][0]) + for j := range target { + fmt.Fprintf(writer, " %2d", matrix[0][j+1]) + } + fmt.Fprintf(writer, "\n") + for i, sourceRune := range source { + fmt.Fprintf(writer, "%c %2d", sourceRune, matrix[i+1][0]) + for j := range target { + fmt.Fprintf(writer, " %2d", matrix[i+1][j+1]) + } + fmt.Fprintf(writer, "\n") + } +} + +// LogMatrix writes a visual representation of the given matrix for the given +// strings to os.Stderr. This function is deprecated, use +// WriteMatrix(source, target, matrix, os.Stderr) instead. +func LogMatrix(source []rune, target []rune, matrix [][]int) { + WriteMatrix(source, target, matrix, os.Stderr) +} + +func backtrace(i int, j int, matrix [][]int, op Options) EditScript { + if i > 0 && matrix[i-1][j]+op.DelCost == matrix[i][j] { + return append(backtrace(i-1, j, matrix, op), Del) + } + if j > 0 && matrix[i][j-1]+op.InsCost == matrix[i][j] { + return append(backtrace(i, j-1, matrix, op), Ins) + } + if i > 0 && j > 0 && matrix[i-1][j-1]+op.SubCost == matrix[i][j] { + return append(backtrace(i-1, j-1, matrix, op), Sub) + } + if i > 0 && j > 0 && matrix[i-1][j-1] == matrix[i][j] { + return append(backtrace(i-1, j-1, matrix, op), Match) + } + return []EditOperation{} +} + +func min(a int, b int) int { + if b < a { + return b + } + return a +} diff --git a/pkg/levenshtein/levenshtein_test.go b/pkg/levenshtein/levenshtein_test.go new file mode 100755 index 0000000..e392e4a --- /dev/null +++ b/pkg/levenshtein/levenshtein_test.go @@ -0,0 +1,296 @@ +package levenshtein + +import ( + "fmt" + "os" + "testing" +) + +var testCases = []struct { + source string + target string + options Options + distance int + ratio float64 + script EditScript +}{ + { + source: "", + target: "a", + options: DefaultOptions, + distance: 1, + ratio: 0.0, + script: EditScript{Ins}, + }, + { + source: "a", + target: "aa", + options: DefaultOptions, + distance: 1, + ratio: 0.6666666666666666, + script: EditScript{Match, Ins}, + }, + { + source: "a", + target: "aaa", + options: DefaultOptions, + distance: 2, + ratio: 0.5, + script: EditScript{Match, Ins, Ins}, + }, + { + source: "", + target: "", + options: DefaultOptions, + distance: 0, + ratio: 0, + script: EditScript{}, + }, + { + source: "a", + target: "b", + options: DefaultOptions, + distance: 2, + ratio: 0, + script: EditScript{Ins, Del}, + }, + { + source: "aaa", + target: "aba", + options: DefaultOptions, + distance: 2, + ratio: 0.6666666666666666, + script: EditScript{Match, Ins, Match, Del}, + }, + { + source: "aaa", + target: "ab", + options: DefaultOptions, + distance: 3, + ratio: 0.4, + script: EditScript{Match, Ins, Del, Del}, + }, + { + source: "a", + target: "a", + options: DefaultOptions, + distance: 0, + ratio: 1, + script: EditScript{Match}, + }, + { + source: "ab", + target: "ab", + options: DefaultOptions, + distance: 0, + ratio: 1, + script: EditScript{Match, Match}, + }, + { + source: "a", + target: "", + options: DefaultOptions, + distance: 1, + ratio: 0, + script: EditScript{Del}, + }, + { + source: "aa", + target: "a", + options: DefaultOptions, + distance: 1, + ratio: 0.6666666666666666, + script: EditScript{Match, Del}, + }, + { + source: "aaa", + target: "a", + options: DefaultOptions, + distance: 2, + ratio: 0.5, + script: EditScript{Match, Del, Del}, + }, + { + source: "kitten", + target: "sitting", + options: DefaultOptions, + distance: 5, + ratio: 0.6153846153846154, + script: EditScript{ + Ins, + Del, + Match, + Match, + Match, + Ins, + Del, + Match, + Ins, + }, + }, + { + source: "kitten", + target: "sitting", + options: DefaultOptionsWithSub, + distance: 3, + ratio: 0.7692307692307693, + script: EditScript{ + Sub, + Match, + Match, + Match, + Sub, + Match, + Ins, + }, + }, + { + source: "Orange", + target: "Apple", + options: DefaultOptionsWithSub, + distance: 5, + ratio: 0.5454545454545454, + script: EditScript{ + Sub, + Sub, + Sub, + Sub, + Del, + Match, + }, + }, + { + source: "me", + target: "meme", + options: Options{ + InsCost: 2, + DelCost: 1, + SubCost: 3, + Matches: IdenticalRunes, + }, + distance: 4, + ratio: 0.3333333333333333, + script: EditScript{ + Match, + Match, + Ins, + Ins, + }, + }, +} + +func TestDistanceForStrings(t *testing.T) { + for _, testCase := range testCases { + distance := DistanceForStrings( + []rune(testCase.source), + []rune(testCase.target), + testCase.options) + if distance != testCase.distance { + t.Log( + "Distance between", + testCase.source, + "and", + testCase.target, + "computed as", + distance, + ", should be", + testCase.distance) + t.Fail() + } + // DistanceForMatrix(MatrixForStrings()) should calculate the same + // value as DistanceForStrings. + distance = DistanceForMatrix(MatrixForStrings( + []rune(testCase.source), + []rune(testCase.target), + testCase.options)) + if distance != testCase.distance { + t.Log( + "Distance between", + testCase.source, + "and", + testCase.target, + "computed as", + distance, + ", should be", + testCase.distance) + t.Fail() + } + } +} + +func TestRatio(t *testing.T) { + for _, testCase := range testCases { + ratio := RatioForStrings( + []rune(testCase.source), + []rune(testCase.target), + testCase.options) + if ratio != testCase.ratio { + t.Log( + "Ratio between", + testCase.source, + "and", + testCase.target, + "computed as", + ratio, + ", should be", + testCase.ratio) + t.Fail() + } + } +} + +func TestEditScriptForStrings(t *testing.T) { + for _, testCase := range testCases { + script := EditScriptForStrings( + []rune(testCase.source), + []rune(testCase.target), + testCase.options) + if !equal(script, testCase.script) { + t.Log( + "Edit script from", + testCase.source, + "to", + testCase.target, + "computed as", + script, + ", should be", + testCase.script) + t.Fail() + } + } +} + +func equal(a, b EditScript) bool { + for i := range a { + if a[i] != b[i] { + return false + } + } + return true +} + +func ExampleDistanceForStrings() { + source := "a" + target := "aa" + distance := DistanceForStrings([]rune(source), []rune(target), DefaultOptions) + fmt.Printf(`Distance between "%s" and "%s" computed as %d`, source, target, distance) + // Output: Distance between "a" and "aa" computed as 1 +} + +func ExampleWriteMatrix() { + source := []rune("neighbor") + target := []rune("Neighbour") + matrix := MatrixForStrings(source, target, DefaultOptions) + WriteMatrix(source, target, matrix, os.Stdout) + // Output: + // N e i g h b o u r + // 0 1 2 3 4 5 6 7 8 9 + // n 1 2 3 4 5 6 7 8 9 10 + // e 2 3 2 3 4 5 6 7 8 9 + // i 3 4 3 2 3 4 5 6 7 8 + // g 4 5 4 3 2 3 4 5 6 7 + // h 5 6 5 4 3 2 3 4 5 6 + // b 6 7 6 5 4 3 2 3 4 5 + // o 7 8 7 6 5 4 3 2 3 4 + // r 8 9 8 7 6 5 4 3 4 3 +} diff --git a/pkg/license_test.go b/pkg/license_test.go new file mode 100644 index 0000000..73a3b16 --- /dev/null +++ b/pkg/license_test.go @@ -0,0 +1,64 @@ +// SPDX-License-Identifier: AGPL-3.0 + +package pkg + +var mitLicence = `MIT License + +Copyright (c) 2021 Ben Boyter + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice (including the next paragraph) shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +` + +var iscLicense = `The license for honk and components is generally ISC or compatible. + +Individual source files are licensed per license at the top. + +Distributed components and dependenices in the vendor directory should have +compatible licenses. + +Files without explicit licenses and the conglomeration as a whole is subject +to the license below. + +// Copyright (c) 2019 Ted Unangst +// +// Permission to use, copy, modify, and distribute this software for any +// purpose with or without fee is hereby granted, provided that the above +// copyright notice and this permission notice appear in all copies. +// +// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.` + +var unlicense = `This is free and unencumbered software released into the public domain. + +Anyone is free to copy, modify, publish, use, compile, sell, or +distribute this software, either in source code form or as a compiled +binary, for any purpose, commercial or non-commercial, and by any +means. + +In jurisdictions that recognize copyright laws, the author or authors +of this software dedicate any and all copyright interest in the +software to the public domain. We make this dedication for the benefit +of the public at large and to the detriment of our heirs and +successors. We intend this dedication to be an overt act of +relinquishment in perpetuity of all present and future rights to this +software under copyright law. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR +OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. + +For more information, please refer to +` diff --git a/vendor/github.com/boyter/gocodewalker/README.md b/vendor/github.com/boyter/gocodewalker/README.md index dbe8ec6..a52c1aa 100644 --- a/vendor/github.com/boyter/gocodewalker/README.md +++ b/vendor/github.com/boyter/gocodewalker/README.md @@ -3,7 +3,15 @@ [![Go Report Card](https://goreportcard.com/badge/github.com/boyter/gocodewalker)](https://goreportcard.com/report/github.com/boyter/gocodewalker) [![Str Count Badge](https://sloc.xyz/github/boyter/gocodewalker/)](https://github.com/boyter/gocodewalker/) -Library to help with walking of code directories in Go +Library to help with walking of code directories in Go. + +The problem. You want to walk the directories of a code repository. You want to respect .gitignore and .ignore files, and +some are nested. This library is the answer. + + - Designed to walk code repositories or find the root of them. + - By default, respects both .gitignore and .ignore files (can be disabled) and nested ones for accuracy + - Has configurable options for skipping files based on regex, extension or general match + - Uses readdir to provide as fast as possible file walking NB this was moved from go-code-walker due to the name being annoying and to ensure it has a unique package name. Should still be drop in replaceable so long as you refer to the new package name. @@ -15,7 +23,7 @@ or looking for the root directory assuming already in a git project. Example of usage, -``` +```go fileListQueue := make(chan *gocodewalker.File, 100) fileWalker := gocodewalker.NewFileWalker(".", fileListQueue) @@ -40,8 +48,20 @@ for f := range fileListQueue { The above by default will recursively add files to the fileListQueue respecting both .ignore and .gitignore files if found, and only adding files with the go extension into the queue. +You can also run the walker in parallel with the results intermixed if required, + +```go +fileListQueue := make(chan *gocodewalker.File, 100) + +fileWalker := gocodewalker.NewParallelFileWalker([]string{".", "someotherdir"}, fileListQueue) +go fileWalker.Start() + +for f := range fileListQueue { + fmt.Println(f.Location) +} +``` + All code is dual-licenced as either MIT or Unlicence. -Note that as an Australian I cannot put this into the public domain, hence the choice most liberal licences I can find. ### Error Handler @@ -50,7 +70,7 @@ and decide if the walker should continue to process, or return. The simplest handler is the below, which if set will swallow all errors and continue as best it can. -``` +```go errorHandler := func(e error) bool { return true } @@ -59,7 +79,7 @@ fileWalker.SetErrorHandler(errorHandler) If you wanted to return on errors you could use the following. -``` +```go errorHandler := func(e error) bool { return false } @@ -69,7 +89,7 @@ fileWalker.SetErrorHandler(errorHandler) If you wanted to terminate walking on an error you could use the following, which would cause it to return the error, and then terminate all walking. This might be desirable where any error indicates a total failure. -``` +```go errorHandler := func(e error) bool { fileWalker.Terminate() return false @@ -77,11 +97,6 @@ errorHandler := func(e error) bool { fileWalker.SetErrorHandler(errorHandler) ``` - -### Package - -Packaging is done through https://goreleaser.com/ - ### Testing Done through unit/integration tests. Otherwise see https://github.com/svent/gitignore-test @@ -92,4 +107,4 @@ See `./cmd/gocodewalker/main.go` for an example of how to implement and validate Details on how gitignores work -https://stackoverflow.com/questions/71735516/proper-way-to-setup-multiple-gitignore-files-in-nested-folders-of-a-repository \ No newline at end of file +https://stackoverflow.com/questions/71735516/proper-way-to-setup-multiple-gitignore-files-in-nested-folders-of-a-repository diff --git a/vendor/github.com/boyter/gocodewalker/file.go b/vendor/github.com/boyter/gocodewalker/file.go index b8e62f1..a33f7f5 100644 --- a/vendor/github.com/boyter/gocodewalker/file.go +++ b/vendor/github.com/boyter/gocodewalker/file.go @@ -10,6 +10,7 @@ import ( "bytes" "errors" "github.com/boyter/gocodewalker/go-gitignore" + "golang.org/x/sync/errgroup" "os" "path" "path/filepath" @@ -32,10 +33,13 @@ type File struct { Filename string } +var semaphoreCount = 8 + type FileWalker struct { fileListQueue chan *File errorsHandler func(error) bool // If returns true will continue to process where possible, otherwise returns if possible directory string + directories []string LocationExcludePattern []string // Case-sensitive patterns which exclude directory/file matches IncludeDirectory []string ExcludeDirectory []string // Paths to always ignore such as .git,.svn and .hg @@ -55,6 +59,8 @@ type FileWalker struct { IncludeHidden bool // Should hidden files and directories be included/walked osOpen func(name string) (*os.File, error) osReadFile func(name string) ([]byte, error) + countingSemaphore chan bool + semaphoreCount int } // NewFileWalker constructs a filewalker, which will walk the supplied directory @@ -83,6 +89,52 @@ func NewFileWalker(directory string, fileListQueue chan *File) *FileWalker { IncludeHidden: false, osOpen: os.Open, osReadFile: os.ReadFile, + countingSemaphore: make(chan bool, semaphoreCount), + semaphoreCount: semaphoreCount, + } +} + +// NewParallelFileWalker constructs a filewalker, which will walk the supplied directories in parallel +// and output File results to the supplied queue as it finds them +func NewParallelFileWalker(directories []string, fileListQueue chan *File) *FileWalker { + return &FileWalker{ + fileListQueue: fileListQueue, + errorsHandler: func(e error) bool { return true }, // a generic one that just swallows everything + directories: directories, + LocationExcludePattern: nil, + IncludeDirectory: nil, + ExcludeDirectory: nil, + IncludeFilename: nil, + ExcludeFilename: nil, + IncludeDirectoryRegex: nil, + ExcludeDirectoryRegex: nil, + IncludeFilenameRegex: nil, + ExcludeFilenameRegex: nil, + AllowListExtensions: nil, + ExcludeListExtensions: nil, + walkMutex: sync.Mutex{}, + terminateWalking: false, + isWalking: false, + IgnoreIgnoreFile: false, + IgnoreGitIgnore: false, + IncludeHidden: false, + osOpen: os.Open, + osReadFile: os.ReadFile, + countingSemaphore: make(chan bool, semaphoreCount), + semaphoreCount: semaphoreCount, + } +} + +// SetConcurrency sets the concurrency when walking +// which controls the number of goroutines that +// walk directories concurrently +// by default it is set to 8 +// must be a whole integer greater than 0 +func (f *FileWalker) SetConcurrency(i int) { + f.walkMutex.Lock() + defer f.walkMutex.Unlock() + if i >= 1 { + f.semaphoreCount = i } } @@ -122,7 +174,27 @@ func (f *FileWalker) Start() error { f.isWalking = true f.walkMutex.Unlock() - err := f.walkDirectoryRecursive(f.directory, []gitignore.GitIgnore{}, []gitignore.GitIgnore{}) + // we now set the counting semaphore based on the count + // done here because it should not change while walking + f.countingSemaphore = make(chan bool, semaphoreCount) + + var err error + if len(f.directories) != 0 { + eg := errgroup.Group{} + for _, directory := range f.directories { + d := directory // capture var + eg.Go(func() error { + return f.walkDirectoryRecursive(0, d, []gitignore.GitIgnore{}, []gitignore.GitIgnore{}) + }) + } + + err = eg.Wait() + } else { + if f.directory != "" { + err = f.walkDirectoryRecursive(0, f.directory, []gitignore.GitIgnore{}, []gitignore.GitIgnore{}) + } + } + close(f.fileListQueue) f.walkMutex.Lock() @@ -132,7 +204,14 @@ func (f *FileWalker) Start() error { return err } -func (f *FileWalker) walkDirectoryRecursive(directory string, gitignores []gitignore.GitIgnore, ignores []gitignore.GitIgnore) error { +func (f *FileWalker) walkDirectoryRecursive(iteration int, directory string, gitignores []gitignore.GitIgnore, ignores []gitignore.GitIgnore) error { + if iteration == 1 { + f.countingSemaphore <- true + defer func() { + <-f.countingSemaphore + }() + } + // NB have to call unlock not using defer because method is recursive // and will deadlock if not done manually f.walkMutex.Lock() @@ -152,7 +231,7 @@ func (f *FileWalker) walkDirectoryRecursive(directory string, gitignores []gitig } defer d.Close() - foundFiles, err := d.ReadDir(-1) + foundFiles, err := d.Readdir(-1) if err != nil { // nothing we can do with this so return nil and process as best we can if f.errorsHandler(err) { @@ -161,8 +240,8 @@ func (f *FileWalker) walkDirectoryRecursive(directory string, gitignores []gitig return err } - files := []os.DirEntry{} - dirs := []os.DirEntry{} + files := []os.FileInfo{} + dirs := []os.FileInfo{} // We want to break apart the files and directories from the // return as we loop over them differently and this avoids some @@ -358,6 +437,9 @@ func (f *FileWalker) walkDirectoryRecursive(directory string, gitignores []gitig } } + // if we are the 1st iteration IE not the root, we run in parallel + wg := sync.WaitGroup{} + // Now we process the directories after hopefully giving the // channel some files to process for _, dir := range dirs { @@ -447,13 +529,23 @@ func (f *FileWalker) walkDirectoryRecursive(directory string, gitignores []gitig } } - err = f.walkDirectoryRecursive(joined, gitignores, ignores) - if err != nil { - return err + if iteration == 0 { + wg.Add(1) + go func(iteration int, directory string, gitignores []gitignore.GitIgnore, ignores []gitignore.GitIgnore) { + _ = f.walkDirectoryRecursive(iteration+1, joined, gitignores, ignores) + wg.Done() + }(iteration, joined, gitignores, ignores) + } else { + err = f.walkDirectoryRecursive(iteration+1, joined, gitignores, ignores) + if err != nil { + return err + } } } } + wg.Wait() + return nil } diff --git a/vendor/github.com/boyter/gocodewalker/go-gitignore/gitignore.go b/vendor/github.com/boyter/gocodewalker/go-gitignore/gitignore.go index 52face7..e627d3e 100644 --- a/vendor/github.com/boyter/gocodewalker/go-gitignore/gitignore.go +++ b/vendor/github.com/boyter/gocodewalker/go-gitignore/gitignore.go @@ -8,6 +8,7 @@ import ( "path/filepath" "runtime" "strings" + "sync" ) // use an empty GitIgnore for cached lookups @@ -242,12 +243,25 @@ func (i *ignore) Match(path string) Match { return i.Absolute(_path, _isdir) } // Match() +var matchIsDirMutex = sync.Mutex{} +var matchIsDirCache = map[string]string{} + func (i *ignore) MatchIsDir(path string, _isdir bool) Match { + // ensure we have the absolute path for the given file - _path, _err := filepath.Abs(path) - if _err != nil { - i._errors(NewError(_err, Position{})) - return nil + matchIsDirMutex.Lock() + _path, ok := matchIsDirCache[path] + matchIsDirMutex.Unlock() + if !ok { + var _err error + _path, _err = filepath.Abs(path) + if _err != nil { + i._errors(NewError(_err, Position{})) + return nil + } + matchIsDirMutex.Lock() + matchIsDirCache[path] = _path + matchIsDirMutex.Unlock() } // attempt to match the absolute path diff --git a/vendor/github.com/boyter/gocodewalker/hidden.go b/vendor/github.com/boyter/gocodewalker/hidden.go index 07b16d1..2a8347f 100644 --- a/vendor/github.com/boyter/gocodewalker/hidden.go +++ b/vendor/github.com/boyter/gocodewalker/hidden.go @@ -9,6 +9,6 @@ import ( ) // IsHidden Returns true if file is hidden -func IsHidden(file os.DirEntry, directory string) (bool, error) { +func IsHidden(file os.FileInfo, directory string) (bool, error) { return file.Name()[0:1] == ".", nil } diff --git a/vendor/golang.org/x/sync/LICENSE b/vendor/golang.org/x/sync/LICENSE new file mode 100644 index 0000000..6a66aea --- /dev/null +++ b/vendor/golang.org/x/sync/LICENSE @@ -0,0 +1,27 @@ +Copyright (c) 2009 The Go Authors. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/vendor/golang.org/x/sync/PATENTS b/vendor/golang.org/x/sync/PATENTS new file mode 100644 index 0000000..7330990 --- /dev/null +++ b/vendor/golang.org/x/sync/PATENTS @@ -0,0 +1,22 @@ +Additional IP Rights Grant (Patents) + +"This implementation" means the copyrightable works distributed by +Google as part of the Go project. + +Google hereby grants to You a perpetual, worldwide, non-exclusive, +no-charge, royalty-free, irrevocable (except as stated in this section) +patent license to make, have made, use, offer to sell, sell, import, +transfer and otherwise run, modify and propagate the contents of this +implementation of Go, where such license applies only to those patent +claims, both currently owned or controlled by Google and acquired in +the future, licensable by Google that are necessarily infringed by this +implementation of Go. This grant does not include claims that would be +infringed only as a consequence of further modification of this +implementation. If you or your agent or exclusive licensee institute or +order or agree to the institution of patent litigation against any +entity (including a cross-claim or counterclaim in a lawsuit) alleging +that this implementation of Go or any code incorporated within this +implementation of Go constitutes direct or contributory patent +infringement, or inducement of patent infringement, then any patent +rights granted to you under this License for this implementation of Go +shall terminate as of the date such litigation is filed. diff --git a/vendor/golang.org/x/sync/errgroup/errgroup.go b/vendor/golang.org/x/sync/errgroup/errgroup.go new file mode 100644 index 0000000..948a3ee --- /dev/null +++ b/vendor/golang.org/x/sync/errgroup/errgroup.go @@ -0,0 +1,135 @@ +// Copyright 2016 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package errgroup provides synchronization, error propagation, and Context +// cancelation for groups of goroutines working on subtasks of a common task. +// +// [errgroup.Group] is related to [sync.WaitGroup] but adds handling of tasks +// returning errors. +package errgroup + +import ( + "context" + "fmt" + "sync" +) + +type token struct{} + +// A Group is a collection of goroutines working on subtasks that are part of +// the same overall task. +// +// A zero Group is valid, has no limit on the number of active goroutines, +// and does not cancel on error. +type Group struct { + cancel func(error) + + wg sync.WaitGroup + + sem chan token + + errOnce sync.Once + err error +} + +func (g *Group) done() { + if g.sem != nil { + <-g.sem + } + g.wg.Done() +} + +// WithContext returns a new Group and an associated Context derived from ctx. +// +// The derived Context is canceled the first time a function passed to Go +// returns a non-nil error or the first time Wait returns, whichever occurs +// first. +func WithContext(ctx context.Context) (*Group, context.Context) { + ctx, cancel := withCancelCause(ctx) + return &Group{cancel: cancel}, ctx +} + +// Wait blocks until all function calls from the Go method have returned, then +// returns the first non-nil error (if any) from them. +func (g *Group) Wait() error { + g.wg.Wait() + if g.cancel != nil { + g.cancel(g.err) + } + return g.err +} + +// Go calls the given function in a new goroutine. +// It blocks until the new goroutine can be added without the number of +// active goroutines in the group exceeding the configured limit. +// +// The first call to return a non-nil error cancels the group's context, if the +// group was created by calling WithContext. The error will be returned by Wait. +func (g *Group) Go(f func() error) { + if g.sem != nil { + g.sem <- token{} + } + + g.wg.Add(1) + go func() { + defer g.done() + + if err := f(); err != nil { + g.errOnce.Do(func() { + g.err = err + if g.cancel != nil { + g.cancel(g.err) + } + }) + } + }() +} + +// TryGo calls the given function in a new goroutine only if the number of +// active goroutines in the group is currently below the configured limit. +// +// The return value reports whether the goroutine was started. +func (g *Group) TryGo(f func() error) bool { + if g.sem != nil { + select { + case g.sem <- token{}: + // Note: this allows barging iff channels in general allow barging. + default: + return false + } + } + + g.wg.Add(1) + go func() { + defer g.done() + + if err := f(); err != nil { + g.errOnce.Do(func() { + g.err = err + if g.cancel != nil { + g.cancel(g.err) + } + }) + } + }() + return true +} + +// SetLimit limits the number of active goroutines in this group to at most n. +// A negative value indicates no limit. +// +// Any subsequent call to the Go method will block until it can add an active +// goroutine without exceeding the configured limit. +// +// The limit must not be modified while any goroutines in the group are active. +func (g *Group) SetLimit(n int) { + if n < 0 { + g.sem = nil + return + } + if len(g.sem) != 0 { + panic(fmt.Errorf("errgroup: modify limit while %v goroutines in the group are still active", len(g.sem))) + } + g.sem = make(chan token, n) +} diff --git a/vendor/golang.org/x/sync/errgroup/go120.go b/vendor/golang.org/x/sync/errgroup/go120.go new file mode 100644 index 0000000..f93c740 --- /dev/null +++ b/vendor/golang.org/x/sync/errgroup/go120.go @@ -0,0 +1,13 @@ +// Copyright 2023 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +//go:build go1.20 + +package errgroup + +import "context" + +func withCancelCause(parent context.Context) (context.Context, func(error)) { + return context.WithCancelCause(parent) +} diff --git a/vendor/golang.org/x/sync/errgroup/pre_go120.go b/vendor/golang.org/x/sync/errgroup/pre_go120.go new file mode 100644 index 0000000..88ce334 --- /dev/null +++ b/vendor/golang.org/x/sync/errgroup/pre_go120.go @@ -0,0 +1,14 @@ +// Copyright 2023 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +//go:build !go1.20 + +package errgroup + +import "context" + +func withCancelCause(parent context.Context) (context.Context, func(error)) { + ctx, cancel := context.WithCancel(parent) + return ctx, func(error) { cancel() } +} diff --git a/vendor/modules.txt b/vendor/modules.txt index c2c2241..56110a8 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -1,7 +1,7 @@ # github.com/BobuSumisu/aho-corasick v1.0.3 ## explicit; go 1.14 github.com/BobuSumisu/aho-corasick -# github.com/boyter/gocodewalker v1.1.0 +# github.com/boyter/gocodewalker v1.3.3 ## explicit; go 1.20 github.com/boyter/gocodewalker github.com/boyter/gocodewalker/go-gitignore @@ -23,3 +23,6 @@ github.com/tealeg/xlsx # github.com/texttheater/golang-levenshtein v0.0.0-20180516184445-d188e65d659e ## explicit github.com/texttheater/golang-levenshtein/levenshtein +# golang.org/x/sync v0.7.0 +## explicit; go 1.18 +golang.org/x/sync/errgroup