@xiaotianxt/skills 0.1.0

package/skills/calendar/scripts/event_dedupe_preview.py

@@ -0,0 +1,155 @@
+#!/usr/bin/env python3
+
+import argparse
+import json
+import sys
+from collections import Counter
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+
+def load_items(path: Path) -> list[dict[str, Any]]:
+    with path.open(encoding="utf-8") as handle:
+        payload = json.load(handle)
+    if isinstance(payload, dict):
+        items = payload.get("items", [])
+    elif isinstance(payload, list):
+        items = payload
+    else:
+        raise SystemExit(f"Unsupported JSON shape in {path}")
+    if not isinstance(items, list):
+        raise SystemExit(f"Expected items array in {path}")
+    return [item for item in items if isinstance(item, dict)]
+
+
+def event_start(event: dict[str, Any]) -> str:
+    start = event.get("start") or {}
+    if not isinstance(start, dict):
+        return ""
+    if start.get("date"):
+        return f"date:{start.get('date')}"
+    date_time = str(start.get("dateTime") or "")
+    return normalized_datetime(date_time)
+
+
+def normalized_datetime(value: str) -> str:
+    if not value:
+        return ""
+    candidate = value.replace("Z", "+00:00")
+    try:
+        parsed = datetime.fromisoformat(candidate)
+    except ValueError:
+        return " ".join(value.split())
+    if parsed.tzinfo is None:
+        return parsed.isoformat()
+    return parsed.astimezone(timezone.utc).isoformat()
+
+
+def event_start_display(event: dict[str, Any]) -> str:
+    start = event.get("start") or {}
+    if not isinstance(start, dict):
+        return ""
+    return str(start.get("dateTime") or start.get("date") or "")
+
+
+def event_location(event: dict[str, Any]) -> str:
+    return " ".join(str(event.get("location") or "").split()).casefold()
+
+
+def event_summary(event: dict[str, Any]) -> str:
+    return " ".join(str(event.get("summary") or "").split()).casefold()
+
+
+def event_signature(event: dict[str, Any]) -> tuple[str, str, str]:
+    return (event_summary(event), event_start(event), event_location(event))
+
+
+def short_event(event: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "id": event.get("id"),
+        "iCalUID": event.get("iCalUID"),
+        "summary": event.get("summary"),
+        "start": event.get("start"),
+        "end": event.get("end"),
+        "location": event.get("location"),
+        "htmlLink": event.get("htmlLink"),
+    }
+
+
+def build_preview(source: list[dict[str, Any]], target: list[dict[str, Any]]) -> dict[str, Any]:
+    target_ical_uids = Counter(
+        str(event.get("iCalUID"))
+        for event in target
+        if event.get("iCalUID")
+    )
+    target_signatures = Counter(event_signature(event) for event in target)
+
+    matches: list[dict[str, Any]] = []
+    unmatched: list[dict[str, Any]] = []
+    for event in source:
+        ical_uid = event.get("iCalUID")
+        by_ical_uid = bool(ical_uid and str(ical_uid) in target_ical_uids)
+        by_signature = event_signature(event) in target_signatures
+        match_count = max(
+            target_ical_uids[str(ical_uid)] if by_ical_uid else 0,
+            target_signatures[event_signature(event)] if by_signature else 0,
+        )
+        record = {
+            "matchedBy": "iCalUID" if by_ical_uid else "summary_start_location" if by_signature else None,
+            "targetMatchCount": match_count,
+            "ambiguous": match_count > 1,
+            "event": short_event(event),
+        }
+        if by_ical_uid or by_signature:
+            matches.append(record)
+        else:
+            unmatched.append(record)
+
+    return {
+        "source_count": len(source),
+        "target_count": len(target),
+        "matched_count": len(matches),
+        "unmatched_count": len(unmatched),
+        "matches": matches,
+        "unmatched": unmatched,
+    }
+
+
+def print_tsv(preview: dict[str, Any]) -> None:
+    print("matched\tstart\tsummary\tlocation\tiCalUID")
+    for record in preview["unmatched"]:
+        event = record["event"]
+        print(
+            "\t".join(
+                [
+                    "false",
+                    event_start_display(event),
+                    str(event.get("summary") or ""),
+                    str(event.get("location") or ""),
+                    str(event.get("iCalUID") or ""),
+                ]
+            )
+        )
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Preview source calendar events not already present in a target events.list JSON export."
+    )
+    parser.add_argument("--source", required=True, help="Source events JSON from gws calendar events list.")
+    parser.add_argument("--target", required=True, help="Target events JSON from gws calendar events list.")
+    parser.add_argument("--format", choices=["json", "tsv"], default="json")
+    args = parser.parse_args()
+
+    preview = build_preview(load_items(Path(args.source)), load_items(Path(args.target)))
+    if args.format == "tsv":
+        print_tsv(preview)
+    else:
+        json.dump(preview, sys.stdout, ensure_ascii=False, indent=2)
+        print()
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/skills/canvas/SKILL.md

@@ -0,0 +1,70 @@
+---
+name: canvas
+description: "Use when Codex needs to work with Canvas LMS / Instructure through the Canvas API: listing courses, finding course IDs, reading syllabi, assignments, modules, pages, files, submissions, grades, rubrics, due dates, or calculating current/final/maximum course grades. Also use when a user asks to submit Canvas assignments or download Canvas course materials, while keeping Canvas tokens in macOS Keychain or environment variables."
+---
+
+# Canvas
+
+Use Canvas through the REST API first. Prefer API calls over browser automation for courses, grades, files, modules, pages, assignments, submissions, and syllabus data.
+
+This is a Canvas data-access skill. For full exam preparation planning, use
+`course-exam-review-planner` as the workflow owner and use this skill only for
+Canvas-specific data gathering and grade calculations.
+
+## Authentication
+
+- Default CMU Canvas base URL: `https://canvas.cmu.edu`.
+- Prefer a token in macOS Keychain at service `codex.canvas`, account `credential`.
+- Use `CANVAS_TOKEN_COMMAND='keychain-secret get codex.canvas credential'` or a local script that reads the same Keychain entry.
+- One-time migration from 1Password, when needed: `keychain-secret import-op codex.canvas credential 'op://Private/Canvas/credential'`.
+- Do not print Canvas tokens, auth headers, raw cookies, or secret values.
+- Use 1Password only as a scoped import/fallback source when the Keychain entry is missing.
+
+## Existing Local Helper
+
+When available, reuse:
+
+`/Users/yupeit/Documents/20-29 Academics & Research/20 CMU Course Materials/84-792 Policy Seminar II/canvas-api-research/canvas_api.py`
+
+Useful commands:
+
+```bash
+python3 canvas_api.py whoami
+python3 canvas_api.py courses
+python3 canvas_api.py raw-get /api/v1/users/self/courses --param 'include[]=total_scores' --param 'include[]=term'
+python3 canvas_api.py raw-get /api/v1/courses/COURSE_ID/assignment_groups --param 'include[]=assignments' --param 'include[]=submission'
+python3 canvas_api.py sync-course COURSE_ID --out OUT_DIR
+```
+
+Quote parameters containing `[]` in zsh, such as `'include[]=total_scores'`, or zsh will treat them as glob patterns.
+
+## Workflow
+
+1. Identify the course with `/api/v1/users/self/courses`, including `term` and `total_scores`.
+2. Fetch course details with `include[]=syllabus_body,total_scores` and verify whether `apply_assignment_group_weights` is true.
+3. Fetch assignment groups with `include[]=assignments` and `include[]=submission`.
+4. Summarize large JSON locally before showing results. Avoid dumping assignment descriptions, discussion bodies, attachment URLs, or secure params unless the user explicitly needs them.
+5. For grade questions, inspect the syllabus PDF or page for grade cutoffs, rounding rules, drop rules, late penalties, and optional or extra-credit treatment.
+6. Reconcile Canvas enrollment scores with local calculations. Canvas may apply muted grades, drop rules, optional assignments, hidden rules, excused submissions, or grading-period settings.
+
+## Grade Calculation Notes
+
+- If `apply_assignment_group_weights` is true, calculate each group separately and multiply by `group_weight`.
+- Exclude unpublished assignments and assignments with `omit_from_final_grade=true`.
+- Treat `excused` submissions as excluded.
+- Distinguish current score from final score:
+  - Current score usually ignores ungraded assignments.
+  - Final score often treats ungraded assignments as zero.
+  - Maximum possible score gives full credit for remaining ungraded assignments.
+- Always check syllabus rules for drops. Canvas assignment group API may not fully explain the visible gradebook calculation unless group rules are included or inferred from the syllabus.
+- When answering "can I get an A?", report the current Canvas score, final score, remaining assignments, required score on remaining work, and the grade cutoff/rounding rule with exact dates when relevant.
+
+## Files And Syllabus
+
+- A syllabus page may link to a full syllabus PDF through a Canvas file endpoint. Fetch file metadata from `/api/v1/courses/:course_id/files/:file_id`, then download the `url` field.
+- Use `pdftotext` when available to extract grade intervals and policy details from syllabus PDFs.
+- Course files and media may be external LTI systems. Canvas often exposes only the link, iframe, or file metadata, not the original video or external resource.
+
+## References
+
+- Read `references/canvas-api.md` for endpoint patterns, pagination, output shaping, and the lessons learned from prior Canvas grade work.

package/skills/canvas/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Canvas"
+  short_description: "Use Canvas LMS API safely and efficiently."
+  default_prompt: "Use Canvas to inspect my courses, assignments, submissions, grades, files, pages, modules, or deadlines."

package/skills/canvas/references/canvas-api.md

@@ -0,0 +1,76 @@
+# Canvas API Reference
+
+## Token And Sandbox
+
+- Prefer macOS Keychain service `codex.canvas`, account `credential`, for the Canvas API token.
+- Use `keychain-secret get codex.canvas credential` in `CANVAS_TOKEN_COMMAND`.
+- If the Keychain entry is missing, import it once with `keychain-secret import-op codex.canvas credential 'op://Private/Canvas/credential'`.
+- Never print the token or `Authorization: Bearer ...` header.
+
+## Common Endpoints
+
+- Current user: `GET /api/v1/users/self`
+- Courses: `GET /api/v1/users/self/courses`
+  - Useful params: `enrollment_state=active`, `include[]=term`, `include[]=total_scores`, `include[]=teachers`, `per_page=100`
+- Course details: `GET /api/v1/courses/:course_id`
+  - Useful params: `include[]=syllabus_body`, `include[]=total_scores`, `include[]=term`, `include[]=teachers`
+- Assignment groups: `GET /api/v1/courses/:course_id/assignment_groups`
+  - Useful params: `include[]=assignments`, `include[]=submission`, `include[]=rules`, `per_page=100`
+- Assignments: `GET /api/v1/courses/:course_id/assignments`
+  - Useful params: `include[]=submission`, `include[]=rubric`, `per_page=100`
+- Single submission: `GET /api/v1/courses/:course_id/assignments/:assignment_id/submissions/self`
+- Modules: `GET /api/v1/courses/:course_id/modules`
+  - Useful params: `include[]=items`, `include[]=content_details`, `per_page=100`
+- Pages: `GET /api/v1/courses/:course_id/pages`, then `GET /api/v1/courses/:course_id/pages/:url`
+- Files: `GET /api/v1/courses/:course_id/files` or `GET /api/v1/courses/:course_id/files/:file_id`
+- Announcements: `GET /api/v1/announcements?context_codes[]=course_:course_id`
+- Discussions: `GET /api/v1/courses/:course_id/discussion_topics`
+
+Always quote zsh args containing brackets:
+
+```bash
+--param 'include[]=total_scores'
+```
+
+## Pagination
+
+Canvas uses HTTP `Link` headers for pagination. Prefer a helper that follows `rel="next"`. Set `per_page=100` for list calls.
+
+## Output Shaping
+
+Canvas assignment objects can contain huge HTML descriptions, rubrics, discussion entries, secure params, and attachment metadata. For user-facing answers, reduce to:
+
+- `id`, `name`, `due_at`, `points_possible`
+- assignment group name and weight
+- submission `score`, `grade`, `workflow_state`, `submitted_at`, `graded_at`
+- `late`, `missing`, `excused`, `points_deducted`
+- flags: `muted`, `omit_from_final_grade`, `published`, `locked_for_user`
+
+Do not dump discussion bodies or secure params unless the task requires them.
+
+## Grade Workflows
+
+For "what grade can I get?" questions:
+
+1. Fetch course list with total scores and identify the course ID.
+2. Fetch `assignment_groups` with assignments and submissions.
+3. Pull syllabus body. If it links a PDF syllabus, download it through the file endpoint and extract text with `pdftotext`.
+4. Find:
+   - grade intervals and rounding rules
+   - assignment group weights
+   - drop rules for quizzes, discussions, and in-class work
+   - late-day credits and final-assignment penalties
+5. Calculate:
+   - current weighted score from graded work only
+   - final score with ungraded work as zero
+   - max score if remaining work earns full credit
+   - required score on remaining work for each relevant letter cutoff
+6. Compare against Canvas `computed_current_score` and `computed_final_score`. If they differ, explain likely causes and prefer Canvas enrollment numbers when they directly answer current/final displayed grade.
+
+## Lessons From 17-629
+
+- CMU Canvas course `Product Management Essentials II` used group weights: Product Assignments 74%, In-Class Exercises 10%, Short Quizzes 10%, Discussions 6%.
+- The syllabus PDF, not just the Canvas syllabus HTML excerpt, contained grade intervals and rounding rules.
+- The course had drop rules: lowest two in-class activities, lowest quiz, lowest discussion.
+- A raw assignment-groups response was too large for direct display. A temporary summarizer was the right pattern.
+- Canvas displayed `computed_current_score` and `computed_final_score`; the answer needed both and a required remaining-assignment score.

package/skills/course-exam-review-planner/SKILL.md

@@ -0,0 +1,127 @@
+---
+name: course-exam-review-planner
+description: Build an evidence-driven review plan for a course exam or final. Use when the user wants to prepare for a new course exam by collecting recordings/transcripts, identifying the official exam scope, mining homework/practice exams/past exams/forums, and turning the result into a concrete study plan or Things 3 project.
+---
+
+# Course Exam Review Planner
+
+Use this skill when planning how to review for a course exam, especially when the course has lecture recordings, transcripts, homeworks, practice exams, previous exams, or forum discussions.
+
+This skill owns the exam-review workflow. Use neighboring tool skills for data
+access and execution details: `canvas` for Canvas LMS data,
+`panopto-mp4-bulk-download` for lecture media extraction, and
+`things3-manager` for Things 3 task creation.
+
+## Core Principle
+
+Do not start by making a generic day-by-day schedule. First reconstruct the exam contract:
+
+1. What is definitely in scope?
+2. What question formats are likely?
+3. What skills are repeatedly tested?
+4. What artifacts best train those skills?
+5. What should be converted into retrieval drills, an error log, and a final cheat sheet?
+
+Treat evidence by priority:
+
+1. Official exam page, final guide, syllabus, instructor announcement.
+2. The lecture or recording that explicitly describes the final exam.
+3. Latest official practice exam and solutions.
+4. Homework, projects, recitations, quizzes, and midterms that overlap the final scope.
+5. Older official exams from the same course/instructor.
+6. Online forums, Reddit, reviews, and student notes as weak signals only. Use them to discover likely pain points, not to override official materials.
+
+## Inputs To Gather
+
+Ask for or locate:
+
+- Course name/number and term.
+- Exam date, time, location, duration, allowed materials, grading weight.
+- Course website, LMS/exported folder, syllabus, final guide, announcements.
+- Full lecture recordings and transcripts. If recordings are on Panopto, use the `panopto-mp4-bulk-download` skill when bulk download is needed.
+- Homework PDFs, solution PDFs, quizzes, midterm/final practice exams, previous exams.
+- Existing notes, cheat sheet constraints, and user time availability.
+- User's target outcome: pass, high grade, or mastery.
+
+## Workflow
+
+1. Build the corpus.
+   - Ensure all recordings are downloaded or accessible.
+   - Ensure every recording has a transcript or searchable text.
+   - Collect PDFs and HTML pages into a single course material directory when possible.
+   - Make local files searchable with filenames that preserve topic, date, and artifact type.
+
+2. Find the exam contract.
+   - Search transcripts for phrases like `final exam`, `scope`, `cumulative`, `practice final`, `cheat sheet`, `allowed`, `logistics`, `review`.
+   - Identify the recording or lecture segment that most directly describes the final.
+   - Extract concrete facts: covered lectures, textbook chapters, excluded topics, exam length, question count, point count, allowed materials, date/time/location.
+   - If relative dates appear, convert them into exact dates.
+
+3. Map official scope to artifacts.
+   - Create a table with columns: topic, official source, lecture numbers, textbook sections, homework questions, practice exam questions, older exam questions.
+   - Prefer the newest practice exam as the primary diagnostic.
+   - Use homework only where it trains concepts that appear in the final scope.
+   - Use older exams to add coverage for recurring question archetypes.
+
+4. Mine external and historical signals.
+   - Search official archives first.
+   - Then search online forums, Reddit, course reviews, and public notes for recurring complaints, surprise topics, or highly emphasized question types.
+   - Mark these as weak evidence unless they are confirmed by official materials.
+   - Do not overfit to rumors or outdated terms.
+
+5. Classify question archetypes.
+   - For each practice/past exam question, record: topic, required procedure, common trap, source artifact, and whether it is calculation, proof, design, debugging, short answer, or concept recognition.
+   - Convert each archetype into a closed-book drill template.
+   - Prioritize procedural templates that can be repeated cold.
+
+6. Plan backward from the exam.
+   - Day 1: run the newest practice exam cold by topic clusters; grade immediately; create error log.
+   - Middle days: backfill misses using homework, lectures, textbook sections, and older exams.
+   - Final day: redo every missed practice subpart cold; finalize the cheat sheet; stop learning new content.
+   - Keep review blocks tied to artifacts and completion criteria, not vague labels like "study transactions".
+
+7. Maintain an error log.
+   - Columns: question, missed rule, corrected rule, next drill.
+   - Every wrong or uncertain answer gets a rule-level entry.
+   - The final-day review is driven from the error log, not from rereading slides.
+
+8. Build the cheat sheet.
+   - Include distilled rules, formulas, state machines, algorithms, and decision tables.
+   - Exclude copied slides or long explanations.
+   - Every cheat-sheet line should answer a known question archetype or correct an error-log miss.
+
+9. Produce an action plan.
+   - Group tasks by date and topic cluster.
+   - Each task should name exact files, questions, and completion criteria.
+   - If using Things 3, create a project with headings by day/topic and verify the import with `things3-manager`.
+
+## Output Shape
+
+For a normal planning request, produce:
+
+1. A short summary of the confirmed exam contract.
+2. A scope map from official topics to course artifacts.
+3. A prioritized review plan by day.
+4. A list of closed-book drill templates.
+5. A cheat-sheet outline.
+6. A Things-ready task breakdown when the user wants task management output.
+
+## Lessons From The 15-445 Final Review Plan
+
+In the 15-445 run, the useful pattern was:
+
+1. Confirm the official final scope from the final guide: textbook chapters, lecture numbers, date/time/location, duration, point count, and allowed notes.
+2. Treat the newest S26 practice final as the main diagnostic and solution source.
+3. Split the exam into topic clusters: query processing/joins, transactions/MVCC, recovery/ARIES, distributed systems.
+4. Attach each cluster to specific practice questions, homework backfills, older exam drills, and cheat-sheet blocks.
+5. Make an error log the central artifact.
+6. Schedule the final pass around redoing misses cold, completing the handwritten note page, and packing exam materials.
+7. Import the resulting project into Things and verify that the tasks exist.
+
+## Guardrails
+
+- Never rely on forum posts as the source of truth for scope.
+- Do not spend time on pre-scope or explicitly excluded content unless it is prerequisite knowledge for an in-scope procedure.
+- Do not reread lectures passively when there are practice questions available.
+- Do not build a plan without exact artifacts and completion criteria.
+- When current course pages, forum posts, or online archives may have changed, browse or verify before citing them.

package/skills/cx/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: cx
+description: Use when Codex needs to operate the local Codex multi-slot workflow with cx, including selecting the best slot, checking usage, creating or logging into slots, or validating slot state.
+---
+
+# cx
+
+Canonical source: https://github.com/xiaotianxt/skills/tree/main/skills/cx
+
+Use this skill when you need to operate the local Codex multi-slot workflow.
+
+## Commands
+
+- `cx`: run Codex through the best available slot.
+- `cat file | cx "prompt"`: wrap stdin as Codex prompt context.
+- `cx status`: show all configured slots and live usage.
+- `cx select`: print the best slot name.
+- `cx add <slot> --rotate`: create a slot and add it to rotation.
+- `cx login <slot>`: log into a slot-specific `CODEX_HOME`.
+- `cx doctor --online`: validate local layout and query usage.
+
+## Safety
+
+Do not print `auth.json`, access tokens, or `env.conf` values. These files may
+contain live credentials.

package/skills/gh-fix-ci/LICENSE.txt

@@ -0,0 +1,201 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf of
+   any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don\'t include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+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.