opencode-skills-collection 4.1.14 → 4.1.16

package/bundled-skills/cirq/references/transformation.md

@@ -0,0 +1,416 @@
+# Circuit Transformations
+
+This guide covers circuit optimization, compilation, and manipulation using Cirq's transformation framework.
+
+## Transformer Framework
+
+### Basic Transformers
+
+```python
+import cirq
+
+# Example circuit
+qubits = cirq.LineQubit.range(3)
+circuit = cirq.Circuit(
+    cirq.H(qubits[0]),
+    cirq.CNOT(qubits[0], qubits[1]),
+    cirq.CNOT(qubits[1], qubits[2])
+)
+
+# Apply built-in transformer
+from cirq.transformers import optimize_for_target_gateset
+
+# Optimize to specific gate set
+optimized = optimize_for_target_gateset(
+    circuit,
+    gateset=cirq.SqrtIswapTargetGateset()
+)
+```
+
+### Merge Single-Qubit Gates
+
+```python
+from cirq.transformers import merge_single_qubit_gates_to_phxz
+
+# Circuit with multiple single-qubit gates
+circuit = cirq.Circuit(
+    cirq.H(q),
+    cirq.T(q),
+    cirq.S(q),
+    cirq.H(q)
+)
+
+# Merge into single operation
+merged = merge_single_qubit_gates_to_phxz(circuit)
+```
+
+### Drop Negligible Operations
+
+```python
+from cirq.transformers import drop_negligible_operations
+
+# Remove gates below threshold
+circuit_with_small_rotations = cirq.Circuit(
+    cirq.rz(1e-10)(q),  # Very small rotation
+    cirq.H(q)
+)
+
+cleaned = drop_negligible_operations(circuit_with_small_rotations, atol=1e-8)
+```
+
+## Custom Transformers
+
+### Transformer Decorator
+
+```python
+from cirq.transformers import transformer_api
+
+@transformer_api.transformer
+def remove_z_gates(circuit: cirq.Circuit) -> cirq.Circuit:
+    """Remove all Z gates from circuit."""
+    new_moments = []
+    for moment in circuit:
+        new_ops = [op for op in moment if not isinstance(op.gate, cirq.ZPowGate)]
+        if new_ops:
+            new_moments.append(cirq.Moment(new_ops))
+    return cirq.Circuit(new_moments)
+
+# Use custom transformer
+transformed = remove_z_gates(circuit)
+```
+
+### Transformer Class
+
+```python
+from cirq.transformers import transformer_primitives
+
+class HToRyTransformer(transformer_primitives.Transformer):
+    """Replace H gates with Ry(π/2)."""
+
+    def __call__(self, circuit: cirq.Circuit, *, context=None) -> cirq.Circuit:
+        def map_op(op: cirq.Operation, _) -> cirq.OP_TREE:
+            if isinstance(op.gate, cirq.HPowGate):
+                return cirq.ry(np.pi/2)(op.qubits[0])
+            return op
+
+        return transformer_primitives.map_operations(
+            circuit,
+            map_op,
+            deep=True
+        ).unfreeze(copy=False)
+
+# Apply transformer
+transformer = HToRyTransformer()
+result = transformer(circuit)
+```
+
+## Gate Decomposition
+
+### Decompose to Target Gateset
+
+```python
+from cirq.transformers import optimize_for_target_gateset
+
+# Decompose to CZ + single-qubit rotations
+target_gateset = cirq.CZTargetGateset()
+decomposed = optimize_for_target_gateset(circuit, gateset=target_gateset)
+
+# Decompose to √iSWAP gates
+sqrt_iswap_gateset = cirq.SqrtIswapTargetGateset()
+decomposed = optimize_for_target_gateset(circuit, gateset=sqrt_iswap_gateset)
+```
+
+### Custom Gate Decomposition
+
+```python
+class Toffoli(cirq.Gate):
+    def _num_qubits_(self):
+        return 3
+
+    def _decompose_(self, qubits):
+        """Decompose Toffoli into basic gates."""
+        c1, c2, t = qubits
+        return [
+            cirq.H(t),
+            cirq.CNOT(c2, t),
+            cirq.T(t)**-1,
+            cirq.CNOT(c1, t),
+            cirq.T(t),
+            cirq.CNOT(c2, t),
+            cirq.T(t)**-1,
+            cirq.CNOT(c1, t),
+            cirq.T(c2),
+            cirq.T(t),
+            cirq.H(t),
+            cirq.CNOT(c1, c2),
+            cirq.T(c1),
+            cirq.T(c2)**-1,
+            cirq.CNOT(c1, c2)
+        ]
+
+# Use decomposition
+circuit = cirq.Circuit(Toffoli()(q0, q1, q2))
+decomposed = cirq.decompose(circuit)
+```
+
+## Circuit Optimization
+
+### Eject Z Gates
+
+```python
+from cirq.transformers import eject_z
+
+# Move Z gates to end of circuit
+circuit = cirq.Circuit(
+    cirq.H(q0),
+    cirq.Z(q0),
+    cirq.CNOT(q0, q1)
+)
+
+ejected = eject_z(circuit)
+```
+
+### Eject Phase Gates
+
+```python
+from cirq.transformers import eject_phased_paulis
+
+# Consolidate phase gates
+optimized = eject_phased_paulis(circuit, atol=1e-8)
+```
+
+### Drop Empty Moments
+
+```python
+from cirq.transformers import drop_empty_moments
+
+# Remove moments with no operations
+cleaned = drop_empty_moments(circuit)
+```
+
+### Align Measurements
+
+```python
+from cirq.transformers import dephase_measurements
+
+# Move measurements to end and remove operations after
+aligned = dephase_measurements(circuit)
+```
+
+## Circuit Compilation
+
+### Compile for Hardware
+
+```python
+import cirq_google
+
+# Get device specification
+device = cirq_google.Sycamore
+
+# Compile circuit to device
+from cirq.transformers import optimize_for_target_gateset
+
+compiled = optimize_for_target_gateset(
+    circuit,
+    gateset=cirq_google.SycamoreTargetGateset()
+)
+
+# Validate compiled circuit
+device.validate_circuit(compiled)
+```
+
+### Two-Qubit Gate Compilation
+
+```python
+# Compile to specific two-qubit gate
+from cirq import two_qubit_to_cz
+
+# Convert all two-qubit gates to CZ
+cz_circuit = cirq.Circuit()
+for moment in circuit:
+    for op in moment:
+        if len(op.qubits) == 2:
+            cz_circuit.append(two_qubit_to_cz(op))
+        else:
+            cz_circuit.append(op)
+```
+
+## Qubit Routing
+
+### Route Circuit to Device Topology
+
+```python
+from cirq.transformers import route_circuit
+
+# Define device connectivity
+device_graph = cirq.NamedTopology(
+    {
+        (0, 0): [(0, 1), (1, 0)],
+        (0, 1): [(0, 0), (1, 1)],
+        (1, 0): [(0, 0), (1, 1)],
+        (1, 1): [(0, 1), (1, 0)]
+    }
+)
+
+# Route logical qubits to physical qubits
+routed_circuit = route_circuit(
+    circuit,
+    device_graph=device_graph,
+    routing_algo=cirq.RouteCQC(device_graph)
+)
+```
+
+### SWAP Network Insertion
+
+```python
+# Manually insert SWAPs for routing
+def insert_swaps(circuit, swap_locations):
+    """Insert SWAP gates at specified locations."""
+    new_circuit = cirq.Circuit()
+    moment_idx = 0
+
+    for i, moment in enumerate(circuit):
+        if i in swap_locations:
+            q0, q1 = swap_locations[i]
+            new_circuit.append(cirq.SWAP(q0, q1))
+        new_circuit.append(moment)
+
+    return new_circuit
+```
+
+## Advanced Transformations
+
+### Unitary Compilation
+
+```python
+import scipy.linalg
+
+# Compile arbitrary unitary to gate sequence
+def compile_unitary(unitary, qubits):
+    """Compile 2x2 unitary using KAK decomposition."""
+    from cirq.linalg import kak_decomposition
+
+    decomp = kak_decomposition(unitary)
+    operations = []
+
+    # Add single-qubit gates before
+    operations.append(cirq.MatrixGate(decomp.single_qubit_operations_before[0])(qubits[0]))
+    operations.append(cirq.MatrixGate(decomp.single_qubit_operations_before[1])(qubits[1]))
+
+    # Add interaction (two-qubit) part
+    x, y, z = decomp.interaction_coefficients
+    operations.append(cirq.XXPowGate(exponent=x/np.pi)(qubits[0], qubits[1]))
+    operations.append(cirq.YYPowGate(exponent=y/np.pi)(qubits[0], qubits[1]))
+    operations.append(cirq.ZZPowGate(exponent=z/np.pi)(qubits[0], qubits[1]))
+
+    # Add single-qubit gates after
+    operations.append(cirq.MatrixGate(decomp.single_qubit_operations_after[0])(qubits[0]))
+    operations.append(cirq.MatrixGate(decomp.single_qubit_operations_after[1])(qubits[1]))
+
+    return operations
+```
+
+### Circuit Simplification
+
+```python
+from cirq.transformers import (
+    merge_k_qubit_unitaries,
+    merge_single_qubit_gates_to_phxz
+)
+
+# Merge adjacent single-qubit gates
+simplified = merge_single_qubit_gates_to_phxz(circuit)
+
+# Merge adjacent k-qubit unitaries
+simplified = merge_k_qubit_unitaries(circuit, k=2)
+```
+
+### Commutation-Based Optimization
+
+```python
+# Commute Z gates through CNOT
+def commute_z_through_cnot(circuit):
+    """Move Z gates through CNOT gates."""
+    new_moments = []
+
+    for moment in circuit:
+        ops = list(moment)
+        # Find Z gates before CNOT
+        z_ops = [op for op in ops if isinstance(op.gate, cirq.ZPowGate)]
+        cnot_ops = [op for op in ops if isinstance(op.gate, cirq.CXPowGate)]
+
+        # Apply commutation rules
+        # Z on control commutes, Z on target anticommutes
+        # (simplified logic here)
+
+        new_moments.append(cirq.Moment(ops))
+
+    return cirq.Circuit(new_moments)
+```
+
+## Transformation Pipelines
+
+### Compose Multiple Transformers
+
+```python
+from cirq.transformers import transformer_api
+
+# Build transformation pipeline
+@transformer_api.transformer
+def optimization_pipeline(circuit: cirq.Circuit) -> cirq.Circuit:
+    # Step 1: Merge single-qubit gates
+    circuit = merge_single_qubit_gates_to_phxz(circuit)
+
+    # Step 2: Drop negligible operations
+    circuit = drop_negligible_operations(circuit)
+
+    # Step 3: Eject Z gates
+    circuit = eject_z(circuit)
+
+    # Step 4: Drop empty moments
+    circuit = drop_empty_moments(circuit)
+
+    return circuit
+
+# Apply pipeline
+optimized = optimization_pipeline(circuit)
+```
+
+## Validation and Analysis
+
+### Circuit Depth Reduction
+
+```python
+# Measure circuit depth before and after
+print(f"Original depth: {len(circuit)}")
+optimized = optimization_pipeline(circuit)
+print(f"Optimized depth: {len(optimized)}")
+```
+
+### Gate Count Analysis
+
+```python
+def count_gates(circuit):
+    """Count gates by type."""
+    counts = {}
+    for moment in circuit:
+        for op in moment:
+            gate_type = type(op.gate).__name__
+            counts[gate_type] = counts.get(gate_type, 0) + 1
+    return counts
+
+original_counts = count_gates(circuit)
+optimized_counts = count_gates(optimized)
+print(f"Original: {original_counts}")
+print(f"Optimized: {optimized_counts}")
+```
+
+## Best Practices
+
+1. **Start with high-level transformers**: Use built-in transformers before writing custom ones
+2. **Chain transformers**: Apply multiple optimizations in sequence
+3. **Validate after transformation**: Ensure circuit correctness and device compatibility
+4. **Measure improvement**: Track depth and gate count reduction
+5. **Use appropriate gatesets**: Match target hardware capabilities
+6. **Consider commutativity**: Exploit gate commutation for optimization
+7. **Test on small circuits first**: Verify transformers work correctly before scaling

package/bundled-skills/cis-benchmarks/SKILL.md

@@ -19,7 +19,7 @@ metadata:
 
 # CIS Benchmarks
 
-Implement and audit CIS security benchmarks.
+Assess a selected benchmark/version against explicitly authorized systems. Scanner output is partial evidence, not certification; verify applicability, documented exceptions and operational impact before remediation.
 
 ## When to Use This Skill
 
@@ -37,12 +37,16 @@ Use this skill when:
 # Install
 apt install openscap-scanner scap-security-guide
 
-# Run CIS benchmark scan
+# Confirm installed content matches the actual OS and required benchmark/version.
+SCAP_FILE="<approved-installed-datastream.xml>"
+oscap info "$SCAP_FILE"
+PROFILE_ID="<exact-CIS-profile-listed-by-oscap-info>"
+# Run the selected assessment only after scope and report-location approval.
 oscap xccdf eval \
-  --profile xccdf_org.ssgproject.content_profile_cis \
+  --profile "$PROFILE_ID" \
   --results results.xml \
   --report report.html \
-  /usr/share/xml/scap/ssg/content/ssg-ubuntu2204-ds.xml
+  "$SCAP_FILE"
 ```
 
 ### Lynis
@@ -55,7 +59,7 @@ apt install lynis
 lynis audit system
 
 # Generate report
-lynis audit system --report-file /tmp/lynis-report.dat
+lynis audit system --report-file "$PRIVATE_AUDIT_DIR/lynis-report.dat"
 ```
 
 ### InSpec
@@ -91,10 +95,11 @@ inspec exec cis-profile -t ssh://user@target
 ```bash
 # kube-bench
 docker run --rm -v /etc:/etc:ro -v /var:/var:ro \
-  aquasec/kube-bench:latest run --targets node
+  aquasec/kube-bench@sha256:<reviewed-image-digest> run --targets node
 
 # Check specific sections
-kube-bench run --targets master --check 1.1,1.2
+kube-bench --help
+# Select role/sections supported by the reviewed version and actual cluster; do not assume master is a current target name.
 ```
 
 ## Remediation Workflow
@@ -137,14 +142,16 @@ workflow:
 
 ## Limitations
 
-- Apply guidance only within authorized scope; test destructive steps in non-production first.
+- An OpenSCAP/Lynis assessment may require privileges and read sensitive host configuration; approve the exact host, profile, privileges, private outputs and limits first. Do not enable auto-remediation or mount all host paths without reviewing necessity. A generic Lynis audit is not a complete CIS benchmark.
+- Benchmark/profile identifiers and installed SCAP content vary; use [OpenSCAP’s documented info/eval flow](https://static.open-scap.org/openscap-1.4.1/oscap_user_manual.html). Test changes and preserve rollback/access before hardening production.
 - Docs-only import: upstream scripts and templates not bundled.
 
 ### Example
 
 ```bash
 # Read-only first: inventory before any active step.
-which <tool> && <tool> --help | head -n 20
+command -v oscap
+oscap --version
 ```
 
 > Adapted from [BagelHole/DevOps-Security-Agent-Skills](https://github.com/BagelHole/DevOps-Security-Agent-Skills) (MIT); frontmatter, When to Use/Limitations, and safety boundaries added for upstream compliance. Docs-only import: helper scripts and templates not bundled.

package/bundled-skills/clarvia-aeo-check/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: clarvia-aeo-check
-description: "Score any MCP server, API, or CLI for agent-readiness using Clarvia AEO (Agent Experience Optimization). Search 15,400+ indexed tools before adding them to your workflow."
+description: "Score any MCP server, API, or CLI for agent-readiness using Clarvia AEO (Agent Experience Optimization). Use current provider evidence as advisory input when evaluating a tool."
 category: tool-quality
 risk: safe
 source: community
@@ -14,7 +14,7 @@ tools: [claude, cursor, windsurf, cline]
 
 ## Overview
 
-Before adding any MCP server, API, or CLI tool to your agent workflow, use Clarvia to score its agent-readiness. Clarvia evaluates 15,400+ AI tools across four AEO dimensions: API accessibility, data structuring, agent compatibility, and trust signals.
+When the user selects Clarvia, use its current index and scoring model as advisory input. Do not make a vendor score a mandatory prerequisite or security approval. Clarvia describes tools across four AEO dimensions: API accessibility, data structuring, agent compatibility, and trust signals.
 
 ## Prerequisites
 
@@ -25,7 +25,7 @@ Add Clarvia MCP server to your config:
   "mcpServers": {
     "clarvia": {
       "command": "npx",
-      "args": ["-y", "clarvia-mcp-server"]
+      "args": ["--yes", "clarvia-mcp-server@<reviewed-version>"]
     }
   }
 }
@@ -56,7 +56,7 @@ Clarvia returns a 0-100 AEO score with breakdown across four dimensions.
 Find the top-rated database MCP servers using Clarvia
 ```
 
-Returns ranked results from 15,400+ indexed tools.
+Returns provider-ranked results; record query date, index coverage and scoring limitations rather than a hardcoded total.
 
 ### Step 3: Compare tools head-to-head
 
@@ -92,10 +92,10 @@ top-rated options and compare the top 3.
 
 ### Example 3: CI/CD quality gate
 
-Add to your CI pipeline using the GitHub Action:
+Optional example for an explicitly requested advisory CI integration; verify the action’s repository, inputs and immutable revision before use:
 
 ```yaml
-- uses: clarvia-project/clarvia-action@v1
+- uses: clarvia-project/clarvia-action@<reviewed-full-commit-SHA>
   with:
     url: https://your-api.com
     fail-under: 70
@@ -109,14 +109,14 @@ Add to your CI pipeline using the GitHub Action:
 | 70-89 | Agent Friendly | Works well, minor gaps |
 | 50-69 | Agent Compatible | Works but needs improvement |
 | 30-49 | Agent Partial | Significant limitations |
-| 0-29 | Not Agent Ready | Avoid for agentic workflows |
+| 0-29 | Provider low score | Inspect the actual gaps and task fit; this is not an eligibility ban |
 
 ## Best Practices
 
 - ✅ Score tools before adding them to long-running agent workflows
 - ✅ Use Clarvia's leaderboard to discover alternatives you haven't considered
 - ✅ Re-check scores periodically — tools improve over time
-- ❌ Don't skip scoring for "well-known" tools — even popular tools can score poorly
+- ✅ Compare scores with actual protocol compatibility, required functionality and source/security review; scoring is optional
 - ❌ Don't use tools scoring below 50 in production agent pipelines without understanding the limitations
 
 ## Common Pitfalls
@@ -133,6 +133,6 @@ Add to your CI pipeline using the GitHub Action:
 - `@agent-evaluation` - Broader agent quality evaluation framework
 
 ## Limitations
-- Use this skill only when the task clearly matches the scope described above.
+- Do not add an MCP host entry or mandatory CI threshold merely to read this guide. Tool lookup/URL scanning sends data to the provider; confirm scope before sending private endpoints or triggering active scans. A 0–100 score is neither a vulnerability audit nor permission to install/execute a tool.
 - Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
 - Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.

package/bundled-skills/claude-ally-health/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: claude-ally-health
 description: "A health assistant skill for medical information analysis, symptom tracking, and wellness guidance."
-risk: safe
+risk: critical
 source: "https://github.com/huifer/Claude-Ally-Health"
 date_added: "2026-02-27"
 ---
@@ -12,15 +12,26 @@ date_added: "2026-02-27"
 
 A health assistant skill for medical information analysis, symptom tracking, and wellness guidance.
 
-## When to Use This Skill
+## When to Use
 
-Use this skill when you need to work with a health assistant skill for medical information analysis, symptom tracking, and wellness guidance..
+Organize user-supplied symptom notes or medical records into a clear timeline and
+questions for a qualified clinician; explain supplied terminology with sources.
 
-## Instructions
+## Evidence and Privacy Workflow
 
-This skill provides guidance and patterns for a health assistant skill for medical information analysis, symptom tracking, and wellness guidance..
+1. Establish the requested informational task, supplied records, dates and intended
+   recipient. Do not infer missing diagnosis, medication, dosage or test results.
+2. Separate patient-reported symptoms, documented findings and unresolved questions.
+3. Produce a source-linked timeline or appointment summary; mark missing/conflicting
+   records explicitly. Keep sensitive records local unless sharing is authorized.
+4. For medical explanations, consult current authoritative clinical sources and
+   distinguish general information from individualized professional advice.
 
-For more information, see the [source repository](https://github.com/huifer/Claude-Ally-Health).
+This entrypoint does not bundle a clinical decision system. It cannot diagnose,
+recommend treatment changes, certify wellness or replace urgent medical care.
+Do not wait on this workflow when the user reports an apparent medical emergency.
+Preserve the original source attribution; the upstream project now redirects to
+WellAlly-health and its implementation must be separately reviewed before use.
 
 ## Example
 

package/bundled-skills/claude-code-guide/SKILL.md

@@ -14,7 +14,7 @@ To provide a comprehensive reference for configuring and using Claude Code (the
 
 ## Configuration (`CLAUDE.md`)
 
-When starting a new project, create a `CLAUDE.md` file in the root directory to guide the agent.
+Read existing project instructions first. Add or update a project `CLAUDE.md` only within the requested scope, preserving repository conventions and existing instructions. The template below illustrates a React/TypeScript npm project; replace its commands and stack rules with verified project facts.
 
 ### Template (General)
 
@@ -45,7 +45,7 @@ When starting a new project, create a `CLAUDE.md` file in the root directory to
 
 ### Thinking Keywords
 
-Use these keywords in your prompts to trigger deeper reasoning from the agent:
+State the desired investigation and verification criteria explicitly. These phrases describe tasks; they are not guaranteed switches for model reasoning effort:
 
 - "Think step-by-step"
 - "Analyze the root cause"
@@ -56,22 +56,26 @@ Use these keywords in your prompts to trigger deeper reasoning from the agent:
 
 If the agent is stuck or behaving unexpectedly:
 
-1. **Clear Context**: Start a new session or ask the agent to "forget previous instructions" if confused.
+1. **Clear Context**: Save the task state and relevant evidence before starting a new session. A prompt to forget instructions does not erase loaded project rules.
 2. **Explicit Instructions**: Be extremely specific about paths, filenames, and desired outcomes.
 3. **Logs**: Ask the agent to "check the logs" or "run the command with verbose output".
 
 ## Best Practices
 
-1. **Small Contexts**: Don't dump the entire codebase into the context. Use `grep` or `find` to locate relevant files first.
+1. **Small Contexts**: Don't dump the entire codebase into the context. Use `rg` or `rg --files` to locate relevant files first.
 2. **Iterative Development**: Ask for small changes, verify, then proceed.
 3. **Feedback Loop**: If the agent makes a mistake, correct it immediately and ask it to "add a lesson" to its memory (if supported) or `CLAUDE.md`.
 
+## Verification
+
+Inspect the resulting diff and confirm the intended instructions actually load in the installed host. Project instructions guide behavior; they do not enforce a security boundary. Keep secrets out of tracked instructions. Check current features against [official memory documentation](https://code.claude.com/docs/en/memory).
+
 ## Reference
 
 Based on [Claude Code Guide by zebbern](https://github.com/zebbern/claude-code-guide).
 
 ## When to Use
-This skill is applicable to execute the workflow or actions described in the overview.
+Use when configuring project instructions, diagnosing conflicting Claude Code guidance, or defining verified build/test workflows.
 
 ## Limitations
 - Use this skill only when the task clearly matches the scope described above.

package/bundled-skills/claude-scientific-skills/SKILL.md

@@ -18,9 +18,21 @@ Use this skill when you need to work with scientific research and analysis skill
 
 ## Instructions
 
-This skill provides guidance and patterns for scientific research and analysis skills.
-
-For more information, see the [source repository](https://github.com/K-Dense-AI/claude-scientific-skills).
+This is a discovery guide to the upstream scientific library; its many scientific
+packages and workflows are not bundled inside this entrypoint.
+
+1. Identify the scientific question, discipline, input data, desired analysis,
+   computational environment, and evidence needed to support the result.
+2. Browse the source repository for the particular relevant skill; inspect its full
+   instructions, supporting files, dependencies, data licenses and limitations.
+3. Prefer an appropriate already-installed canonical AAS skill when available.
+   Import or install upstream content only within the user's authorized scope;
+   do not silently load the whole library or execute unreviewed scripts.
+4. Record methods, package versions, data provenance, uncertainty and actual checks.
+   Separate reproduced results from proposed analysis or vendor claims.
+
+The upstream library now calls itself Scientific Agent Skills. The original source
+URL is preserved for attribution and redirects to the same project.
 
 ## Example