CRASHLYTICS AGREEMENT

Last Updated: July 23, 2018

This Crashlytics Agreement (“Agreement”) is entered into by Crashlytics (defined as either: (a)
Google Ireland Limited, with offices at Gordon House, Barrow Street, Dublin 4, Ireland, if Your
principal place of business (for entities) or place of residence (for individuals) is in any country
within Europe, the Middle East, or Africa ("EMEA"), (b) Google Asia Pacific Pte. Ltd., with offices
at 8 Marina View Asia Square 1 #30-01 Singapore 018960, if Your principal place of business
(for entities) or place of residence (for individuals) is in any country within the Asia Pacific region
("APAC"), or (c) Google LLC, with offices at 1600 Amphitheatre Parkway, Mountain View,
California 94043, if Your principal place of business (for entities) or place of residence (for
individuals) is in any country in the world other than those in EMEA and APAC) and you
(“Developer” or “You”) and governs your access and use of www.crashlytics.com and the
Crashlytics crash reporting and beta testing solution (collectively, the “Services” as more fully
described below). If You are accessing or using the Services on behalf of a company or other
legal entity, You represent and warrant that You are an authorized representative of that entity
and have the authority to bind such entity to this Agreement, in which case the terms
“Developer” and “You” shall refer to such entity. You and Crashlytics hereby agree as follows:
YOUR RIGHT TO ACCESS AND USE THE SERVICES IS EXPRESSLY CONDITIONED ON
ACCEPTANCE OF THIS AGREEMENT. BY ACCESSING OR USING THE SERVICES, YOU
AGREE TO BE BOUND BY THIS AGREEMENT. IF YOU ARE ACCESSING OR USING THE
SERVICES ON BEHALF OF YOUR EMPLOYER OR ANOTHER ENTITY (“ENTITY”), YOU
AGREE TO PROVIDE CRASHLYTICS WITH THE NAME OF THE ENTITY AND OBTAIN
CRASHLYTICS'S APPROVAL TO USE THE SOFTWARE ON YOUR BEHALF AND BEHALF
OF THE ENTITY AND YOU AGREE TO REMAIN RESPONSIBLE AND LIABLE FOR YOUR
AND SUCH ENTITY'S COMPLIANCE WITH THIS AGREEMENT. FURTHER, YOU
REPRESENT AND WARRANT THAT: (I) YOU ARE THE AUTHORIZED AGENT OF THE
APPLICABLE ENTITY AND HAVE THE LEGAL AUTHORITY TO ENTER INTO THE
AGREEMENT ON BEHALF OF YOURSELF AND THE ENTITY, AND (II) YOU HAVE
OBTAINED, ON BEHALF OF YOURSELF AND THE ENTITY (IF APPLICABLE), ALL
NECESSARY RIGHTS, WAIVERS, CONSENTS AND PERMISSIONS NECESSARY TO
COLLECT, USE, STORE, AND SHARE USER INFORMATION IN CONNECTION WITH THE
SOFTWARE. Effective November 20, 2015, this Agreement does not cover www.answers.io or
the related “Answers” service, which is a software development kit and associated services
focused on analysis and computation of the behavior and usage of mobile applications,
including app analytics, event tracking, and conversion tracking. If you use Answers, then
please consult the Answers Agreement, which is the contract governing your use of Answers. If
you have questions regarding this Agreement, please contact Crashlytics at
support@crashlytics.com.

SECTION 1. OVERVIEW OF THE SERVICES

1.1 The Services provide a reporting solution for developers of mobile applications , including
publicly released mobile applications (“Application(s)”), and facilitates Developers’ ability to
invite certain designated users (“Beta Tester(s)”) to test mobile applications that have not yet
been publicly released (“Beta Application(s)”). The Services provide information to Developers
about the functioning of Applications and Beta Applications they own or manage, including, but
not limited to, information about how and under what circumstances such applications crashed
and how many users interact with such applications and how they do so.

SECTION 2. SPECIFIC TERMS FOR DEVELOPERS

2.1 Service and Access Credentials. Developer will provide reasonable cooperation,
assistance, information and access to Crashlytics as may be necessary to initiate Developer’s
use of the Services. During the Term, and subject to Developer’s compliance with all terms and
conditions of this Agreement, Crashlytics will provide Developer with access to the Services. As
part of the implementation process, Developer will identify a user name and password that will
be used to set up Developer’s account. Developer will not share its user name or password with
any third party and will be responsible and liable for the acts or omissions of any person who
accesses the Services using passwords or access procedures provided to Developer.
Crashlytics reserves the right to refuse registration of, or to suspend or cancel, login IDs used by
Developer to access the Services for any reason, including if Developer violates the terms and
conditions set forth in this Agreement.

2.2 License to Developer. During the Term, and subject to all terms and conditions of this
Agreement (as a condition to the grants below), Crashlytics grants Developer and Developer
accepts a nonexclusive, nontransferable right and license (without right to sublicense) to: (a)
access and use the Services, solely for the purpose of accessing and downloading the Software
(defined below) and assessing the performance of its own Applications and Beta Applications
for Developer’s internal business purposes; and (b) download, install and use a reasonable
number of copies of the Crashlytics software development kit (the “SDK”) and any tools
provided as part of the SDK, including, but not limited to, any plugins (collectively, the
“Software”) solely for the integration of the Software into an Application or Beta Application.
Developer may use the Services and the Software solely for the purpose: (i) enabling
Developer’s users, including Beta Testers, to access and use Applications and Beta
Applications, (ii) obtaining information regarding the installation, use of and engagement with,
and the functionality of Developer’s Applications and Beta Applications, including reporting on
errors or bugs (collectively, “Performance Data”), (iii) improving the functionality of Developer’s
Applications, Beta Applications and related products and services, and/or (iv) communicating
with users, including Beta Testers, about Developer’s Applications and Beta Applications.
Developer’s access and use of the Services shall also comply with all other conditions set forth
in all documentation, instructions, end user guides and other documents regarding the Services
and Software, in each case that is provided or made available by Crashlytics to Developer in
electronic or other form (collectively, “Documentation”). Developer shall comply with all: (a)
applicable laws, rules, and regulations, and (b) any applicable third party terms, including any
third party terms applicable to Developer’s development and distribution of any Application or
Beta Application operating on the Android or iOS mobile operating systems, or any other
operating system upon which the Application or Beta Application is made available and upon
which Crashlytics makes the Services available to Developer.

2.3 Restrictions. Developer shall not directly or indirectly, or allow any third-party to: (a) use the
Services or any of Crashlytics’s Confidential Information (as defined below) to create any
service, software, or documentation that is the same as, substantially similar to or has similar
functionality as the Services, (b) disassemble, decompile, reverse engineer, decipher, translate
or use any other means to attempt to discover any source code, algorithms, or trade secrets
underlying the Services or Background Materials (defined below), except and only to the extent
these restrictions are expressly prohibited by applicable statutory law, (c) encumber, sublicense,
transfer, distribute, rent, lease, timeshare, or use any Crashlytics Properties (as defined below)
in any service bureau, rental or managed services arrangement or permit other individuals or
entities to create Internet "links" to the Crashlytics Properties or "frame" or "mirror" the
Crashlytics Properties on any other server, or wireless or Internet-based device, (d) adapt,
combine, create derivative works of, or otherwise modify any Crashlytics Properties, (e) use or
allow the transmission, transfer, export, reexport, or other transfer of any product, technology, or
information it obtains or learns in connection with Developer’s use of the Services in violation of
any export control or other laws and regulations of the United States or any other relevant
jurisdiction, (f) remove or alter any proprietary notices or labels on or in any Crashlytics
Properties; (g) use any Crashlytics Properties in connection with the development or
transmission of any virus, worms or malicious code, (h) use any Crashlytics Properties to
infringe the rights of Crashlytics or any third party, or in any way that does not comply with all
applicable laws, or (i) use any Crashlytics Properties (including to create any Application) in any
way that interferes with, disrupts, damages, or accesses in an unauthorized manner the servers,
networks, or other properties or services of Crashlytics or any third party, including any mobile
communications carrier.

2.4 Developer Feedback. From time to time, Crashlytics may solicit from Developer or
Developer may make, in its sole discretion, suggestions for changes, modifications or
improvements to the Crashlytics Properties (as defined below) or any other feedback related to
Crashlytics or the Crashlytics Properties (collectively, “Developer Feedback”). All Developer
Feedback shall be solely owned by Crashlytics (including all intellectual property rights therein
and thereto) and shall also be Crashlytics’s confidential information. Developer hereby assigns
all of its right, title and interest in and to any Developer Feedback to Crashlytics and
acknowledges that Crashlytics has the unrestricted right to use and exploit such Developer
Feedback in any manner, without attribution, and without any obligations or compensation to
Developer.

2.5 Developer Data. Developer hereby grants Crashlytics a nonexclusive, license fee free and
royalty free right and license to access, copy, distribute, process and use all information, data
and other content provided by Developer or received by Crashlytics in connection with
Developer’s authorized use of the Services, including, without limitation information provided
through any Application or Beta Application that Developer makes available for testing through
the Services (collectively, “Developer Data”), solely for the purpose of providing, developing,
and maintaining the Services, along with any related customer or technical support, and as
otherwise expressly permitted in this Agreement. Developer agrees that: (a) the Services
depend on the availability of the Developer Data, and (b) Crashlytics will not assume any
responsibility or liability for, or undertake to verify, the legality, accuracy or completeness of the
Developer Data. Crashlytics shall have no obligation to store any Developer Data or Results (as
defined below).

2.6 Access by Beta Testers; EULA; End Users; Compliance. Developer shall provide to
Crashlytics the contact information of any user of Developer’s application(s) whom Developer
intends to invite to become a Beta Tester. Developer is solely responsible for determining which
users will receive an invitation to become a Beta Tester, and for ensuring the accuracy of any
user contact information provided to Crashlytics. Developer may provide Beta Testers with its
own EULA for a Beta Application that will be accessed by Beta Testers (“Developer EULA”);
provided that the Developer EULA provides terms and conditions consistent with this Agreement
and, with respect to Crashlytics, no less protective than those terms and conditions set forth in
the standard EULA provided in Appendix A (“Standard EULA”). If Developer does not provide a
separate Developer EULA to Beta Testers in connection with Developer’s Beta Application,
then Developer acknowledges and agrees that such Beta Testers, by accessing the Beta
Application through the Services, will be made subject to the terms and conditions of the
Standard EULA between Developer and such Beta Testers.. Developer acknowledges and
agrees that Crashlytics provides the Standard EULA by way of convenience only, and does not
represent or warrant that the Standard EULA will be enforceable under, or in compliance with,
all applicable laws, rules, regulations, or otherwise. Developer acknowledges and agrees that
the EULA applicable to Developer’s Beta Application shall be between Developer and any Beta
Tester, and Crashlytics shall not be responsible for, and shall not have any liability whatsoever
for, such EULA, any application tested by a Beta Tester, or for any breach by Developer or any
Beta Tester of the terms and conditions of such EULA. The Services allow the Developer to
collect information relating to performance of Developer’s applications, including, without
limitation, device state information, unique device identifiers, information relating to the physical
location of a device, and information about how the application was used. Developer may turn
on features of the Services to allow collection of other information via the Services, including
some personally identifiable information (e.g., a user’s email address), which allows Developers
to communicate with users about the engagement with and functionality of their applications and
to invite them to become Beta Testers. Developer represents and warrants that Developer is
collecting information via the Services solely to obtain information about the user engagement
with and functionality of Developer’s applications, and to communicate with users about such
engagement and functionality. Developer agrees that it will not enable collection of personally
identifiable information via the Services unless it is necessary to communicate with users about
the applications or Developer wishes to invite users to be Beta Testers and the user has
provided affirmative consent to the collection and use of such information. Subject to and
without limiting the foregoing, Developer agrees it will not enable collection or use of credit card
information, Social Security numbers, driver’s license numbers, dates of birth or physical
addresses via the Services. Developer further agrees it will not invite any user to be a Beta
Tester that is under the age of consent as defined under any applicable laws, rules, or
regulations relating to data collection, including without limitation the Children’s Online Privacy
Protection Act of 1998 (“COPPA”), the Regulation (EU) 2016/679 of the European Parliament
and of the Council of 27 April 2016 on the protection of natural persons with regard to the
processing of personal data and on the free movement of such data, and repealing Directive
95/46/EC (General Data Protection Regulation or “GDPR”), and all other relevant laws and
regulations. At all times during the term of this Agreement, Developer shall maintain a privacy
policy: (a) that is readily accessible to users from its website or within its online service (as
applicable), (b) that fully and accurately discloses to its users what information is collected about
its users, and (c) that states that such information is disclosed to and processed by third party
providers like Crashlytics in the manner contemplated by the Services, including, without
limitation, disclosure of the use of technology to track users’ activity and otherwise collect
information from users. For Developer’s users in the European Union, Developer shall provide
such users with clear notice of, and obtain such users’ consent to, the transfer, storage, and use
of their information in the United States and any other country where Crashlytics, or any third
party service providers acting on its behalf, operates, and shall further notify such users that the
privacy and data protection laws in some of these countries may vary from the laws in the
country where such users live. Developer shall at all times comply with all applicable laws, rules
and regulations relating to data collection, privacy and security, including without limitation,
COPPA, GDPR, and all other such laws and regulations.. Developer will obtain and maintain
any required consents necessary and will comply with any other applicable requirements to
permit the processing of Developer Data under this Agreement.

2.7 Developer Systems. Developer is responsible for providing: (a) all equipment, subscriptions
and credentials necessary for Crashlytics to receive the Developer Data, and (b) all modems,
servers, devices, storage, software (other than Software), databases, network and
communications equipment and ancillary services needed to connect to, access, or otherwise
use the Services at its facility (collectively, “Developer Systems”). Developer shall ensure that
Developer Systems are compatible with the Services and comply with all configurations and
specifications described in the Documentation.

2.8 Limitations. Crashlytics will not be responsible or liable for any failures in the Services or any
other problems which are related to: (a) the Developer Data or Developer Systems, or (b) any
satellite, telecommunications, network or other equipment or service outside of Crashlytics’s
facilities or control.

2.9 Confidentiality. “Confidential Information” means any information disclosed by one party
(“Discloser”) to the other party (“Recipient”) that is marked or otherwise identified as
“confidential” or “proprietary,” or by its nature or the circumstances of disclosure should
reasonably be understood to be confidential, including without limitation, all financial, business
or technical information disclosed in relation to this Agreement. Except for the specific rights
granted by this Agreement, the Recipient may not use, copy or disclose any Confidential
Information of the Discloser without Discloser’s prior written consent, and shall use no less than
reasonable care to safeguard Discloser’s Confidential Information, including ensuring that
Recipient’s employees, contractors and agents (“Representatives”)with access to Discloser’s
Confidential Information have a need to know such Confidential Information for the purposes of
this Agreement and are bound by confidentiality obligations no less protective of the parties as
those set forth herein. The foregoing obligations shall not apply to any Confidential Information
that Recipient can demonstrate is: (a) already known by it without restriction, (b) rightfully
furnished to it without restriction by a third party not in breach of any obligation to Discloser, (c)
generally available to the public without breach of this Agreement or (d) independently
developed by it without reference to or use of any of Discloser’s Confidential Information and
without any violation of any obligation of this Agreement. Each party shall be responsible for any
breach of confidentiality by its Representatives, as applicable. Promptly upon Discloser’s
request at any time, Recipient shall, or in the case of Developer Data shall use reasonable
efforts to, return all of Discloser’s tangible Confidential Information, permanently erase all
Confidential Information from any storage media and destroy all information, records, copies,
summaries, analyses and materials developed therefrom. Nothing herein shall prevent a party
from disclosing any of the other’s Confidential Information as necessary pursuant to any court
order or any legal, regulatory, law enforcement or similar requirement or investigation; provided,
however, prior to any such disclosure, Recipient shall use reasonable efforts to: (i) promptly
notify Discloser in writing of such requirement to disclose where permitted by law, and (ii)
cooperate with Discloser in protecting against or minimizing any such disclosure and/or
obtaining a protective order.

2.10 Proprietary Rights. As used in this Agreement: “Background Materials” means all ideas,
concepts, inventions, systems, platforms, software (including all Software), interfaces, tools,
utilities, templates, forms, Report Formats, techniques, methods, processes, algorithms,
knowhow, trade secrets and other technologies and information that are used by Crashlytics in
providing the Services and Results (including any correction, improvement, derivative work,
extension or other modification to the Services made, created, conceived or developed by or for
Crashlytics, including at Developer’s request or as a result of feedback provided by Developer
to Crashlytics); “Reports” means the reports, charts, graphs and other presentation in which the
Results are presented to Developer; “Report Formats” means the formatting, look and feel of
the Reports; and “Results” means the work products resulting from the Services that are
delivered to Developer by Crashlytics through the Services, and which are based on the
Developer Data. For the sake of clarity, Results shall expressly exclude all Background
Materials. Developer shall own all right, title and interest (including all intellectual property and
other proprietary rights) in and to: (a) feedback, suggestions, ideas or other materials and
information provided by Beta Testers with respect to any Beta Application (“User Feedback”),
(b) the Results and (c) Developer Data. Developer acknowledges and agrees that the Results
will be presented to it in a Report, the Report Format of which is Confidential Information and
proprietary to Crashlytics. Developer may make a reasonable number of copies of the Reports
only for its internal purposes in using the Results. .

2.11 General Learning; Aggregate Data. Crashlytics reserves the right to disclose aggregate
information of Services usage, engagement, and performance, and to reuse all general
knowledge, experience, knowhow, works and technologies (including ideas, concepts,
processes and techniques) related to the Results or acquired during provision of the Services
(including without limitation, that which it could have acquired performing the same or similar
services for another customer).

2.12 Reservation of Rights. Except for the limited rights and licenses expressly granted
hereunder, no other license is granted, no other use is permitted and Crashlytics (and its
licensors) shall retain all right, title, and interest (including all intellectual property and proprietary
rights embodied therein) in and to the Services, Software, Documentation, Background
Materials, aggregate data, and analyses (collectively, "Crashlytics Properties").

SECTION 3. SPECIFIC TERMS FOR BETA TESTERS

3.1 License; Restrictions. In order to access and use the Services to test any Beta Application,
you may need to download or install Software (defined in Section 2 above), web clips,
certificates, or other materials provided by Crashlytics (“Crashlytics Material”). Subject to your
compliance with this Agreement, Crashlytics grants you a limited, nonexclusive, non-assignable,
non-sublicensable license to access, download, and use any Crashlytics Material made
available to you by Crashlytics, solely to access and use the Services. Crashlytics reserves all
right, title, and interest in the Crashlytics Material not expressly granted to you, including but not
limited to intellectual property rights. To the maximum extent permitted by law, you may not do
any of the following with respect to any Crashlytics Material you receive or otherwise have
access to: (a) modify, reverse engineer, decompile, or disassemble any Crashlytics Material, (b)
rent, lease, loan, sell, sublicense, distribute, transmit, or otherwise transfer any Crashlytics
Material, (c) make any copy of or otherwise reproduce any Crashlytics Material, (d) remove,
alter, or obscure any copyright, trademark or other proprietary rights notice on or in any
Crashlytics Material, (e) work around any technical limitations in any Crashlytics Material, or (f)
use any Crashlytics Material for purposes for which it is not designed.

3.2 No Responsibility for Beta Applications. If you have any complaints or disputes relating to
your use of any Beta Application, you agree to look solely to the applicable Developer of such
Beta Application and not Crashlytics. You acknowledge and agree that the applicable
Developer, not Crashlytics, is fully responsible for any Beta Application, and the processing of
information about your use of any Beta Application. If you want to terminate this Agreement, you
must stop using the Services and delete from your device all Crashlytics Material.

3.3 Consent to Data Processing and Transfer. Irrespective of which country you live in, you
authorize Crashlytics to use your information in, and as a result to transfer it to and store it in,
the United States and any other country where Crashlytics operates. Privacy and data
protection laws in some of these countries may vary from the laws in the country where you live.

3.4 No Compensation. By becoming a Beta Tester, you are acting as a volunteer. You will bear
your own costs, including any mobile carrier and data costs that you incur in connection with
your use of the Beta Application or any User Feedback (defined above) that you submit.

3.5 Standard EULA for Beta Applications. You agree to comply with the terms of the Standard
EULA in connection with your access and use of any Beta Application of a Developer, unless
you agree to comply with a separate license agreement that the Developer provides in
connection with such Beta Application, in which case the terms of that separate license
agreement will govern.

SECTION 4. WARRANTY, LIABILITY & INDEMNITY

4.1 Warranties. Crashlytics represents and warrants that it has full right, power, and authority to
enter into this Agreement and to perform its obligations and duties under this Agreement, and
that the performance of such obligations and duties does not conflict with or result in a breach of
any other agreement of Crashlytics, or any judgment, order, or decree by which such party is
bound. Developer’s sole and exclusive remedy for any and all breaches of this provision is the
remedy set forth in Section 4.4. Developer represents and warrants that it owns all right, title
and interest, or possesses sufficient license rights, in and to the Developer Data as may be
necessary to grant the rights and licenses, and provide the representations, and for Crashlytics
to provide the Services set forth herein. Developer bears all responsibility and liability for the
legality, accuracy and completeness of the Developer Data and Crashlytics’s access,
possession, distribution, and use thereof, as permitted herein.

4.2 Disclaimers. THE CRASHLYTICS SERVICES, CRASHLYTICS PROPERTIES AND
RESULTS ARE PROVIDED “AS IS” WITHOUT WARRANTY OF ANY KIND. WITHOUT
LIMITING THE FOREGOING, CRASHLYTICS AND ITS PARENTS, SUBSIDIARIES,
AFFILIATES, RELATED COMPANIES, OFFICERS, DIRECTORS, EMPLOYEES, AGENTS,
REPRESENTATIVES, PARTNERS AND LICENSORS (COLLECTIVELY, THE “CRASHLYTICS
ENTITIES”) MAKE NO WARRANTY: (A) THAT THE SERVICES OR RESULTS WILL MEET
YOUR REQUIREMENTS OR BE UNINTERRUPTED, ERROR FREE OR BUGFREE, (B)
REGARDING THE RELIABILITY, TIMELINESS, OR PERFORMANCE OF THE SERVICES, OR
(C) THAT ANY ERRORS IN THE SERVICES CAN OR WILL BE CORRECTED. THE
CRASHLYTICS ENTITIES HEREBY DISCLAIM (FOR THEMSELVES AND THEIR
SUPPLIERS) ALL WARRANTIES, WHETHER EXPRESS OR IMPLIED, ORAL OR WRITTEN,
INCLUDING WITHOUT LIMITATION, ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
MERCHANTABILITY, TITLE OR FITNESS FOR ANY PARTICULAR PURPOSE AND ALL
WARRANTIES ARISING FROM ANY COURSE OF DEALING, COURSE OF PERFORMANCE
OR USAGE OF TRADE.

4.3 Claims Against Crashlytics. Developer will defend Crashlytics from all third party claims,
whether actual or alleged (collectively, “Crashlytics Claims”), and will indemnify Crashlytics
and hold Crashlytics harmless from any and all losses, liabilities, damages, costs, and expenses
(including reasonable attorney’s fees) resulting from such Crashlytics Claims that arise out of
Developer’s: (a) use of the Services, (b) actual or alleged infringement or misappropriation of
the rights of any third party, including, without limitation, any intellectual property rights, privacy
rights or publicity rights, and (c) breach of any representations and warranties set forth in the
Agreement. Developer is solely responsible for defending any such Crashlytics Claims, subject
to Crashlytics’s right to participate with counsel of its own choosing, and for payment of all
judgments, settlements, damages, losses, liabilities, costs, and expenses, including reasonable
attorneys’ fees, resulting from such Claims against Crashlytics, provided that Developer will not
agree to any settlement related to any such Crashlytics Claims without Crashlytics’s prior
express written consent regardless of whether or not such settlement releases Crashlytics from
any obligation or liability. If Developer uses the Services in an official capacity as an employee
or representative of a United States federal, state, or local government entity and is legally
unable to accept this indemnification provision, then it does not apply to such entity, but only to
the extent required by applicable law.

4.4 Claims Against Developer. Crashlytics will defend the Developer from all third party claims,
actions, suits, or proceedings, whether actual or alleged (collectively, “Developer Claims”), and
will indemnify Developer and hold Developer harmless from any and all losses, liabilities,
damages, costs, and expenses (including reasonable attorney’s fees) resulting from such
Developer Claims, that arise out of an allegation that the Services, when used as expressly
permitted by this Agreement, infringes the intellectual property rights of such third party.
Notwithstanding the foregoing, Crashlytics will have no obligation under this Section 4.4 or
otherwise with respect to any infringement claim based upon: (a) any use of the Services not
expressly permitted under this Agreement; (b) any use of the Services in combination with
products, equipment, software, or data not made available by Crashlytics if such infringement
would have been avoided without the combination with such other products, equipment,
software, or data; (c) any modification of the Services by any person other than Crashlytics or its
authorized agents or subcontractors; or (d) any claim not clearly based on the Services itself.
This Section 4.4 states Crashlytics’s entire liability and Developer’s sole and exclusive remedy
for all third party claims.

4.5 Procedure. The foregoing obligations are conditioned on the party seeking indemnification:
(a) promptly notifying the other party in writing of such claim; (b) giving the other party sole
control of the defense thereof and any related settlement negotiations; and (c) cooperating and,
at the other party’s request and expense, assisting in such defense. Neither party may make
any public announcement of any claim, defense or settlement without the other party’s prior
written approval. The indemnifying party may not settle, compromise or resolve a claim without
the consent of the indemnified party, if such settlement, compromise or resolution (i) causes or
requires an admission or finding of guilt against the indemnified party, (i) imposes any monetary
damages against the indemnified party, or (iii) does not fully release the indemnified party from
liability with respect to the claim.

4.6 Limitation of Liability.
(a) IN NO EVENT WILL EITHER PARTY BE LIABLE TO THE OTHER FOR ANY INDIRECT,
SPECIAL, INCIDENTAL, EXEMPLARY, PUNITIVE, OR CONSEQUENTIAL DAMAGES
ARISING OUT OF OR IN CONNECTION WITH THIS AGREEMENT, OR FOR ANY DAMAGES
ASSOCIATED WITH ANY LOSS OF USE, BUSINESS, PROFITS, OR GOODWILL OR FOR
INTERRUPTION, LOSS OR CORRUPTION OF DATA OR NETWORKS.
(b) IN NO EVENT WILL EITHER PARTY’S AGGREGATE LIABILITY FOR ANY AND ALL
CLAIMS UNDER THIS AGREEMENT EXCEED FIFTY ($50.00) DOLLARS (USD).
(c) THE FOREGOING LIMITATIONS SHALL NOT APPLY TO BREACHES OF
CONFIDENTIALITY OBLIGATIONS OR FOR MISAPPROPRIATION OR INFRINGEMENT OF
INTELLECTUAL PROPERTY RIGHTS, AND SHALL APPLY NOTWITHSTANDING THE
FAILURE OF ANY REMEDY PROVIDED HEREIN.
THE FOREGOING LIMITATIONS, EXCLUSIONS AND DISCLAIMERS SHALL APPLY TO ANY
AND ALL CLAIMS, REGARDLESS OF WHETHER SUCH LIABILITY ARISES FROM ANY
CLAIM BASED UPON CONTRACT, WARRANTY, TORT (INCLUDING NEGLIGENCE), STRICT
LIABILITY, OR OTHERWISE, AND WHETHER OR NOT THE PARTY HAS BEEN ADVISED OF
THE POSSIBILITY OF SUCH LOSS OR DAMAGE. Some states do not allow the exclusion or
limitation of incidental or consequential damages, so the above limitation or exclusion may not
apply to You. INSOFAR AS APPLICABLE LAW PROHIBITS ANY LIMITATION ON LIABILITY
HEREIN, THE PARTIES AGREE THAT SUCH LIMITATION WILL BE AUTOMATICALLY
MODIFIED, BUT ONLY TO THE EXTENT SO AS TO MAKE THE LIMITATION COMPLIANT
WITH APPLICABLE LAW.

SECTION 5. TERM AND TERMINATION

5.1 Term. The term of this Agreement will begin on the date you first agree to this Agreement
and are approved to register for the Services, and continue until terminated as set forth herein
(“Term”). Your use of the Services may be terminated by Crashlytics or you at any time, for any
reason, effective immediately upon notice provided by one party to the other party as set forth
herein.

5.2 Effects of Termination. Upon any expiration or termination of this Agreement, all rights,
obligations and licenses of the parties shall cease, except that: (a) all obligations that accrued
prior to the effective date of termination and all remedies for breach of this Agreement shall
survive, (b) you must discontinue accessing and using the Services and delete all Software,
Crashlytics Properties, and Crashlytics Material, and (c) the provisions in Section 2 titled
Restrictions, Developer Feedback, Confidentiality, Proprietary Rights, General Learning;
Aggregate Data, the provisions of Section 4 and the provisions in this Section 5 shall survive.
Crashlytics has no obligation to store, delete or return any User Feedback, Performance Data,
Developer Data, or Results.

SECTION 6. MISCELLANEOUS

6.1 Entire Agreement. This Agreement (which includes any order form completed by Developer)
constitutes the entire agreement, and supersede all prior negotiations, understandings, or
agreements (oral or written), between the parties about the subject matter of this Agreement.

6.2 Waivers, Consents and Amendments. No waiver, consent, or modification of this
Agreement shall bind the Crashlytics Entities unless in writing and signed by Crashlytics.
Crashlytics may amend this Agreement from time to time. If we make a change to this
Agreement that, in our sole discretion, is material, we will notify you at the email address that
you provided upon signing up to access the Services or upon signing up to access the
Crashlytics Fabric services, at crashlytics.com, or otherwise through the Services. If you do not
agree to the modified terms, you shall notify Crashlytics in writing within thirty (30) days, after
which your right to access and use the Services shall immediately terminate and the Crashlytics
Entities shall have no further responsibility or liability to you. The failure of either party to enforce
its rights under this Agreement at any time for any period will not be construed as a waiver of
such rights.

6.3 Severability. If any provision of this Agreement is determined to be illegal or unenforceable,
that provision will be limited or eliminated to the minimum extent necessary so that this
Agreement will otherwise remain in full force and effect and enforceable.

6.4 Governing Law and Disputes. This Agreement shall be governed by and construed in
accordance with the laws of the State of California, without regard to its conflicts of law
provisions.

(a) Except as set forth in Section 6.4(b) below, all claims arising out of or relating to this
Agreement or the Services ("Disputes”) will be governed by California law, excluding
California’s conflict of laws rules, and all Disputes will be litigated exclusively in the federal or
state courts of Santa Clara County, California, USA, and You and Crashlytics consent to
personal jurisdiction in those courts.

(b) If Your principal place of business (for entities) or place of residence (for individuals) is in any
country within APAC (other than Australia, Japan, New Zealand or Singapore) or Latin America,
this Section 6.4(b) will apply instead of Section 6.4(a) above. ALL DISPUTES (AS DEFINED
ABOVE) WILL BE GOVERNED BY CALIFORNIA LAW, EXCLUDING CALIFORNIA’S
CONFLICT OF LAWS RULES.The parties will try in good faith to settle any Dispute within 30
days after the Dispute arises. If the Dispute is not resolved within 30 days, it must be resolved
by arbitration by the American Arbitration Association’s International Centre for Dispute
Resolution in accordance with its Expedited Commercial Rules in force as of the date of this
Agreement ("Rules"). The parties will mutually select one arbitrator. The arbitration will be
conducted in English in Santa Clara County, California, USA. Either party may apply to any
competent court for injunctive relief necessary to protect its rights pending resolution of the
arbitration. The arbitrator may order equitable or injunctive relief consistent with the remedies
and limitations in this Agreement. Subject to the confidentiality requirements in of this
Agreement, either party may petition any competent court to issue any order necessary to
protect that party's rights or property; this petition will not be considered a violation or waiver of
this governing law and arbitration section and will not affect the arbitrator’s powers, including the
power to review the judicial decision. The parties stipulate that the courts of Santa Clara County,
California, USA, are competent to grant any order under this subsection. The arbitral award will
be final and binding on the parties and its execution may be presented in any competent court,
including any court with jurisdiction over either party or any of its property. Any arbitration
proceeding conducted in accordance with this section will be considered Confidential
Information under this Agreement's confidentiality section, including: (i) the existence of, (ii) any
information disclosed during, and (iii) any oral communications or documents related to the
arbitration proceedings. The parties may also disclose the information described in this section
to a competent court as may be necessary to file any order under this section or execute any
arbitral decision, but the parties must request that those judicial proceedings be conducted in
camera (in private). The parties will pay the arbitrator’s fees, the arbitrator's appointed experts'
fees and expenses, and the arbitration center's administrative expenses in accordance with the
Rules. In its final decision, the arbitrator will determine the non-prevailing party's obligation to
reimburse the amount paid in advance by the prevailing party for these fees. Each party will
bear its own lawyers’ and experts’ fees and expenses, regardless of the arbitrator’s final
decision.

6.5 Force Majeure. In the event that either party is prevented from performing, or is unable to
perform, any of its obligations under this Agreement (except payment obligations) due to any
cause beyond its reasonable control, the affected party shall give written notice thereof to the
other party and its performance shall be extended for the period of delay or inability to perform
due to such occurrence.

6.6 Notices. Any notice or communication hereunder shall be in writing and either personally
delivered or sent via confirmed facsimile, confirmed electronic transmission, recognized express
delivery courier or certified or registered mail, prepaid and return receipt requested, addressed
to the other party, which, in the case of Developer, shall be the email address provided to
Crashlytics upon signing up for the Services or upon signing up to access the Crashlytics Fabric
services, and, in the case of Crashlytics, shall be Google LLC 1600 Amphitheatre Parkway,
Mountain View, CA 94043, USA, with a copy to Legal Department. All notices shall be in
English, and deemed to have been received when they are hand delivered, or five business
days after their mailing, or upon confirmed electronic transmission or confirmed facsimile
transmission.

6.7 Assignment. This Agreement and the rights and obligations hereunder may not be assigned,
transferred or delegated, in whole or in part, whether voluntarily or by operation of law, contract,
merger (whether Developer is the surviving or disappearing entity), stock or asset sale,
consolidation, dissolution, through government action or otherwise, by Developer without
Crashlytics’s prior written consent. Any assignment or transfer in violation of the foregoing shall
automatically be null and void, and Crashlytics may immediately terminate this Agreement upon
such an attempt. This Agreement shall be binding upon, and inure to the benefit of, any
permitted successors, representatives, and permitted assigns of the parties hereto.
6.8 Independent Contractors. The parties shall be independent contractors under this

Agreement, and nothing herein will constitute either party as the employer, employee, agent, or
representative of the other party, or both parties as joint venturers or partners for any purpose.
Appendix A - Standard EULA

You, the Beta Tester, and the Developer (“Licensor”) of the Beta Application you access and use
via the Services agree to comply with the terms of this EULA in connection with your access and
use of such Beta Application (the “Application”).

1. Relationship between the Parties. Licensor and the Beta Tester acknowledge that this
Standard EULA is entered into by and between Licensor and the Beta Tester only, and not with
Google LLCand its worldwide affiliates (“Crashlytics”), and Licensor, not Crashlytics, is solely
responsible and liable for the Application accessed and used by the Beta Tester, including (i)
any related maintenance and support, (ii) any and all express, implied, or statutory warranties
associated with the Application, and (iii) any disputes or claims arising out of or related to the
access and use of the Application.

2. License. Subject to your compliance with this Standard EULA, the Licensor grants you a
limited, nonexclusive, non-assignable, non-sublicensable license to access, download, and use
the Application and any related documentation made available to you by the Licensor, solely for
beta testing purposes. Licensor reserves all right, title, and interest in the Application not
expressly granted to you, including but not limited to intellectual property rights. To the maximum
extent permitted by law, you may not do any of the following with respect to the Application: (a)
modify, reverse engineer, decompile, or disassemble the Application; (b) rent, lease, loan, sell,
sublicense, distribute, transmit, or otherwise transfer the Application; or (c) make any copy of or
otherwise reproduce the Application. This license is effective until terminated by you or the
Licensor. Your rights under this license will terminate automatically without notice from the
Licensor if you fail to comply with any term of this Standard EULA. Upon termination of the
license, you shall cease all use of the Application, and destroy all copies, full or partial, of the
Application.

3. Consent to Data Processing and Transfer. Irrespective of which country you live in, you
authorize us to use your information in, and as a result to transfer it to and store it in, the United
States and any other country where we or Crashlytics operate. Privacy and data protection laws
in some of these countries may vary from the laws in the country where you live

.
4. No Compensation. By becoming a Beta Tester, you are acting as a volunteer. You will bear
your own costs, including any mobile carrier and data costs that you incur in connection with
your use of the Application or any User Feedback (defined in Section 2 above) that you submit.

5. User Feedback. You agree to use reasonable efforts to beta test any application downloaded
from the Services. User Feedback shall be owned by the Licensor. You hereby assign all of your
right, title, and interest in and to any User Feedback to Licensor and acknowledge that Licensor
has the unrestricted right to use and exploit such User Feedback in any manner, with or without
attribution, and without compensation or any duty to account to you for such use.

6. Confidentiality. The Application and related information that Licensor provides to you are
Licensor’s confidential information. You will not disclose information about the Application or any
other Licensor confidential information to anyone other than Licensor’s employees, unless
Licensor gives you written permission. For example, do not share screenshots or video clips of
the Application with your friends, family, coworkers, or the media. You will also take reasonable
precautions to prevent anyone from obtaining Licensor’s confidential information. For example,
you should restrict access to your mobile device, prevent others from watching you use the
Application, and not create any screenshots or video clips of the Application.

7. Disclaimer. THE APPLICATION IS A TEST VERSION THAT IS MADE AVAILABLE TO YOU
FOR TESTING AND EVALUATION PURPOSES ONLY. THE APPLICATION IS NOT READY
FOR COMMERCIAL RELEASE AND MAY CONTAIN BUGS, ERRORS, AND DEFECTS.
ACCORDINGLY, THE APPLICATION IS PROVIDED “AS IS,” WITH ALL FAULTS, DEFECTS,
AND ERRORS, AND WITHOUT WARRANTY OF ANY KIND. LICENSOR AND ITS
SUPPLIERS DISCLAIM ALL WARRANTIES (EXPRESS, IMPLIED, ARISING BY LAW, OR
OTHERWISE) REGARDING THE APPLICATION AND ITS PERFORMANCE OR SUITABILITY
FOR YOUR INTENDED USE, INCLUDING ANY IMPLIED WARRANTY OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NONINFRINGEMENT.

8. Limitation of Liability. EXCEPT TO THE EXTENT PROHIBITED BY LAW, IN NO EVENT
WILL LICENSOR OR ITS SUPPLIERS BE LIABLE (UNDER ANY THEORY OF LIABILITY)
FOR PERSONAL INJURY OR ANY INDIRECT, INCIDENTAL, CONSEQUENTIAL OR SPECIAL
DAMAGES (INCLUDING FOR LOSS OF DATA, LOSS OF CONTENT, LOSS OF
IN-APPLICATION FEATURES, LOSS OF PROFITS, OR BUSINESS INTERRUPTION)
ARISING OUT OF OR RELATED TO YOUR USE OF OR INABILITY TO USE THE
APPLICATION, EVEN IF LICENSOR AND/OR ITS SUPPLIERS HAS/HAVE BEEN ADVISED
OF THE POSSIBILITY OF SUCH DAMAGES. SOME JURISDICTIONS DO NOT ALLOW THE
FOREGOING LIMITATIONS OF LIABILITY, SO THESE LIMITATIONS MAY NOT APPLY TO
YOU. IN NO EVENT SHALL LICENSOR AND ITS SUPPLIERS’ AGGREGATE LIABILITY
ARISING FROM YOUR USE OR INABILITY TO USE THE APPLICATION EXCEED FIFTY
UNITED STATES DOLLARS (US $50.00).

{'repo_name': 'mikepenz/AboutLibraries', 'stars': '2496', 'repo_language': 'Kotlin', 'file_name': 'license_asdkl.txt', 'mime_type': 'text/plain', 'hash': -6552667529809065873, 'source_dataset': 'data'}


/* $Id: hash.hpp 2394 2008-12-23 17:27:53Z bennylp $ */
/*
 * Copyright (C) 2008-2009 Teluu Inc. (http://www.teluu.com)
 * Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
#ifndef __PJPP_HASH_HPP__
#define __PJPP_HASH_HPP__

#include <pj++/types.hpp>
#include <pj++/pool.hpp>
#include <pj/hash.h>

//
// Hash table.
//
class Pj_Hash_Table : public Pj_Object
{
public:
    //
    // Hash table iterator.
    //
    class iterator
    {
    public:
	iterator()
        {
        }
	explicit iterator(pj_hash_table_t *h, pj_hash_iterator_t *i)
        : ht_(h), it_(i)
        {
        }
	iterator(const iterator &rhs)
        : ht_(rhs.ht_), it_(rhs.it_)
        {
        }
	void operator++()
        {
            it_ = pj_hash_next(ht_, it_);
        }
	bool operator==(const iterator &rhs)
        {
            return ht_ == rhs.ht_ && it_ == rhs.it_;
        }
	iterator & operator=(const iterator &rhs)
        {
            ht_=rhs.ht_; it_=rhs.it_;
            return *this;
        }
    private:
	pj_hash_table_t *ht_;
	pj_hash_iterator_t it_val_;
	pj_hash_iterator_t *it_;

	friend class Pj_Hash_Table;
    };

    //
    // Construct hash table.
    //
    Pj_Hash_Table(Pj_Pool *pool, unsigned size)
    {
	table_ = pj_hash_create(pool->pool_(), size);
    }

    //
    // Destroy hash table.
    //
    ~Pj_Hash_Table()
    {
    }

    //
    // Calculate hash value.
    //
    static pj_uint32_t calc( pj_uint32_t initial_hval,
                             const void *key,
                             unsigned keylen = PJ_HASH_KEY_STRING)
    {
	return pj_hash_calc(initial_hval, key, keylen);
    }

    //
    // Return pjlib compatible hash table object.
    //
    pj_hash_table_t *pj_hash_table_t_()
    {
	return table_;
    }

    //
    // Get the value associated with the specified key.
    //
    void *get(const void *key, unsigned keylen = PJ_HASH_KEY_STRING)
    {
	return pj_hash_get(table_, key, keylen);
    }

    //
    // Associate a value with a key.
    // Set the value to NULL to delete the key from the hash table.
    //
    void set(Pj_Pool *pool,
             const void *key,
             void *value,
             unsigned keylen = PJ_HASH_KEY_STRING)
    {
	pj_hash_set(pool->pool_(), table_, key, keylen, value);
    }

    //
    // Get number of items in the hash table.
    //
    unsigned count()
    {
	return pj_hash_count(table_);
    }

    //
    // Iterate hash table.
    //
    iterator begin()
    {
	iterator it(table_, NULL);
	it.it_ = pj_hash_first(table_, &it.it_val_);
	return it;
    }

    //
    // End of items.
    //
    iterator end()
    {
	return iterator(table_, NULL);
    }

private:
    pj_hash_table_t *table_;
};

#endif	/* __PJPP_HASH_HPP__ */

{'repo_name': 'Te-k/flexidie', 'stars': '808', 'repo_language': 'None', 'file_name': 'main.m', 'mime_type': 'text/x-objective-c', 'hash': 4014293668579674708, 'source_dataset': 'data'}


{'repo_name': 'midwayjs/midway', 'stars': '2554', 'repo_language': 'TypeScript', 'file_name': 'cli.js', 'mime_type': 'text/plain', 'hash': 5871325176371417602, 'source_dataset': 'data'}


from __future__ import absolute_import, print_function, division
import os.path

from theano import Apply, config, Op

from theano.compile import optdb
from theano.gof import LocalOptGroup
from theano.tensor.basic import as_tensor_variable
from theano.tensor.opt import in2out

from .basic_ops import as_gpuarray_variable, infer_context_name
from .opt_util import inplace_allocempty

try:
    import pygpu
    from pygpu import blas
except ImportError as e:
    # To make sure theano is importable
    pass

class BlasOp(Op):
    def c_headers(self):
        return ['<blas_api.h>', '<numpy_compat.h>', '<gpuarray_helper.h>']

    def c_header_dirs(self):
        return [pygpu.get_include(), os.path.dirname(__file__)]

    def c_init_code(self):
        return ['import_pygpu__blas();']

class GpuGemv(BlasOp):
    """
    Gemv on the GPU.

    """
    __props__ = ('inplace',)

    def __init__(self, inplace=False):
        self.inplace = inplace
        if self.inplace:
            self.destroy_map = {0: [0]}

    def make_node(self, y, alpha, A, x, beta):
        ctx_name = infer_context_name(y, A, x)
        A = as_gpuarray_variable(A, ctx_name)
        x = as_gpuarray_variable(x, ctx_name)
        y = as_gpuarray_variable(y, ctx_name)
        alpha = as_tensor_variable(alpha)
        beta = as_tensor_variable(beta)
        assert alpha.ndim == 0
        assert beta.ndim == 0
        assert A.ndim == 2
        assert x.ndim == 1
        assert y.ndim == 1
        assert A.dtype == x.dtype == y.dtype
        return Apply(self, [y, alpha, A, x, beta], [y.type()])

    def perform(self, node, inputs, out_storage):
        y, alpha, A, x, beta = inputs
        inplace = self.inplace
        if inplace and y.strides[0] < 0:
            inplace = False
        out_storage[0][0] = blas.gemv(alpha, A, x, beta, y,
                                      overwrite_y=inplace)

    def c_code(self, node, name, inp, out, sub):
        vars = dict(out=out[0], y=inp[0], alpha=inp[1], A=inp[2], x=inp[3],
                    beta=inp[4], fail=sub['fail'], name=name)
        if self.inplace:
            code = """
                   if (%(y)s->ga.strides[0] <= 0) {
                     %(out)s = theano_try_copy(%(out)s, %(y)s);
                     if (%(out)s == NULL) {
                       %(fail)s
                     }
                   } else {
                     Py_XDECREF(%(out)s);
                     %(out)s = %(y)s;
                     Py_INCREF(%(out)s);
                   }
                   """ % vars
        else:
            code = """
                   %(out)s = theano_try_copy(%(out)s, %(y)s);
                   if (%(out)s == NULL) {
                       %(fail)s
                   }
                   """ % vars
        code += """
        if (pygpu_blas_rgemv(cb_no_trans,
                             ((dtype_%(alpha)s *)PyArray_DATA(%(alpha)s))[0],
                             %(A)s, %(x)s,
                             ((dtype_%(beta)s *)PyArray_DATA(%(beta)s))[0],
                             %(out)s, 0) == -1) {
            %(fail)s
        }
        """ % vars
        if config.gpuarray.sync:
            code += """
            GpuArray_sync(&%(out)s->ga);
            """ % vars
        return code

    def c_code_cache_version(self):
        return (4,)

gpugemv_no_inplace = GpuGemv(inplace=False)
gpugemv_inplace = GpuGemv(inplace=True)

class GpuGemm(BlasOp):
    """
    Gemm on the GPU.

    """
    __props__ = ('inplace',)
    _f16_ok = True

    def __init__(self, inplace=False):
        self.inplace = inplace
        if self.inplace:
            self.destroy_map = {0: [0]}

    def make_node(self, C, alpha, A, B, beta):
        ctx_name = infer_context_name(C, A, B)
        A = as_gpuarray_variable(A, ctx_name)
        B = as_gpuarray_variable(B, ctx_name)
        C = as_gpuarray_variable(C, ctx_name)
        alpha = as_tensor_variable(alpha)
        beta = as_tensor_variable(beta)
        assert alpha.ndim == 0
        assert beta.ndim == 0
        assert A.ndim == 2
        assert B.ndim == 2
        assert C.ndim == 2
        assert A.dtype == B.dtype == C.dtype
        return Apply(self, [C, alpha, A, B, beta], [C.type()])

    def perform(self, node, inputs, outputs):
        C, alpha, A, B, beta = inputs
        inplace = self.inplace
        if inplace and not C.flags.forc:
            inplace = False
        outputs[0][0] = blas.gemm(alpha, A, B, beta, C,
                                  overwrite_c=inplace)

    def c_code(self, node, name, inp, out, sub):
        vars = dict(out=out[0], C=inp[0], alpha=inp[1], A=inp[2], B=inp[3],
                    beta=inp[4], fail=sub['fail'], name=name)
        if self.inplace:
            code = """
                   if (!GpuArray_ISONESEGMENT(&%(C)s->ga)) {
                     %(out)s = theano_try_copy(%(out)s, %(C)s);
                     if (%(out)s == NULL) {
                       %(fail)s
                     }
                   } else {
                     Py_XDECREF(%(out)s);
                     %(out)s = %(C)s;
                     Py_INCREF(%(out)s);
                   }
                   """ % vars
        else:
            code = """
                   %(out)s = theano_try_copy(%(out)s, %(C)s);
                   if (%(out)s == NULL) {
                       %(fail)s
                   }
                   """ % vars
        code += """
        if (pygpu_blas_rgemm(cb_no_trans, cb_no_trans,
                             ((dtype_%(alpha)s *)PyArray_DATA(%(alpha)s))[0],
                             %(A)s, %(B)s,
                             ((dtype_%(beta)s *)PyArray_DATA(%(beta)s))[0],
                             %(out)s, 0) == -1) {
            %(fail)s
        }
        """ % vars
        if config.gpuarray.sync:
            code += """
            GpuArray_sync(&%(out)s->ga);
            """ % vars
        return code

    def c_code_cache_version(self):
        return (5,)

gpugemm_no_inplace = GpuGemm(inplace=False)
gpugemm_inplace = GpuGemm(inplace=True)

class GpuGer(BlasOp):
    """
    Ger on the GPU.

    """
    __props__ = ('inplace',)

    def __init__(self, inplace=False):
        self.inplace = inplace
        if self.inplace:
            self.destroy_map = {0: [0]}

    def make_node(self, A, alpha, x, y):
        ctx_name = infer_context_name(A, x, y)
        A = as_gpuarray_variable(A, ctx_name)
        x = as_gpuarray_variable(x, ctx_name)
        y = as_gpuarray_variable(y, ctx_name)
        alpha = as_tensor_variable(alpha)
        assert alpha.ndim == 0
        assert A.ndim == 2
        assert x.ndim == 1
        assert y.ndim == 1
        assert A.dtype == x.dtype == y.dtype
        return Apply(self, [A, alpha, x, y], [A.type()])

    def perform(self, node, inp, out):
        A, alpha, x, y = inp
        inplace = self.inplace
        if inplace and not A.flags.forc:
            inplace = False
        out[0][0] = blas.ger(alpha, x, y, A,
                             overwrite_a=inplace)

    def c_code(self, node, name, inp, out, sub):
        vars = dict(out=out[0], A=inp[0], alpha=inp[1], x=inp[2], y=inp[3],
                    fail=sub['fail'], name=name)
        if self.inplace:
            code = """
                   if (!GpuArray_ISONESEGMENT(&%(A)s->ga)) {
                     %(out)s = theano_try_copy(%(out)s, %(A)s);
                     if (%(out)s == NULL) {
                       %(fail)s
                     }
                   } else {
                     Py_XDECREF(%(out)s);
                     %(out)s = %(A)s;
                     Py_INCREF(%(out)s);
                   }
                   """ % vars
        else:
            code = """
                   %(out)s = theano_try_copy(%(out)s, %(A)s);
                   if (%(out)s == NULL) {
                       %(fail)s
                   }
                   """ % vars
        code += """
        if (pygpu_blas_rger(((dtype_%(alpha)s *)PyArray_DATA(%(alpha)s))[0],
                            %(x)s, %(y)s, %(out)s, 0) == -1) {
            %(fail)s
        }
        """ % vars
        if config.gpuarray.sync:
            code += """
            GpuArray_sync(&%(out)s->ga);
            """ % vars
        return code

    def c_code_cache_version(self):
        return (3,)

gpuger_no_inplace = GpuGer(inplace=False)
gpuger_inplace = GpuGer(inplace=True)

class GpuDot22(BlasOp):
    """
    Dot22 on the GPU.

    """
    __props__ = ()

    def make_node(self, x, y):
        ctx_name = infer_context_name(x, y)
        x = as_gpuarray_variable(x, ctx_name)
        y = as_gpuarray_variable(y, ctx_name)
        assert x.ndim == 2
        assert y.ndim == 2
        assert x.dtype == y.dtype
        otype = x.type.clone(
            broadcastable=(x.type.broadcastable[0], y.type.broadcastable[1]))
        return Apply(self, [x, y], [otype()])

    def perform(self, node, inputs, outputs):
        x, y = inputs

        out = pygpu.empty((x.shape[0], y.shape[1]), dtype=x.dtype,
                          context=x.context)
        outputs[0][0] = blas.gemm(1., x, y, 0., out,
                                  overwrite_c=True)

    def c_code(self, node, name, inputs, outputs, sub):
        dtype = node.inputs[0].dtype
        typecode = pygpu.gpuarray.dtype_to_typecode(dtype)
        vars = dict(A=inputs[0], B=inputs[1], dtype=dtype, out=outputs[0],
                    typecode=typecode,
                    fail=sub['fail'], name=name)
        code = """
        double one = 1.;
        double zero = 0.;

        size_t dims[] = {0, 0};
        dims[0] = PyGpuArray_DIMS(%(A)s)[0];
        dims[1] = PyGpuArray_DIMS(%(B)s)[1];

        if (theano_prep_output(&%(out)s, 2, dims, %(typecode)s, GA_C_ORDER,
                               %(A)s->context)) {
            %(fail)s
        }

        if (pygpu_blas_rgemm(cb_no_trans, cb_no_trans,
                             one,
                             %(A)s, %(B)s,
                             zero,
                             %(out)s, 0) == -1) {
            %(fail)s
        }
        """ % vars
        if config.gpuarray.sync:
            code += """
            GpuArray_sync(&%(out)s->ga);
            """ % vars
        return code

    def c_code_cache_version(self):
        return (4,)

gpu_dot22 = GpuDot22()

@inplace_allocempty(GpuGemv, 0)
def local_inplace_gpuagemv(node, inputs):
    return [gpugemv_inplace(*inputs)]

@inplace_allocempty(GpuGemm, 0)
def local_inplace_gpuagemm(node, inputs):
    return [gpugemm_inplace(*inputs)]

@inplace_allocempty(GpuGer, 0)
def local_inplace_gpuager(node, inputs):
    return [gpuger_inplace(*inputs)]

gpuablas_opt_inplace = in2out(LocalOptGroup(local_inplace_gpuagemv,
                                            local_inplace_gpuagemm,
                                            local_inplace_gpuager),
                              name='gpuablas_opt_inplace')

optdb.register('InplaceGpuaBlasOpt',
               gpuablas_opt_inplace,
               70.0, 'fast_run', 'inplace', 'gpuarray')

{'repo_name': 'mkusner/grammarVAE', 'stars': '193', 'repo_language': 'Python', 'file_name': 'pycuda_double_op.py', 'mime_type': 'text/x-python', 'hash': 7464482337962137883, 'source_dataset': 'data'}


// Copyright 2017 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "content/public/test/test_navigation_ui_data.h"

#include <memory>

namespace content {

std::unique_ptr<NavigationUIData> TestNavigationUIData::Clone() {
  return std::make_unique<TestNavigationUIData>();
}

}  // namespace content

{'repo_name': 'nwjs/chromium.src', 'stars': '111', 'repo_language': 'None', 'file_name': 'AndroidManifest.xml', 'mime_type': 'text/xml', 'hash': 606371700882733897, 'source_dataset': 'data'}


<?php

/*
 * This file is part of the Symfony package.
 *
 * (c) Fabien Potencier <fabien@symfony.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Symfony\Component\Security\Core\Tests\Role;

use Symfony\Component\Security\Core\Role\Role;

class RoleTest extends \PHPUnit_Framework_TestCase
{
    public function testGetRole()
    {
        $role = new Role('FOO');

        $this->assertEquals('FOO', $role->getRole());
    }
}

{'repo_name': '5-say/laravel-4.1-quick-start-cn', 'stars': '144', 'repo_language': 'PHP', 'file_name': 'github.css', 'mime_type': 'text/plain', 'hash': -4130621524817217631, 'source_dataset': 'data'}


<?php

$xml =<<<EOF
<?xml version="1.0" encoding="ISO-8859-1" ?>
<foo/>
EOF;

$sxe = simplexml_load_string($xml);

$sxe[""] = "warning";
$sxe["attr"] = "value";

echo $sxe->asXML();

$sxe["attr"] = "new value";

echo $sxe->asXML();

$sxe[] = "error";

__HALT_COMPILER();
?>
===DONE===

{'repo_name': 'stephens2424/php', 'stars': '509', 'repo_language': 'Go', 'file_name': 'fmt.go', 'mime_type': 'text/x-c', 'hash': -8821917791502125984, 'source_dataset': 'data'}


---
title: 1016 - CompleteCompletionWorkItem
ms.date: 03/30/2017
ms.assetid: 246929fb-6f14-440a-814b-cd8349350644
ms.openlocfilehash: 3f0904a561a242cd3be528c9707a409b6f98e0fe
ms.sourcegitcommit: 9b552addadfb57fab0b9e7852ed4f1f1b8a42f8e
ms.translationtype: MT
ms.contentlocale: es-ES
ms.lasthandoff: 04/23/2019
ms.locfileid: "61925091"
---
# 1016 - CompleteCompletionWorkItem
## Propiedades

|||
|-|-|
|ID|1016|
|Palabras clave|WFRuntime|
|Nivel|Detallado|
|Canal|Microsoft-Windows-Application Server-Applications/Debug|

## Descripción
 Indica que se ha completado un CompletionWorkItem.

## Mensaje
 Un CompletionWorkItem se ha completado para la actividad primaria '%1', DisplayName: '%2', InstanceId: '%3'. Actividad completada '%4', DisplayName: '%5', InstanceId: '%6'.

## Detalles

|Nombre del elemento de datos|Tipo del elemento de datos|Descripción|
|--------------------|--------------------|-----------------|
|ParentActivity|xs:string|Nombre del tipo de la actividad principal.|
|ParentDisplayName|xs:string|Identificación y nombre para mostrar de la actividad principal.|
|ParentInstanceId|xs:string|Identificador de instancia de la actividad principal.|
|CompletedActivity|xs:string|El nombre del tipo de la actividad que se completó.|
|CompletedActivityDisplayName|xs:string|Nombre para mostrar de la actividad que se ha completado.|
|CompletedActivityInstanceId|xs:string|Identificador de instancia de la actividad que se ha completado.|
|AppDomain|xs:string|La cadena devuelta por AppDomain.CurrentDomain.FriendlyName.|

{'repo_name': 'dotnet/docs.es-es', 'stars': '120', 'repo_language': 'PowerShell', 'file_name': 'index.md', 'mime_type': 'text/plain', 'hash': 7944387464672782726, 'source_dataset': 'data'}


<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <ItemGroup Label="ProjectConfigurations">
    <ProjectConfiguration Include="Debug|Win32">
      <Configuration>Debug</Configuration>
      <Platform>Win32</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Release|Win32">
      <Configuration>Release</Configuration>
      <Platform>Win32</Platform>
    </ProjectConfiguration>
  </ItemGroup>
  <PropertyGroup Label="Globals">
    <ProjectGuid>{C9A024A7-D638-4F7A-8741-D16EBBF2643F}</ProjectGuid>
    <RootNamespace>SimpleObfuscation</RootNamespace>
    <Keyword>Win32Proj</Keyword>
  </PropertyGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
    <ConfigurationType>Application</ConfigurationType>
    <PlatformToolset>v140</PlatformToolset>
    <CharacterSet>Unicode</CharacterSet>
    <WholeProgramOptimization>true</WholeProgramOptimization>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
    <ConfigurationType>Application</ConfigurationType>
    <PlatformToolset>v140</PlatformToolset>
    <CharacterSet>Unicode</CharacterSet>
  </PropertyGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
  <ImportGroup Label="ExtensionSettings">
  </ImportGroup>
  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
  </ImportGroup>
  <PropertyGroup Label="UserMacros" />
  <PropertyGroup>
    <_ProjectFileVersion>14.0.24730.2</_ProjectFileVersion>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
    <OutDir>$(SolutionDir)$(Configuration)\</OutDir>
    <IntDir>$(Configuration)\</IntDir>
    <LinkIncremental>true</LinkIncremental>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
    <OutDir>$(SolutionDir)$(Configuration)\</OutDir>
    <IntDir>$(Configuration)\</IntDir>
    <LinkIncremental>false</LinkIncremental>
  </PropertyGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
    <ClCompile>
      <Optimization>Disabled</Optimization>
      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <MinimalRebuild>true</MinimalRebuild>
      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
      <PrecompiledHeader />
      <WarningLevel>Level3</WarningLevel>
      <DebugInformationFormat>EditAndContinue</DebugInformationFormat>
    </ClCompile>
    <Link>
      <GenerateDebugInformation>true</GenerateDebugInformation>
      <SubSystem>Console</SubSystem>
      <TargetMachine>MachineX86</TargetMachine>
    </Link>
  </ItemDefinitionGroup>
  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
    <ClCompile>
      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
      <PrecompiledHeader />
      <WarningLevel>Level3</WarningLevel>
      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
    </ClCompile>
    <Link>
      <GenerateDebugInformation>true</GenerateDebugInformation>
      <SubSystem>Console</SubSystem>
      <OptimizeReferences>true</OptimizeReferences>
      <EnableCOMDATFolding>true</EnableCOMDATFolding>
      <TargetMachine>MachineX86</TargetMachine>
    </Link>
  </ItemDefinitionGroup>
  <ItemGroup>
    <ClCompile Include="main.cpp" />
    <ClCompile Include="SimpleObf.cpp" />
  </ItemGroup>
  <ItemGroup>
    <ClInclude Include="SimpleObf.h" />
  </ItemGroup>
  <ItemGroup>
    <Text Include="Changelog.txt" />
  </ItemGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
  <ImportGroup Label="ExtensionTargets">
  </ImportGroup>
</Project>

{'repo_name': 'rootm0s/Protectors', 'stars': '318', 'repo_language': 'C++', 'file_name': 'CL.write.1.tlog', 'mime_type': 'text/plain', 'hash': 1533711684416258195, 'source_dataset': 'data'}


/*
XOWA: the XOWA Offline Wiki Application
Copyright (C) 2012-2017 gnosygnu@gmail.com

XOWA is licensed under the terms of the General Public License (GPL) Version 3,
or alternatively under the terms of the Apache License Version 2.0.

You may use XOWA according to either of these licenses as is most appropriate
for your project on a case-by-case basis.

The terms of each license can be found in the source code repository:

GPLv3 License: https://github.com/gnosygnu/xowa/blob/master/LICENSE-GPLv3.txt
Apache License: https://github.com/gnosygnu/xowa/blob/master/LICENSE-APACHE2.txt
*/
package gplx.xowa.bldrs.wms.dump_pages; import gplx.*; import gplx.xowa.*; import gplx.xowa.bldrs.*; import gplx.xowa.bldrs.wms.*;
import org.junit.*;
import gplx.xowa.wikis.domains.*;
public class Xowmf_wiki_dump_dirs_parser_tst {
	@Before public void init() {fxt.Clear();} private final Xowmf_wiki_dump_dirs_parser_fxt fxt = new Xowmf_wiki_dump_dirs_parser_fxt();
	@Test  public void Basic() {
		fxt.Test_parse("20141230/20150118/", "20141230", "20150118");
	}
	@Test  public void Example() {	// http://dumps.wikimedia.org/jawiki/
		fxt.Test_parse(String_.Concat_lines_nl_skip_last
		( ""
		, "<title>Index of /jawiki/</title>"
		, ""
		, "
Index of /jawiki/

../"
		, "20141122/                                          25-Nov-2014 22:04                   -"
		, "20141211/                                          14-Dec-2014 09:25                   -"
		, "20141230/                                          02-Jan-2015 09:02                   -"
		, "20150118/                                          21-Jan-2015 04:39                   -"
		, "20150221/                                          24-Feb-2015 17:51                   -"
		, "20150313/                                          16-Mar-2015 14:37                   -"
		, "20150402/                                          05-Apr-2015 06:19                   -"
		, "20150422/                                          25-Apr-2015 13:52                   -"
		, "20150512/                                          15-May-2015 08:17                   -"
		, "20150602/                                          16-Jun-2015 01:34                   -"
		, "20150703/                                          08-Jul-2015 14:44                   -"
		, "latest/                                            08-Jul-2015 14:44                   -"
		, "

"
		, ""
		)
		, "20141122"
		, "20141211"
		, "20141230"
		, "20150118"
		, "20150221"
		, "20150313"
		, "20150402"
		, "20150422"
		, "20150512"
		, "20150602"
		, "20150703"
		, "latest"
		);
	}
}
class Xowmf_wiki_dump_dirs_parser_fxt {
	public void Clear() {}
	public void Test_parse(String src, String... expd_dates) {
		String[] actl_dates = Xowmf_wiki_dump_dirs_parser.Parse(Xow_domain_itm_.Bry__enwiki, Bry_.new_u8(src));
		Tfds.Eq_ary_str(expd_dates, actl_dates);
	}
}

{'repo_name': 'gnosygnu/xowa', 'stars': '220', 'repo_language': 'Java', 'file_name': 'xowa_user_cfg.gfs', 'mime_type': 'text/plain', 'hash': -8769190589026384192, 'source_dataset': 'data'}


package com.bage.study.spring.boot.oauth2.client2;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import java.security.Principal;

@Controller
public class ProtectResourceController {

    @RequestMapping("/user")
    @ResponseBody
    public Principal user(Principal principal) {
        return principal;
    }

    @RequestMapping("/protectresource")
    public String protectresource() {
        return "protectresource";
    }

}

{'repo_name': 'bage2014/study', 'stars': '107', 'repo_language': 'Java', 'file_name': 'Receiver.java', 'mime_type': 'text/x-java', 'hash': -8357332551946892170, 'source_dataset': 'data'}


// -*-Mode: C++;-*- // technically C99

// * BeginRiceCopyright *****************************************************
//
// --------------------------------------------------------------------------
// Part of HPCToolkit (hpctoolkit.org)
//
// Information about sources of support for research and development of
// HPCToolkit is at 'hpctoolkit.org' and in 'README.Acknowledgments'.
// --------------------------------------------------------------------------
//
// Copyright ((c)) 2002-2020, Rice University
// 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 Rice University (RICE) 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 RICE 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 RICE 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.
//
// ******************************************************* EndRiceCopyright *

#ifndef __PERF_SKID_H__
#define __PERF_SKID_H__

// constants of precise_ip (see the man page)
#define PERF_EVENT_AUTODETECT_SKID       4
#define PERF_EVENT_SKID_ZERO_REQUIRED    3
#define PERF_EVENT_SKID_ZERO_REQUESTED   2
#define PERF_EVENT_SKID_CONSTANT         1
#define PERF_EVENT_SKID_ARBITRARY        0
#define PERF_EVENT_SKID_ERROR           -1

// parse the event into event_name and the type of precise_ip
//  the name of the event excludes the precise ip suffix
// returns:
//  PERF_EVENT_AUTODETECT_SKID
//  PERF_EVENT_SKID_ZERO_REQUIRED
//  PERF_EVENT_SKID_ZERO_REQUESTED
//  PERF_EVENT_SKID_CONSTANT
//  PERF_EVENT_SKID_ARBITRARY
//  PERF_EVENT_SKID_NONE
//  PERF_EVENT_SKID_ERROR
int
perf_skid_parse_event(const char *event_string, char **event_string_without_skidmarks);

int
perf_skid_set_max_precise_ip(struct perf_event_attr *attr);

u64
perf_skid_get_precise_ip(struct perf_event_attr *attr);
#endif

{'repo_name': 'HPCToolkit/hpctoolkit', 'stars': '171', 'repo_language': 'C++', 'file_name': 'Makefile.am', 'mime_type': 'text/plain', 'hash': 7492114810487897362, 'source_dataset': 'data'}


namespace Eigen {

/** \eigenManualPage TopicStlContainers Using STL Containers with Eigen

\eigenAutoToc

\section summary Executive summary

Using STL containers on \ref TopicFixedSizeVectorizable "fixed-size vectorizable Eigen types", or classes having members of such types, requires taking the following two steps:

\li A 16-byte-aligned allocator must be used. Eigen does provide one ready for use: aligned_allocator.
\li If you want to use the std::vector container, you need to \#include <Eigen/StdVector>.

These issues arise only with \ref TopicFixedSizeVectorizable "fixed-size vectorizable Eigen types" and \ref TopicStructHavingEigenMembers "structures having such Eigen objects as member". For other Eigen types, such as Vector3f or MatrixXd, no special care is needed when using STL containers.

\section allocator Using an aligned allocator

STL containers take an optional template parameter, the allocator type. When using STL containers on \ref TopicFixedSizeVectorizable "fixed-size vectorizable Eigen types", you need tell the container to use an allocator that will always allocate memory at 16-byte-aligned locations. Fortunately, Eigen does provide such an allocator: Eigen::aligned_allocator.

For example, instead of
\code
std::map<int, Eigen::Vector4f>
\endcode
you need to use
\code
std::map<int, Eigen::Vector4f, std::less<int>,
         Eigen::aligned_allocator<std::pair<const int, Eigen::Vector4f> > >
\endcode
Note that the third parameter "std::less<int>" is just the default value, but we have to include it because we want to specify the fourth parameter, which is the allocator type.

\section vector The case of std::vector

The situation with std::vector was even worse (explanation below) so we had to specialize it for the Eigen::aligned_allocator type. In practice you \b must use the Eigen::aligned_allocator (not another aligned allocator), \b and \#include <Eigen/StdVector>.

Here is an example:
\code
#include<Eigen/StdVector>
/* ... */
std::vector<Eigen::Vector4f,Eigen::aligned_allocator<Eigen::Vector4f> >
\endcode

\subsection vector_spec An alternative - specializing std::vector for Eigen types

As an alternative to the recommended approach described above, you have the option to specialize std::vector for Eigen types requiring alignment.
The advantage is that you won't need to declare std::vector all over with Eigen::allocator. One drawback on the other hand side is that
the specialization needs to be defined before all code pieces in which e.g. std::vector<Vector2d> is used. Otherwise, without knowing the specialization
the compiler will compile that particular instance with the default std::allocator and you program is most likely to crash.

Here is an example:
\code
#include<Eigen/StdVector>
/* ... */
EIGEN_DEFINE_STL_VECTOR_SPECIALIZATION(Matrix2d)
std::vector<Eigen::Vector2d>
\endcode

<span class="note">\b Explanation: The resize() method of std::vector takes a value_type argument (defaulting to value_type()). So with std::vector<Eigen::Vector4f>, some Eigen::Vector4f objects will be passed by value, which discards any alignment modifiers, so a Eigen::Vector4f can be created at an unaligned location. In order to avoid that, the only solution we saw was to specialize std::vector to make it work on a slight modification of, here, Eigen::Vector4f, that is able to deal properly with this situation.
</span>

*/

}

{'repo_name': 'plumonito/dtslam', 'stars': '113', 'repo_language': 'C++', 'file_name': 'calibFaro.txt', 'mime_type': 'text/plain', 'hash': 3708719526761708319, 'source_dataset': 'data'}


/*
 * Copyright (c) 2017-2018 THL A29 Limited, a Tencent company. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
 *
 * Unless 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.
 */
package com.tencentcloudapi.cpdp.v20190820.models;

import com.tencentcloudapi.common.AbstractModel;
import com.google.gson.annotations.SerializedName;
import com.google.gson.annotations.Expose;
import java.util.HashMap;

public class QueryBankWithdrawCashDetailsRequest extends AbstractModel{

    /**
    * String(22)，商户号（签约客户号）
    */
    @SerializedName("MrchCode")
    @Expose
    private String MrchCode;

    /**
    * STRING(2)，功能标志（1: 当日; 2: 历史）
    */
    @SerializedName("FunctionFlag")
    @Expose
    private String FunctionFlag;

    /**
    * STRING(50)，见证子帐户的帐号
    */
    @SerializedName("SubAcctNo")
    @Expose
    private String SubAcctNo;

    /**
    * STRING(4)，查询标志（2: 提现; 3: 清分）
    */
    @SerializedName("QueryFlag")
    @Expose
    private String QueryFlag;

    /**
    * STRING(10)，页码（起始值为1，每次最多返回20条记录，第二页返回的记录数为第21至40条记录，第三页为41至60条记录，顺序均按照建立时间的先后）
    */
    @SerializedName("PageNum")
    @Expose
    private String PageNum;

    /**
    * STRING(8)，开始日期（若是历史查询，则必输，当日查询时，不起作用。格式：20190101）
    */
    @SerializedName("BeginDate")
    @Expose
    private String BeginDate;

    /**
    * STRING(8)，结束日期（若是历史查询，则必输，当日查询时，不起作用。格式：20190101）
    */
    @SerializedName("EndDate")
    @Expose
    private String EndDate;

    /**
    * STRING(1027)，保留域
    */
    @SerializedName("ReservedMsg")
    @Expose
    private String ReservedMsg;

    /**
    * STRING(12)，接入环境，默认接入沙箱环境。接入正式环境填"prod"
    */
    @SerializedName("Profile")
    @Expose
    private String Profile;

    /**
     * Get String(22)，商户号（签约客户号）
     * @return MrchCode String(22)，商户号（签约客户号）
     */
    public String getMrchCode() {
        return this.MrchCode;
    }

    /**
     * Set String(22)，商户号（签约客户号）
     * @param MrchCode String(22)，商户号（签约客户号）
     */
    public void setMrchCode(String MrchCode) {
        this.MrchCode = MrchCode;
    }

    /**
     * Get STRING(2)，功能标志（1: 当日; 2: 历史）
     * @return FunctionFlag STRING(2)，功能标志（1: 当日; 2: 历史）
     */
    public String getFunctionFlag() {
        return this.FunctionFlag;
    }

    /**
     * Set STRING(2)，功能标志（1: 当日; 2: 历史）
     * @param FunctionFlag STRING(2)，功能标志（1: 当日; 2: 历史）
     */
    public void setFunctionFlag(String FunctionFlag) {
        this.FunctionFlag = FunctionFlag;
    }

    /**
     * Get STRING(50)，见证子帐户的帐号
     * @return SubAcctNo STRING(50)，见证子帐户的帐号
     */
    public String getSubAcctNo() {
        return this.SubAcctNo;
    }

    /**
     * Set STRING(50)，见证子帐户的帐号
     * @param SubAcctNo STRING(50)，见证子帐户的帐号
     */
    public void setSubAcctNo(String SubAcctNo) {
        this.SubAcctNo = SubAcctNo;
    }

    /**
     * Get STRING(4)，查询标志（2: 提现; 3: 清分）
     * @return QueryFlag STRING(4)，查询标志（2: 提现; 3: 清分）
     */
    public String getQueryFlag() {
        return this.QueryFlag;
    }

    /**
     * Set STRING(4)，查询标志（2: 提现; 3: 清分）
     * @param QueryFlag STRING(4)，查询标志（2: 提现; 3: 清分）
     */
    public void setQueryFlag(String QueryFlag) {
        this.QueryFlag = QueryFlag;
    }

    /**
     * Get STRING(10)，页码（起始值为1，每次最多返回20条记录，第二页返回的记录数为第21至40条记录，第三页为41至60条记录，顺序均按照建立时间的先后）
     * @return PageNum STRING(10)，页码（起始值为1，每次最多返回20条记录，第二页返回的记录数为第21至40条记录，第三页为41至60条记录，顺序均按照建立时间的先后）
     */
    public String getPageNum() {
        return this.PageNum;
    }

    /**
     * Set STRING(10)，页码（起始值为1，每次最多返回20条记录，第二页返回的记录数为第21至40条记录，第三页为41至60条记录，顺序均按照建立时间的先后）
     * @param PageNum STRING(10)，页码（起始值为1，每次最多返回20条记录，第二页返回的记录数为第21至40条记录，第三页为41至60条记录，顺序均按照建立时间的先后）
     */
    public void setPageNum(String PageNum) {
        this.PageNum = PageNum;
    }

    /**
     * Get STRING(8)，开始日期（若是历史查询，则必输，当日查询时，不起作用。格式：20190101）
     * @return BeginDate STRING(8)，开始日期（若是历史查询，则必输，当日查询时，不起作用。格式：20190101）
     */
    public String getBeginDate() {
        return this.BeginDate;
    }

    /**
     * Set STRING(8)，开始日期（若是历史查询，则必输，当日查询时，不起作用。格式：20190101）
     * @param BeginDate STRING(8)，开始日期（若是历史查询，则必输，当日查询时，不起作用。格式：20190101）
     */
    public void setBeginDate(String BeginDate) {
        this.BeginDate = BeginDate;
    }

    /**
     * Get STRING(8)，结束日期（若是历史查询，则必输，当日查询时，不起作用。格式：20190101）
     * @return EndDate STRING(8)，结束日期（若是历史查询，则必输，当日查询时，不起作用。格式：20190101）
     */
    public String getEndDate() {
        return this.EndDate;
    }

    /**
     * Set STRING(8)，结束日期（若是历史查询，则必输，当日查询时，不起作用。格式：20190101）
     * @param EndDate STRING(8)，结束日期（若是历史查询，则必输，当日查询时，不起作用。格式：20190101）
     */
    public void setEndDate(String EndDate) {
        this.EndDate = EndDate;
    }

    /**
     * Get STRING(1027)，保留域
     * @return ReservedMsg STRING(1027)，保留域
     */
    public String getReservedMsg() {
        return this.ReservedMsg;
    }

    /**
     * Set STRING(1027)，保留域
     * @param ReservedMsg STRING(1027)，保留域
     */
    public void setReservedMsg(String ReservedMsg) {
        this.ReservedMsg = ReservedMsg;
    }

    /**
     * Get STRING(12)，接入环境，默认接入沙箱环境。接入正式环境填"prod"
     * @return Profile STRING(12)，接入环境，默认接入沙箱环境。接入正式环境填"prod"
     */
    public String getProfile() {
        return this.Profile;
    }

    /**
     * Set STRING(12)，接入环境，默认接入沙箱环境。接入正式环境填"prod"
     * @param Profile STRING(12)，接入环境，默认接入沙箱环境。接入正式环境填"prod"
     */
    public void setProfile(String Profile) {
        this.Profile = Profile;
    }

    /**
     * Internal implementation, normal users should not use it.
     */
    public void toMap(HashMap<String, String> map, String prefix) {
        this.setParamSimple(map, prefix + "MrchCode", this.MrchCode);
        this.setParamSimple(map, prefix + "FunctionFlag", this.FunctionFlag);
        this.setParamSimple(map, prefix + "SubAcctNo", this.SubAcctNo);
        this.setParamSimple(map, prefix + "QueryFlag", this.QueryFlag);
        this.setParamSimple(map, prefix + "PageNum", this.PageNum);
        this.setParamSimple(map, prefix + "BeginDate", this.BeginDate);
        this.setParamSimple(map, prefix + "EndDate", this.EndDate);
        this.setParamSimple(map, prefix + "ReservedMsg", this.ReservedMsg);
        this.setParamSimple(map, prefix + "Profile", this.Profile);

    }
}

{'repo_name': 'TencentCloud/tencentcloud-sdk-java', 'stars': '220', 'repo_language': 'Java', 'file_name': 'EvaluationExamples.java', 'mime_type': 'text/x-java', 'hash': 4925252502173894676, 'source_dataset': 'data'}


using System.IO;

namespace Lucene.Net.Codecs
{
    /*
     * Licensed to the Apache Software Foundation (ASF) under one or more
     * contributor license agreements.  See the NOTICE file distributed with
     * this work for additional information regarding copyright ownership.
     * The ASF licenses this file to You under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
     *
     * Unless 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.
     */

    using Directory = Lucene.Net.Store.Directory;
    using IOContext = Lucene.Net.Store.IOContext;
    using SegmentInfo = Lucene.Net.Index.SegmentInfo;

    /// <summary>
    /// Specifies an API for classes that can read <see cref="SegmentInfo"/> information.
    /// <para/>
    /// @lucene.experimental
    /// </summary>
    public abstract class SegmentInfoReader
    {
        /// <summary>
        /// Sole constructor. (For invocation by subclass
        /// constructors, typically implicit.)
        /// </summary>
        protected internal SegmentInfoReader()
        {
        }

        /// <summary>
        /// Read <see cref="SegmentInfo"/> data from a directory. </summary>
        /// <param name="directory"> Directory to read from. </param>
        /// <param name="segmentName"> Name of the segment to read. </param>
        /// <param name="context"> IO context. </param>
        /// <returns> Infos instance to be populated with data. </returns>
        /// <exception cref="IOException"> If an I/O error occurs. </exception>
        public abstract SegmentInfo Read(Directory directory, string segmentName, IOContext context);
    }
}

{'repo_name': 'apache/lucenenet', 'stars': '1387', 'repo_language': 'C#', 'file_name': 'settings.json', 'mime_type': 'text/plain', 'hash': 1300354671405834206, 'source_dataset': 'data'}


using System.Drawing;
using System.Windows.Forms;
using SmartTaskbar.Core;

namespace SmartTaskbar.Views
{
    public sealed class MenuButton : Button
    {
        public MenuButton()
        {
            FlatStyle = FlatStyle.Flat;
            BackColor = Color.Transparent;
            Size = new Size(230, 32);
            Margin = Padding.Empty;
            FlatAppearance.BorderSize = 0;
            Font = new Font("Segoe UI", 9F);
            TextAlign = ContentAlignment.MiddleLeft;
            TextImageRelation = TextImageRelation.ImageBeforeText;
            ImageAlign = ContentAlignment.TopLeft;
        }

        protected override void OnControlAdded(ControlEventArgs e)
        {
            base.OnControlAdded(e);
            UseVisualStyleBackColor = false;
        }

        protected override void OnPaint(PaintEventArgs pevent)
        {
            base.OnPaint(pevent);
            var isLight = InvokeMethods.IsLightTheme();
            ForeColor = ForeColor = isLight ? Color.Black : Color.White;
            FlatAppearance.MouseOverBackColor =
                FlatAppearance.MouseDownBackColor = isLight ? Color.White : Color.FromArgb(65, 65, 65);
        }
    }
}

{'repo_name': 'ChanpleCai/SmartTaskbar', 'stars': '523', 'repo_language': 'C#', 'file_name': 'AssemblyInfo.cs', 'mime_type': 'text/plain', 'hash': -1987930177927206562, 'source_dataset': 'data'}


Version: Sep 02 update

Modules:
hw 01d00000

0:000> s -a hw L1000000 "HUD_PlayerMove"
01e346ec  48 55 44 5f 50 6c 61 79-65 72 4d 6f 76 65 00 00  HUD_PlayerMove..
01e3471f  48 55 44 5f 50 6c 61 79-65 72 4d 6f 76 65 0a 00  HUD_PlayerMove..
01e34730  48 55 44 5f 50 6c 61 79-65 72 4d 6f 76 65 49 6e  HUD_PlayerMoveIn
01e34767  48 55 44 5f 50 6c 61 79-65 72 4d 6f 76 65 49 6e  HUD_PlayerMoveIn
01e3477c  48 55 44 5f 50 6c 61 79-65 72 4d 6f 76 65 54 65  HUD_PlayerMoveTe
01e347b7  48 55 44 5f 50 6c 61 79-65 72 4d 6f 76 65 54 65  HUD_PlayerMoveTe

0:000> s hw L1000000 ec 46 e3 01
01d0b2f3  ec 46 e3 01 52 ff d6 85-c0 a3 58 f5 f2 02 75 0d  .F..R.....X...u.

01d0b2f3 -1 == 01d0b2f2 is inside the function that builds the ClientFunctionTable

01d0b1e0 UnkBuildClientFunctionTable
01d0b1e0 55              push    ebp
01d0b1e1 8bec            mov     ebp,esp
01d0b1e3 56              push    esi
01d0b1e4 8b7508          mov     esi,dword ptr [ebp+8]
01d0b1e7 56              push    esi
01d0b1e8 e8a3fe0200      call    hw+0x3b090 (01d3b090)
01d0b1ed 83c404          add     esp,4
01d0b1f0 a30059e601      mov     dword ptr [hw!vgui::Frame::`vftable'+0x48b9c (01e65900)],eax
01d0b1f5 85c0            test    eax,eax
01d0b1f7 7513            jne     hw+0xb20c (01d0b20c)
01d0b1f9 56              push    esi
01d0b1fa 685045e301      push    offset hw!vgui::Frame::`vftable'+0x177ec (01e34550)
01d0b1ff e84cd20900      call    hw!CreateInterface+0x4b3a0 (01da8450)
01d0b204 a10059e601      mov     eax,dword ptr [hw!vgui::Frame::`vftable'+0x48b9c (01e65900)]
01d0b209 83c408          add     esp,8
01d0b20c 8b3514a1e101    mov     esi,dword ptr [hw!vgui::Frame::operator=+0x5b484 (01e1a114)]
01d0b212 686c45e301      push    offset hw!vgui::Frame::`vftable'+0x17808 (01e3456c) // "Initialize"
01d0b217 50              push    eax
01d0b218 c705fc58e60101000000 mov dword ptr [hw!vgui::Frame::`vftable'+0x48b98 (01e658fc)],offset <Unloaded_ud.drv> (00000001)
01d0b222 ffd6            call    esi
01d0b224 85c0            test    eax,eax
01d0b226 a340f5f202      mov     dword ptr [hw!qwglMakeCurrent+0x7a0a34 (02f2f540)],eax
...
01d0b2f2 68ec46e301      push    offset hw!vgui::Frame::`vftable'+0x17988 (01e346ec) // "HUD_PlayerMove"
01d0b2f7 52              push    edx
01d0b2f8 ffd6            call    esi
01d0b2fa 85c0            test    eax,eax
01d0b2fc a358f5f202      mov     dword ptr [hw!qwglMakeCurrent+0x7a0a4c (02f2f558)],eax

==>
01d0b226 => 02f2f540 is ClientFunctionTable

{'repo_name': 'advancedfx/advancedfx', 'stars': '179', 'repo_language': 'C++', 'file_name': 'Ref.h', 'mime_type': 'text/x-c++', 'hash': 7640338913030994563, 'source_dataset': 'data'}


/*****************************************************************************
 * var_list.cpp
 *****************************************************************************
 * Copyright (C) 2003 the VideoLAN team
 *
 * Authors: Cyril Deguet     <asmax@via.ecp.fr>
 *          Olivier Teulière <ipkiss@via.ecp.fr>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
 *****************************************************************************/

#include "var_list.hpp"

const std::string VarList::m_type = "list";

VarList::VarList( intf_thread_t *pIntf ): Variable( pIntf )
{
    // Create the position variable
    m_cPosition = VariablePtr( new VarPercent( pIntf ) );
    getPositionVar().set( 1.0 );
}

VarList::~VarList()
{
}

void VarList::add( const UStringPtr &rcString )
{
    m_list.push_back( Elem_t( rcString ) );
    notify();
}

void VarList::delSelected()
{
    Iterator it = begin();
    while( it != end() )
    {
        if( (*it).m_selected )
        {
            Iterator oldIt = it;
            ++it;
            m_list.erase( oldIt );
        }
        else
        {
            ++it;
        }
    }
    notify();
}

void VarList::clear()
{
    m_list.clear();
}

VarList::Iterator VarList::operator[]( int n )
{
    Iterator it = begin();
    for( int i = 0; i < n; i++ )
    {
        if( it != end() )
        {
            it++;
        }
        else
        {
            break;
        }
    }
    return it;
}

VarList::ConstIterator VarList::operator[]( int n ) const
{
    ConstIterator it = begin();
    for( int i = 0; i < n; i++ )
    {
        if( it != end() )
        {
            it++;
        }
        else
        {
            break;
        }
    }
    return it;
}

{'repo_name': 'videolan/vlc', 'stars': '6334', 'repo_language': 'C', 'file_name': 'mpris.py', 'mime_type': 'text/x-python', 'hash': -890656127392862444, 'source_dataset': 'data'}


package com.github.houbb.markdown.toc.vo;

import org.junit.Test;

/**
* TocVo Tester.
*
* @author author
* @since 2018-01-30 15:11:47.253
* @version 1.0
*/
public class TocVoTest {

    /**
    *
    * Method: TocVo(origin)
    */
    @Test
    public void TocVoTest() throws Exception {
    }

    /**
    *
    * Method: rootToc()
    */
    @Test
    public void rootTocTest() throws Exception {
    }

    /**
    *
    * Method: getOrigin()
    */
    @Test
    public void getOriginTest() throws Exception {
    }

    /**
    *
    * Method: setOrigin(origin)
    */
    @Test
    public void setOriginTest() throws Exception {
    }

    /**
    *
    * Method: getLevel()
    */
    @Test
    public void getLevelTest() throws Exception {
    }

    /**
    *
    * Method: setLevel(level)
    */
    @Test
    public void setLevelTest() throws Exception {
    }

    /**
    *
    * Method: getTocTitle()
    */
    @Test
    public void getTocTitleTest() throws Exception {
    }

    /**
    *
    * Method: setTocTitle(tocTitle)
    */
    @Test
    public void setTocTitleTest() throws Exception {
    }

    /**
    *
    * Method: getTocHref()
    */
    @Test
    public void getTocHrefTest() throws Exception {
    }

    /**
    *
    * Method: setTocHref(tocHref)
    */
    @Test
    public void setTocHrefTest() throws Exception {
    }

    /**
    *
    * Method: getChildren()
    */
    @Test
    public void getChildrenTest() throws Exception {
    }

    /**
    *
    * Method: setChildren(children)
    */
    @Test
    public void setChildrenTest() throws Exception {
    }

    /**
    *
    * Method: getParent()
    */
    @Test
    public void getParentTest() throws Exception {
    }

    /**
    *
    * Method: setParent(parent)
    */
    @Test
    public void setParentTest() throws Exception {
    }

}

{'repo_name': 'houbb/markdown-toc', 'stars': '119', 'repo_language': 'Java', 'file_name': 'CHANGELOG-ENGLISH.MD', 'mime_type': 'text/plain', 'hash': 6465649971056416872, 'source_dataset': 'data'}