Your task is to implement the **{{ operation }}** kernel operation in C++ for the Tenstorrent AI accelerator.  Building off of the `tt_eltwise_sfpu2_template.cpp` template file and the reference implementation in `lowered_{{ operation }}.py`, you will construct the C++ kernel code that correctly implements {{ operation }}.


{% if files %}
## Input Files
{% for file in files %}
### {{ file.filename }}
{% if file.usage %}*{{ file.usage }}*{% endif %}

```{% if file.filename.endswith('.cpp') %}cpp{% else %}python{% endif %}
{{ file.contents }}
```
{% endfor %}
{% endif %}

{% if suggested_fixes %}
## Issues to Fix

The previous iteration had the following issues:
{% for fix in suggested_fixes %}
- **{{ fix.path }}:{{ fix.line_number }}** - {{ fix.likely_cause }}
  - Suggested fix: {{ fix.suggested_fix }}
{% endfor %}
{% endif %}

## Requirements

1. **Understand the lowering**: Review the contents of `lowered_{{ operation }}.py` to see how {{ operation }} should be broken down into primitive operations (exp, neg, add, mul, etc.)

2. **Map operations to LLK calls**: Translate each primitive operation from the lowering into the corresponding Low-Level Kernel (LLK) API calls in the C++ compute kernel.

3. **Generate the compute kernel**:
   - The template file provides a reference structure for implementing element-wise operations
   - Modify the code to implement `{{ operation }}(x)` using appropriate LLK operations
   - Follow the same structure as the template: use DST registers, SFPU operations, and binary operations
   - Update comments to reflect the {{ operation }} operation computed by the kernel

4. **Key LLK operations available**:
   - `copy_tile()` - Copy data between circular buffers and DST registers
   - `negative_tile()` - Negate values in a DST register
   - `exp_tile()` - Compute exponential using SFPU
   - `add_binary_tile()` - Add two DST registers
   - `sub_binary_tile()` - Subtract two DST registers
   - `mul_unary_tile()` - Multiply DST register by a scalar

5. **Preserve the kernel structure**:
   - Keep the same main loop structure
   - Keep the circular buffer setup (CB c_0 for input, CB c_16 for output)
   - Keep the tile-by-tile processing pattern
   - Only update the mathematical operations inside the tile processing loop

## Output:

Return the **complete code** for the {{ operation }} compute kernel in accordance with the output schema.  The code should be runnable without any errors.
