Essential hypertension

**Providing answer format**

I see that I need to provide the answer in a JSON format. Specifically, I'll focus on primary hypertension, which is classified under ICD-10-CM as I10. I want to ensure the structure is clear and concise, so organizing this information effectively is key. I'll make sure to present it nicely for anyone who might need to reference it later. It's all about getting that format just right!

The task is: Assign the single ICD-10-CM code for: "Essential (primary) hypertension." Required key: "code".

The task is: Assign the single ICD-10-CM code for: "Essential (primary) hypertension." Required key: "code".

The task is: Assign the single ICD-10-CM code for: "Essential (primary) hypertension." Required key: "code".

The problem asks to assign the single ICD-10-CM code for: "Essential (primary) hypertension." Required key: "code".

The task asks to assign the single ICD-10-CM code for: "Essential (primary) hypertension." and the required key is "code".

The task asks to assign the single ICD-10-CM code for "Essential (primary) hypertension." Required key: "code".

**My Thought Process for Ascertaining the ICD-10-CM Code for Essential (Primary) Hypertension**

My primary objective here is to identify the precise ICD-10-CM code corresponding to "Essential (primary) hypertension." This is a straightforward retrieval task, requiring me to access my knowledge base regarding medical coding classifications.

Upon querying my internal data, I immediately recall that the established ICD-10-CM code for this condition is **I10**.

The user has specified a particular output format: a JSON code block containing a single key, "code." The value associated with this key should be the ICD-10-CM code itself.

A crucial detail highlighted in the instructions pertains to code formatting. I understand that I must present the code *exactly* as it appears in the official code set. This means including decimal points where they are present. For instance, a code like E11.9 necessitates the decimal, whereas I10 does not. Therefore, for "Essential (primary) hypertension," the correct representation, adhering strictly to the code set's convention, is simply **I10**. No decimal is to be included.

Furthermore, the instructions explicitly state that no other keys are required in the JSON output. My task is therefore confined to providing solely the "code" key with its corresponding value.

In summation, based on the defined condition and the formatting constraints, the final output will be a JSON object containing the key "code" with the value "I10."

```json
{
  "code": "I10"
}
```

**My Thought Process on Coding "Essential (primary) hypertension"**

Alright, so the request is straightforward: I need to find the ICD-10-CM code for "Essential (primary) hypertension." My internal knowledge base immediately flags this as a common and well-defined diagnosis. I access the ICD-10-CM classification system, specifically looking for terms related to hypertension. I'm focused on the "essential" or "primary" aspect, which signifies hypertension without an identifiable secondary cause.

My search confirms that the direct and most appropriate code for "Essential (primary) hypertension" is **I10**. This code specifically encompasses this condition, as detailed in the ICD-10-CM manual.

Therefore, the required key is "code," and the associated value is "I10." This is a standard lookup, and the mapping is quite direct in this instance.

**My Thought Process for Assigning the ICD-10-CM Code for Essential Hypertension**

My primary objective here is clear: I need to identify and output the single, most appropriate ICD-10-CM code that represents "Essential (primary) hypertension." This output must be strictly formatted as a JSON object, containing only the key "code."

My first step is to recognize the condition itself. "Essential (primary) hypertension" is a fundamental and frequently encountered diagnosis within clinical practice. My internal knowledge base, honed by extensive experience with medical coding and classification systems, immediately points to its standard designation within ICD-10-CM.

Recalling the structure and specific entries of the ICD-10-CM manual, I access the relevant section for hypertensive diseases. I know that "essential (primary) hypertension" is the default, idiopathic form of high blood pressure, and it has a dedicated, top-level code. This code is I10.

Now, I must adhere to the precise formatting requirements stipulated for this task. The output needs to be a JSON object, enclosed within a code block, with absolutely no preceding or succeeding text – no preamble, no explanations, just the data. The sole required key is "code," and its value must be the identified ICD-10-CM code.

The ICD-10-CM code I10 is a straightforward alphanumeric designation. It does not incorporate a decimal point in its representation, which is important to note for accurate transcription.

Therefore, I construct the JSON object. It will have the key "code," and its corresponding value will be the string "I10."

My final verification checks are crucial.
1.  Does the code "I10" indeed represent "Essential (primary) hypertension" according to the ICD-10-CM coding guidelines? Yes, it does.
2.  Does the code require a decimal point as part of its standard representation? No, I10 is a valid code without one.
3.  Is the JSON structure correct – a single object, with the specified key "code," and no extraneous elements? Yes, it is.

With these checks complete, I am confident that the resulting JSON object accurately and compliantly fulfills the request.

```json
{
  "code": "I10"
}
```

**My Thought Process for Determining the ICD-10-CM Code for Essential Hypertension**

Alright, the request is clear: I need to find the ICD-10-CM code for "Essential (primary) hypertension." This is a straightforward coding task, but like any good coding process, it requires a systematic approach and verification.

My first step, naturally, is to **search for "hypertension"** within the ICD-10-CM classification system. I know that "essential (primary) hypertension" is a very common diagnosis, so I anticipate it will have a direct and well-established code.

Upon searching, the system or my knowledge base immediately points me to **I10** as the code for "Essential (primary) hypertension." This seems correct and aligns with my understanding of the terminology.

Now, I need to ensure I'm adhering strictly to ICD-10-CM guidelines. I recall (or would consult) that the guidelines explicitly state: **"Hypertension, essential, primary, systemic -> I10."** This provides definitive confirmation.

A crucial detail I always keep in mind with ICD-10-CM is the formatting. I've seen too many errors arise from incorrect decimal placement. For **I10**, it's important to note that **ICD-10-CM codes do not use a decimal point for this particular code.** The code is simply I10.

At this point, I've identified the core information:
*   **Key:** "code" (representing the concept I'm trying to code)
*   **Value:** "I10" (the actual ICD-10-CM code)

To finalize this, I perform a **Self-Correction/Verification** step.
*   **Is it I10?** Yes, the mapping is direct and unambiguous.
*   **Are there sub-classifications for I10?** My knowledge confirms that for "Essential (primary) hypertension," I10 is the complete and final code. There are no further sub-classifications needed for this specific phrase.
*   **Does it need a decimal?** As noted earlier, no. I10 is a 3-character code and doesn't require a decimal point in its representation.

With all verification steps complete and confidence in the result, my final action is to **Construct the JSON** structure as requested, encapsulating the determined code.

**My Thought Process for Determining the ICD-10-CM Code for Essential Hypertension**

My primary objective was to identify the correct ICD-10-CM code for "Essential (primary) hypertension." To achieve this, I initiated a systematic search within the ICD-10-CM nomenclature, starting with the broad term "hypertension." My search yielded a direct match for "essential (primary) hypertension."

Upon locating this specific condition, I cross-referenced it to confirm the assigned code. The ICD-10-CM designation for "Essential (primary) hypertension" is indeed I10. I then proceeded to examine the inclusions associated with I10 to ensure comprehensive understanding and accurate application. This revealed that I10 also encompasses a range of related terms, including "high blood pressure" and various forms of hypertension such as "hypertension (arterial) (benign) (essential) (malignant) (primary) (systemic)."

A critical step in my process was to verify if there were any further subdivisions or more specific subcodes available for essential hypertension within the ICD-10-CM framework. I confirmed that, as of the current code set, I10 does not offer further subdivisions specifically for essential hypertension. Therefore, I10 stands as the definitive and singular code for this condition.

Finally, I considered the requested output format. The user specified a JSON structure with a "code" key. Adhering to this, I formatted the result as `{"code": "I10"}`, ensuring that all explicit requirements were met. No date or currency formatting was necessary for this particular query.

**My Thought Process for Determining the ICD-10-CM Code for Essential (Primary) Hypertension**

When presented with the request for the ICD-10-CM code for "Essential (primary) hypertension," my immediate thought process centers on accurately identifying the correct code within the established diagnostic classification system. My expertise in this domain allows me to navigate the complexities of medical coding with efficiency.

First, I recall the direct correspondence between the clinical term "Essential (primary) hypertension" and its designated ICD-10-CM code. My internal knowledge base readily links these.

To confirm and ensure absolute precision, I would then mentally, or if needed, physically consult the ICD-10-CM index. My search would begin with the primary term, "Hypertension." I anticipate that the index will provide a comprehensive list of hypertensive conditions, and I'm specifically looking for the modifier "essential" or "primary."

Upon locating the entry for "Hypertension, hypertensive (arterial) (benign) (essential) (malignant) (primary) (systemic)," I would observe that the index points directly to code **I10**. This is a strong indicator of the correct code.

Next, I would cross-reference this with the tabular list for **I10** to verify its descriptive text and any associated guidelines. My review would confirm that **I10** is indeed defined as "Essential (primary) hypertension." I would also note the inclusions listed for this code, such as "high blood pressure" and other synonyms, which further validate its applicability to the presented diagnosis.

A critical step in my process is to determine if the identified code requires additional characters for specificity. In this instance, I know that **I10** is a complete code and does not necessitate further alphanumeric extensions to fully capture the diagnosis of essential (primary) hypertension. Similarly, I would confirm that the code itself does not involve decimal points, as is the case with **I10**.

Therefore, based on my comprehensive understanding of the ICD-10-CM structure and the specific diagnostic terminology, I conclude that the single, correct ICD-10-CM code for "Essential (primary) hypertension" is **I10**.

The ICD-10-CM code for "Essential (primary) hypertension" is I10. No decimal point.

This is a simple ICD-10-CM coding question. "Essential (primary) hypertension" maps to I10. The code set uses no decimal point for this code — I10 is the complete code.

The task asks for the ICD-10-CM code for "Essential (primary) hypertension." That's I10. No decimal point.

Alright, let's break down how I arrived at the ICD-10-CM code for "Essential (primary) hypertension." My initial thought process immediately harks back to my foundational knowledge of ICD-10-CM coding. I recognize "hypertension" as a very common diagnosis and recall that the primary code family for it resides within the I10-I16 range.

The key descriptor here is "Essential (primary) hypertension." This tells me we're dealing with the most common form, where there isn't a discernible secondary cause driving the elevated blood pressure. My internal lexicon quickly points to a specific code for this scenario.

To confirm, I mentally (or if I were actually looking it up, I would physically) access the ICD-10-CM index. I'd search for "Hypertension, essential" or "Hypertension, primary." This search would unequivocally lead me to code I10, which is explicitly defined as "Essential (primary) hypertension."

I then perform a crucial verification step. Is I10 a terminal code? Yes, it is. There are no further sub-classifications under I10 for uncomplicated essential hypertension. This means it's the most specific and appropriate code without additional complicating factors. I also consider other potential hypertensive codes: I11 (Hypertensive heart disease), I12 (Hypertensive chronic kidney disease), and so forth. However, the prompt *only* states "Essential (primary) hypertension," without mentioning any co-existing heart or kidney conditions. Therefore, codes like I11 or I12 are not applicable. Similarly, I15 codes for secondary hypertension are ruled out by the term "primary."

With the code confirmed as I10, I then focus on the output format. The request specifies a JSON object with a single key, "code." The value associated with this key must be the ICD-10-CM code itself. So, the value will be "I10."

Finally, I construct the JSON object precisely as requested, ensuring no extraneous information, preambles, or commentary are included, as the user is an expert and expects a direct, accurate, and unadorned response. This leads directly to the final output:

```json
{
  "code": "I10"
}
```

Everything checks out: it's a single JSON block, uses the correct key, and holds the precise ICD-10-CM code for the specified diagnosis.

Okay, let's break down how I arrived at the answer for the ICD-10-CM code for "Essential (primary) hypertension." My internal process follows a logical, structured approach, much like how I'd approach any complex coding query.

First, I analyzed the request itself. The user's explicit need is for a *single* ICD-10-CM code for the diagnosis "Essential (primary) hypertension." This tells me I need to find the most specific and appropriate code that encapsulates this exact phrase, and the output format is strictly defined as JSON.

Next, I focused on the core of the request: the diagnosis itself. The key terms here are "Essential (primary) hypertension." I understand that "essential" or "primary" hypertension is distinct from secondary hypertension, which is caused by another underlying medical condition. Essential hypertension is the most common form, where the cause is unknown or multifactorial.

Drawing upon my extensive knowledge base of the ICD-10-CM coding system, I immediately accessed the section pertaining to circulatory system diseases, specifically hypertensive diseases. I know that hypertension is a very common diagnosis with well-established coding pathways. I recall that the classification for essential hypertension is quite direct.

The specific code that maps directly to "Essential (primary) hypertension" is **I10**. This code is a foundational entry in the ICD-10-CM system for this condition. I also cross-referenced the structural requirements. The instructions emphasized not adding any extraneous characters, particularly decimals, where they aren't part of the official code. I10 is a three-character code without a decimal point, so this confirms its direct applicability and correct format.

Once I had the code, I turned my attention to the required output format. The user specified a JSON object with a single key: `"code"`. Therefore, I constructed the JSON object by assigning the identified code, "I10", as the value to this key.

Finally, I performed a self-check to ensure all constraints were met.
*   Is the output a single JSON block? Yes.
*   Does it contain only the `"code"` key? Yes.
*   Is the code `I10` accurate for "Essential (primary) hypertension"? Yes.
*   Is the code formatted correctly as per ICD-10-CM (no extra decimal)? Yes.
*   Am I operating solely within the bounds of my provided knowledge and the request? Yes.
*   Am I answering in a manner that reflects the expertise expected of a health plan analyst or coder by providing the precise, actionable code? Yes.

The entire process is about precise mapping and adherence to established coding rules and output specifications. For a diagnosis like "Essential (primary) hypertension," it's a straightforward lookup and application, assuming complete familiarity with the coding system.

Alright, let's break down this request. The user, clearly an expert, needs the definitive ICD-10-CM code for "Essential (primary) hypertension." My immediate thought is to dive into my ICD-10-CM knowledge base. I'll be looking for the exact terminology, so my search terms will be "essential hypertension" and "primary hypertension."

Upon consulting the index, I'll navigate to the "Hypertension" section. Within that block, I'm specifically looking for the sub-entry that reads "essential (primary)." My internal recall confirms that the corresponding ICD-10-CM code for this specific diagnosis is I10.

Now, for verification. I need to ensure I10 is indeed the correct, billable code that directly maps to "Essential (primary) hypertension" without requiring any additional specificity or further characters. It is. The description is a perfect match.

Finally, I need to format this precisely as requested: a JSON object with a single key, "code," and the value being the string "I10." No decimal is required in the code itself. I'll construct that JSON now:

```json
{
  "code": "I10"
}
```

This looks correct, adheres to all the constraints, and delivers the precise answer the user, as an expert, would expect.

The ICD-10-CM code for essential (primary) hypertension is I10.

Essential (primary) hypertension in ICD-10-CM is codedas I10.

The ICD-10-CM code for Essential (primary) hypertension is I10.

The user wants the ICD-10-CM code for "Essential (primary) hypertension".
I know that the ICD-10-CM code for Essential (primary) hypertension is I10.
I10 has no decimal.
Required key: "code".
Output format: JSON with key "code".

Code: I10
Check rules: "Report codes exactly as they are written in the code set, including the decimal point where the code set uses one. I10 has no decimal."
So "I10".
JSON format:
```json
{
  "code": "I10"
}
```
No preamble, no commentary.
I will output just the JSON block.

The user wants the ICD-10-CM code for "Essential (primary) hypertension".
The ICD-10-CM code for Essential (primary) hypertension is I10.
I10 has no decimal.
Required key: "code".
Output format: JSON with key "code".
Code: "I10"
Check rules: "Report codes exactly as they are written in the code set, including the decimal point where the code set uses one. I10 has no decimal."
So "I10".

The user wants the ICD-10-CM code for "Essential (primary) hypertension."
I know that the ICD-10-CM code for Essential (primary) hypertension is I10.
Let me double-check. Yes, I10 is Essential (primary) hypertension.
There is no decimal in I10.
The required key is "code".

```json
{
  "code": "I10"
}
```
Wait, let me just confirm there are no other specifications.
"Essential (primary) hypertension" -> I10.
No further characters needed.
I will output the JSON block.

The ICD-10-CM code for essential (primary) hypertension is I10. No decimal point — the instruction even says "I10 has no decimal."

The ICD-10-CM code for essential (primary) hypertension is I10. The ICD-10-CM code for essential hypertension has no decimal point — wait, actually I10 is written without a decimal point. In ICD-10-CM, hypertension is coded I10 (no decimal). The rubric says "I10 has no decimal." So the answer is "I10".

The ICD-10-CM code for essential (primary) hypertension is I10. It has no decimal point.

We need answer user's request: Assign single ICD-10-CM code for "Essential (primary) hypertension." Required key "code". Need output exactly one fenced JSON block. Need know ICD-10-CM code. Essential (primary) hypertension is I10. Need no decimal. Ensure JSON only.

We need answer user's request: Assign single ICD-10-CM code for "Essential (primary) hypertension." Required key "code". Need output exactly one fenced JSON code block. Need know code: I10 for Essential (primary) hypertension. Include no decimal. final JSON.

We need answer user's request: Assign single ICD-10-CM code for "Essential (primary) hypertension." Required key "code". Need output exactly one fenced JSON block. Need think in English because user request English. Need know ICD-10-CM code for essential (primary) hypertension is I10. The prompt says I10 has no decimal. So output {"code":"I10"}. Ensure no extra.

The task asks for the single ICD-10-CM code for "Essential (primary) hypertension."

That is I10. In ICD-10-CM, essential (primary) hypertension is I10, written without a decimal point. The instructions say to report codes exactly as written in the code set — I10 has no decimal.

Required key: "code".

The task asks for the single ICD-10-CM code for "Essential (primary) hypertension." That is I10.

The glossary notes: I10 has no decimal. Report codes exactly as written in the code set, including the decimal point where the code set uses one. I10 has no decimal.

So the answer is "I10" — no decimal.

The task asks for the single ICD-10-CM code for "Essential (primary) hypertension."

From my knowledge of ICD-10-CM, the code for essential (primary) hypertension is I10.

The code set conventions note: I10 has no decimal. So report "I10" without a decimal point.

We need answer with exactly one fenced JSON code block. Task: Assign the single ICD-10-CM code for: "Essential (primary) hypertension." Required key: "code". Need recall ICD-10-CM code. Essential (primary) hypertension is I10. Check ICD-10-CM: I10 Essential (primary) hypertension. Yes code I10, no decimal. Need output JSON object with key "code": "I10". Ensure no extra keys. Output contract: exactly one fenced JSON code block and nothing else. Need use ```json ... ```. Code string exactly "I10". Let's ensure no decimal. In ICD-10-CM, I10 is Essential (primary) hypertension. It is a valid code, no decimal point. Category I10-I15 Hypertensive diseases. I10 Essential (primary) hypertension. So code = "I10".

Need final with only fenced block. No commentary.

Check requirements: Booleans etc not relevant. Integers etc. The key "code" required. Use JSON null if empty not needed. So final:

```json
{
  "code": "I10"
}
```

Need ensure formatting. The output contract says Reply with exactly one fenced JSON code block and nothing else. So no text before/after. Good.

We need answer assign single ICD-10-CM code for "Essential (primary) hypertension." Required key: "code". This is likely I10. Need be careful: ICD-10-CM code for Essential (primary) hypertension is I10. In ICD-10-CM, code I10 is Essential (primary) hypertension. Does it include hypertension, benign/essential/malignant? Let's recall: I10 Essential (primary) hypertension. Includes: high blood pressure, hypertension (arterial)(benign)(essential)(malignant)(primary)(systemic). Excludes1: hypertension complicating pregnancy/childbirth/puerperium (O10-?), etc. Excludes2: ... So answer exactly "I10". Required key code. Output JSON block with one key. Ensure no decimal, I10 no decimal. Not I10.9. The code is I10 (no decimal point). Confirm up-to-date? Some years maybe I10 is still valid. Yes ICD-10-CM I10 is essential (primary) hypertension.

Need reply exactly one fenced JSON code block and nothing else. JSON object: {"code":"I10"}. Check if need quotes. Yes string.

Let's ensure task: Required key: "code". No other keys. Output contract: exactly one fenced JSON code block and nothing else. Use code block with json. So final:
```json
{"code":"I10"}
```

We need answer single ICD-10-CM code for "Essential (primary) hypertension." Required key code. Need output JSON exactly one fenced block. Need know ICD-10-CM code for essential (primary) hypertension. It's I10. In ICD-10-CM, I10 is Essential (primary) hypertension. There is no decimal. Include I10. Need output {"code":"I10"}. Ensure string. No other keys. Check if there are any excludes? Essential hypertension code I10. No 7th char. The question: Assign the single ICD-10-CM code for "Essential (primary) hypertension." Required key: "code". The code set uses I10, no decimal. So answer. Need exactly one fenced JSON code block, nothing else.

Final:
```json
{ "code": "I10" }
```
Need maybe no space? JSON object. Fine. Ensure code block with json. No commentary. Done.

We need answer JSON only. Task: assign single ICD-10-CM code for Essential (primary) hypertension. Known code I10. Need include code exactly no decimal? I10. Output JSON object key code. Ensure no extra.

We need answer user's request. Need output exactly one fenced JSON code block. Task: Assign single ICD-10-CM code for "Essential (primary) hypertension." Required key code. Need know ICD-10-CM: I10. It's in glossary example says I10 has no decimal. Output {"code":"I10"}. Ensure only JSON block.

We need answer user: "Assign the single ICD-10-CM code for: Essential (primary) hypertension. Required key: code." Need output exactly one fenced JSON code block. Need think. ICD-10-CM for essential hypertension is I10. Rules: code exactly no decimal. So final JSON {"code":"I10"}. Ensure only code block.

The user wants the single ICD-10-CM code for "Essential (primary) hypertension."
No reference material is supplied. I need to answer from what I know.
Essential (primary) hypertension is coded as I10 in ICD-10-CM.
The required key is "code".
I need to output exactly one fenced JSON code block with nothing else.
The code should be reported exactly as written. I10 has no decimal.
So the JSON should be:
```json
{
  "code": "I10"
}
```

 The user is asking for the single ICD-10-CM code for "Essential (primary) hypertension."

No reference material is supplied for this item. I need to answer from what I know.

ICD-10-CM code for essential (primary) hypertension is I10.

Let me verify: 
- In ICD-10-CM, essential (primary) hypertension is coded as I10.
- It does not have a decimal point.
- The prompt says "Report codes exactly as they are written in the code set, including the decimal point where the code set uses one. I10 has no decimal."

So the code is "I10".

Required key: "code".

I need to output exactly one fenced JSON code block and nothing else.

```json
{
  "code": "I10"
}
```

This seems straightforward and correct based on standard ICD-10-CM knowledge. 

The user is asking for the ICD-10-CM code for "Essential (primary) hypertension." No reference material is supplied, so I need to answer from what I know.

The ICD-10-CM code for Essential (primary) hypertension is I10.

Key required: "code"

Value: "I10"

I need to output exactly one fenced JSON code block.

```json
{
  "code": "I10"
}
```

Wait, the instructions say: "Report codes exactly as they are written in the code set, including the decimal point where the code set uses one. I10 has no decimal. E11.9 does. Do not add a decimal point that the code set does not use, and do not strip one that it does."

I10 indeed has no decimal in ICD-10-CM. So "I10" is correct.

The required key is "code". I should include only that key.

Let me double-check: Essential (primary) hypertension = I10. Yes.

I will output the JSON block.

We are asked for the ICD-10-CM code for "Essential (primary) hypertension." That is I10. So code: "I10".

We need answer ICD-10-CM code for essential primary hypertension. Need single code. Likely I10. Essential (primary) hypertension = I10. No decimal. Need JSON with key code. Ensure exactly one fenced JSON block.

We need answer JSON with key code. Need assign ICD-10-CM for "Essential (primary) hypertension." Single code I10. Need exactly fenced JSON. No extra.

We need answer single ICD-10-CM code for "Essential (primary) hypertension." Required key code. Need know ICD-10-CM code I10. Essential hypertension primary is I10. No decimal. Need output JSON with key code. Must be exactly fenced JSON.

The task is asking me to assign the single ICD-10-CM code for "Essential (primary) hypertension."

Essential hypertension, also known as primary hypertension, is a very common diagnosis in ICD-10-CM. Let me recall the correct code.

In ICD-10-CM, essential (primary) hypertension is coded as I10.

The code I10 is the appropriate code for Essential (primary) hypertension. It does not require a decimal point or a seventh character.

The task says:
- Report codes exactly as they are written in the code set, including the decimal point where the code set uses one. I10 has no decimal.
- Where a code carries a seventh character, include it.

I10 has no decimal point and no seventh character requirement for essential hypertension.

The required key is "code", so I need to return a JSON object with the key "code" and the value "I10".

The user is asking for a single ICD-10-CM code for "Essential (primary) hypertension."

In ICD-10-CM, essential hypertension is coded as I10.

This is the standard code for essential (primary) hypertension with no other specific conditions noted. There is no seventh character required for this code.

The code should be reported exactly as it is written in the code set. I10 does not have a decimal point in ICD-10-CM, so I should not add one.

Let me verify my knowledge: I10 is indeed the correct ICD-10-CM code for essential (primary) hypertension.

The task asks for a single code with the required key "code".

The task is asking me to assign a single ICD-10-CM code for "Essential (primary) hypertension."

In ICD-10-CM, essential hypertension is coded as I10. This is the standard code for essential (primary) hypertension without specifying any complications or secondary forms.

The instruction states:
- Report codes exactly as they are written in the code set, including the decimal point where the code set uses one. I10 has no decimal.
- Never invent a code. If you cannot identify the correct value, return the string "UNKNOWN" for that key.

I10 is the correct ICD-10-CM code for essential (primary) hypertension. There is no decimal point in this code.

The required key is "code".

The response should be a JSON object with just the "code" key containing the value "I10".