# Decompiler Actions

The decompiler provides three primary views: **Pseudocode**, **Microcode**, and **CTree Viewer**, each with its own set of actions. These actions are accessible either from the top menu bar or through context menus.

{% hint style="info" %}
To explore which actions are available from the top menu bar for each view, refer to [Menu Bar Actions](/9.4/core/user-interface/reference/menu-bar-actions.md).
{% endhint %}

Most actions are context-sensitive and are only available when the cursor is positioned on specific elements.

## Pseudocode Actions

Below is an overview of all decompiler-related actions available in the Pseudocode Actions.

| UI Action Name                                                                 | Action Name              | Description                                                                                                                                                                                                                                |
| ------------------------------------------------------------------------------ | ------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| [Add cast... - Add cast](/9.4/ida-actions/hx_addcast.md)                       | `hx:AddCast`             |                                                                                                                                                                                                                                            |
| [Add empty line](/9.4/ida-actions/hx_addemptyline.md)                          | `hx:AddEmptyLine`        |                                                                                                                                                                                                                                            |
| [Add pseudocode comments...](/9.4/ida-actions/hx_addpseudocmt.md)              | `hx:AddPseudoCmt`        | Add pseudocode comments.                                                                                                                                                                                                                   |
| [Add variadic argument](/9.4/ida-actions/hx_addvararg.md)                      | `hx:AddVarArg`           | Add an argument of a variadic call.                                                                                                                                                                                                        |
| [Bitwise negate](/9.4/ida-actions/hx_bitwisenegate.md)                         | `hx:BitwiseNegate`       |                                                                                                                                                                                                                                            |
| [Char](/9.4/ida-actions/hx_char.md)                                            | `hx:Char`                | Switch to character constant representation                                                                                                                                                                                                |
| [Clear cached cfuncs](/9.4/ida-actions/hx_clearcachedcfuncs.md)                | `hx:ClearCachedCfuncs`   |                                                                                                                                                                                                                                            |
| [Collapse declarations](/9.4/ida-actions/hx_collapsedecls.md)                  | `hx:CollapseDecls`       | This command collapses the current statement into one line. It can be applied to multiline statements (if, while, for, do, switch, blocks).                                                                                                |
| [Collapse else-branch](/9.4/ida-actions/hx_collapseelse.md)                    | `hx:CollapseElse`        | Collapse the else-branch of the current `if` statement into a single line, leaving the `then`-branch untouched.                                                                                                                            |
| [Collapse item](/9.4/ida-actions/hx_collapseitem.md)                           | `hx:CollapseItem`        | Collapse the selected multiline C statement into one line.                                                                                                                                                                                 |
| [Collapse then-branch](/9.4/ida-actions/hx_collapsethen.md)                    | `hx:CollapseThen`        | Collapse the then-branch of the current `if` statement into a single line, leaving the `else`-branch (if any) untouched.                                                                                                                   |
| [Convert to struct \*...](/9.4/ida-actions/hx_cvt2strucptr.md)                 | `hx:Cvt2StrucPtr`        | Specify the current variable as a pointer to a selected structure.                                                                                                                                                                         |
| [Copy to assembly](/9.4/ida-actions/hx_copy2asm.md)                            | `hx:Copy2Asm`            | Copy the pseudocode text to the disassembly window.                                                                                                                                                                                        |
| [Create C file...](/9.4/ida-actions/hx_createcfile.md)                         | `hx:CreateCFile`         | Create C file.                                                                                                                                                                                                                             |
| [Create new struct type...](/9.4/ida-actions/hx_newstruc.md)                   | `hx:NewStruc`            | Convert the current local variable from a non-pointer type to a pointer to a newly created structure type.                                                                                                                                 |
| [Decimal](/9.4/ida-actions/hx_dec.md)                                          | `hx:Dec`                 |                                                                                                                                                                                                                                            |
| [Decompile as call...](/9.4/ida-actions/hx_userdefinedcall.md)                 | `hx:UserDefinedCall`     | Decompile as call.                                                                                                                                                                                                                         |
| [Delete orphan comments](/9.4/ida-actions/hx_delorphancmts.md)                 | `hx:DelOrphanCmts`       |                                                                                                                                                                                                                                            |
| [Delete pseudocode comments...](/9.4/ida-actions/hx_delpseudocmt.md)           | `hx:DelPseudoCmt`        | Delete pseudocode comments.                                                                                                                                                                                                                |
| [Delete variadic argument](/9.4/ida-actions/hx_delvararg.md)                   | `hx:DelVarArg`           | Remove an argument of a variadic call.                                                                                                                                                                                                     |
| [Edit block comment...](/9.4/ida-actions/hx_editblockcmt.md)                   | `hx:EditBlockCmt`        | Edits the block comment for the current line. The entered comment will be displayed before the current line.                                                                                                                               |
| [Edit comment...](/9.4/ida-actions/hx_editcmt.md)                              | `hx:EditCmt`             | This command edits the indented comment for the current line or the current variable. It can be applied to the local variable definition area (at the top of the output) and to the function statement area (at the bottom of the output). |
| [Edit type... - Edit type](/9.4/ida-actions/hx_edittype.md)                    | `hx:EditType`            |                                                                                                                                                                                                                                            |
| [Enum](/9.4/ida-actions/hx_enum.md)                                            | `hx:Enum`                | Switch to enumeration (symbolic constant) representation                                                                                                                                                                                   |
| [Extract function...](/9.4/ida-actions/hx_extractfunc.md)                      | `hx:ExtractFunc`         | Extract function.                                                                                                                                                                                                                          |
| [Forbid assignment propagation](/9.4/ida-actions/hx_nopropvar.md)              | `hx:NopropVar`           | Disable propagation of the assignments of the specified local variable.                                                                                                                                                                    |
| [Force call type](/9.4/ida-actions/hx_forcecalltype.md)                        | `hx:ForceCallType`       | Tell the decompiler to skip analyzing the call arguments and instead use the type of the called object as-is.                                                                                                                              |
| [Generate HTML...](/9.4/ida-actions/hx_genhtml.md)                             | `hx:GenHtml`             | Generate an HTML file with the pseudocode of the current function.                                                                                                                                                                         |
| [Generate pseudocode](/9.4/ida-actions/hx_genpseudo.md)                        | `hx:GenPseudo`           | This command decompiles the current function.                                                                                                                                                                                              |
| [Hexadecimal](/9.4/ida-actions/hx_hex.md)                                      | `hx:Hex`                 |                                                                                                                                                                                                                                            |
| [Hide casts](/9.4/ida-actions/hx_toggleshowcasts.md)                           | `hx:ToggleShowCasts`     | Hide all cast operators from the output listing.                                                                                                                                                                                           |
| [hx\_JmpLocalType](/9.4/ida-actions/hx_jmplocaltype.md)                        | `hx:JmpLocalType`        |                                                                                                                                                                                                                                            |
| [hx\_ToggleSSEIntrinsics](/9.4/ida-actions/hx_togglesseintrinsics.md)          | `hx:ToggleSSEIntrinsics` |                                                                                                                                                                                                                                            |
| [Invert sign](/9.4/ida-actions/hx_invertsign.md)                               | `hx:InvertSign`          | It negates the constant and resets the enum/char flag if it was set.                                                                                                                                                                       |
| [Invert then/else](/9.4/ida-actions/hx_invertif.md)                            | `hx:InvertIf`            | Swap the then- and else-branches of an `if` statement and negate the condition, leaving behavior unchanged.                                                                                                                                |
| [Jump to matching brace](/9.4/ida-actions/hx_jumpnextparen.md)                 | `hx:JumpNextParen`       | This command jumps to the matching parenthesis.                                                                                                                                                                                            |
| [Jump to pseudocode](/9.4/ida-actions/hx_jumppseudo.md)                        | `hx:JumpPseudo`          | Jump to pseudocode.                                                                                                                                                                                                                        |
| [Jump to pseudocode in a new view](/9.4/ida-actions/hx_jumpnewpseudo.md)       | `hx:JumpNewPseudo`       |                                                                                                                                                                                                                                            |
| [Jump to structure definition...](/9.4/ida-actions/hx_jmpstrucdef.md)          | `hx:JmpStrucDef`         |                                                                                                                                                                                                                                            |
| [Jump to xref globally...](/9.4/ida-actions/hx_jumpglobalxref.md)              | `hx:JumpGlobalXref`      | Decompile all non-trivial functions in the database and look for xrefs in them.                                                                                                                                                            |
| [Jump to xref...](/9.4/ida-actions/hx_jmpxref.md)                              | `hx:JmpXref`             | Open the standard dialog box with the cross references to the current item.                                                                                                                                                                |
| [Map to another variable...](/9.4/ida-actions/hx_map2othervar.md)              | `hx:Map2OtherVar`        | Replace all occurrences of a variable by another variable.                                                                                                                                                                                 |
| [Mark as decompiled](/9.4/ida-actions/hx_markdecompiled.md)                    | `hx:MarkDecompiled`      | Mark the current function as decompiled.                                                                                                                                                                                                   |
| [Octal](/9.4/ida-actions/hx_oct.md)                                            | `hx:Oct`                 | Convert to an octal number                                                                                                                                                                                                                 |
| [Quick rename...](/9.4/ida-actions/hx_quickrename.md)                          | `hx:QuickRename`         |                                                                                                                                                                                                                                            |
| [Remove function argument/retval](/9.4/ida-actions/hx_removearg.md)            | `hx:RemoveArg`           | Remove an argument or the return type from a function prototype.                                                                                                                                                                           |
| [Remove/Add function retval](/9.4/ida-actions/hx_addremovereturn.md)           | `hx:AddRemoveReturn`     | Remove the return type from the function prototype.                                                                                                                                                                                        |
| [Rename label...](/9.4/ida-actions/hx_rename.md)                               | `hx:Rename`              | Rename the current item.                                                                                                                                                                                                                   |
| [Reset decompiler information...](/9.4/ida-actions/hx_restypeinfo.md)          | `hx:ResTypeInfo`         | Reset decompiler information.                                                                                                                                                                                                              |
| [Reset pointer type](/9.4/ida-actions/hx_resetptrtype.md)                      | `hx:ResetPtrType`        | Reset the type of the current local variable from a pointer type to an integer type.                                                                                                                                                       |
| [Revert CONTAINING\_RECORD](/9.4/ida-actions/hx_delcontainingrecord.md)        | `hx:DelContainingRecord` |                                                                                                                                                                                                                                            |
| [Select union field...](/9.4/ida-actions/hx_selunionfield.md)                  | `hx:SelUnionField`       | Select the desired union field.                                                                                                                                                                                                            |
| [Send database...](/9.4/ida-actions/hx_sendidb.md)                             | `hx:SendIDB`             | Send current database to our server.                                                                                                                                                                                                       |
| [Set call type](/9.4/ida-actions/hx_setcalltype.md)                            | `hx:SetCallType`         | Set the type of the current function call without changing the type of the called function itself.                                                                                                                                         |
| [Set type](/9.4/ida-actions/hx_settype.md)                                     | `hx:SetType`             |                                                                                                                                                                                                                                            |
| [Show all call decompilations...](/9.4/ida-actions/hx_calldecomp.md)           | `hx:CallDecomp`          | Decompile all functions that call the selected function and display their call sites.                                                                                                                                                      |
| [Show all xref decompilations...](/9.4/ida-actions/hx_xrefdecomp.md)           | `hx:XrefDecomp`          | Decompile all functions that reference the selected global variable and display the relevant code snippets in a separate window.                                                                                                           |
| [Split expression](/9.4/ida-actions/hx_splitexpr.md)                           | `hx:SplitExpr`           | Split the current expression into multiple expressions.                                                                                                                                                                                    |
| [Split memory access](/9.4/ida-actions/hx_splitmemaccess.md)                   | `hx:SplitMemAccess`      |                                                                                                                                                                                                                                            |
| [Split variable](/9.4/ida-actions/hx_splitvar.md)                              | `hx:SplitVar`            | Forces the decompiler to create a new variable from the current point when the same stack slot is used for different purposes.                                                                                                             |
| [Stock Comments](/9.4/ida-actions/hx_stockcomments.md)                         | `hx:StockComments`       | Manage the "stock comments" (creating, deleting, and editing), and apply them to the listing.                                                                                                                                              |
| [Structure offset](/9.4/ida-actions/hx_strucoffset.md)                         | `hx:StrucOffset`         | Apply struct offset.                                                                                                                                                                                                                       |
| [Toggle hex/dec](/9.4/ida-actions/hx_hexdec.md)                                | `hx:HexDec`              | Toggle between hexadecimal and decimal representations                                                                                                                                                                                     |
| [Toggle skippable instructions...](/9.4/ida-actions/hx_toggleskippableinsn.md) | `hx:ToggleSkippableInsn` | Toggle skippable instructions.                                                                                                                                                                                                             |
| [Uncollapse declarations](/9.4/ida-actions/hx_expanddecls.md)                  | `hx:ExpandDecls`         | Uncollapse the hidden item.                                                                                                                                                                                                                |
| [Uncollapse else-branch](/9.4/ida-actions/hx_expandelse.md)                    | `hx:ExpandElse`          | Expand a previously collapsed else-branch back to its full form.                                                                                                                                                                           |
| [Uncollapse item](/9.4/ida-actions/hx_expanditem.md)                           | `hx:ExpandItem`          | Expand a previously collapsed statement or declaration back to its full multiline form                                                                                                                                                     |
| [Uncollapse then-branch](/9.4/ida-actions/hx_expandthen.md)                    | `hx:ExpandThen`          | Expand a previously collapsed then-branch back to its full form.                                                                                                                                                                           |
| [Unmap variable(s)...](/9.4/ida-actions/hx_unmapvar.md)                        | `hx:UnmapVar`            |                                                                                                                                                                                                                                            |
| [Unmark as decompiled](/9.4/ida-actions/hx_unmarkdecompiled.md)                | `hx:UnmarkDecompiled`    | Reset the decompiled status of the current function.                                                                                                                                                                                       |
| [Unsplit expression](/9.4/ida-actions/hx_unsplitexpr.md)                       | `hx:UnsplitExpr`         | Reverse a previous Split operation, removing all effects of the Split command.                                                                                                                                                             |
| [Unsplit memory access](/9.4/ida-actions/hx_unsplitmemaccess.md)               | `hx:UnsplitMemAccess`    |                                                                                                                                                                                                                                            |
| [Unsplit variable](/9.4/ida-actions/hx_unsplitvar.md)                          | `hx:UnsplitVar`          | Revert a split variable back to a single variable by removing the split point                                                                                                                                                              |

## Microcode Actions

Below is an overview of all decompiler-related actions available in the Microcode Actions.

| UI Action Name                                                      | Action Name               | Description                                                                                                                                                                                                                     |
| ------------------------------------------------------------------- | ------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Delete microcode instruction](/9.4/ida-actions/mv_deleteinsn.md)   | `mv:DeleteInsn`           | Delete microcode instruction.                                                                                                                                                                                                   |
| [Display chains...](/9.4/ida-actions/mv_displaychains.md)           | `mv:DisplayChains`        | Display chains                                                                                                                                                                                                                  |
| [Display ctree...](/9.4/ida-actions/mv_displayctree.md)             | `mv:DisplayCTree`         |                                                                                                                                                                                                                                 |
| [Display local types...](/9.4/ida-actions/mv_displayvdtypes.md)     | `mv:DisplayVdTypes`       | Display local types                                                                                                                                                                                                             |
| [Display microcode graph...](/9.4/ida-actions/mv_displaymcgraph.md) | `mv:DisplayMCGraph`       | Display microcode graph                                                                                                                                                                                                         |
| [Edit block comment...](/9.4/ida-actions/mv_editblockcmt.md)        | `mv:EditBlockCmt`         | Edit block comment                                                                                                                                                                                                              |
| [Edit microcode comment...](/9.4/ida-actions/mv_editcmt.md)         | `mv:EditCmt`              | Edit comment of microcode line                                                                                                                                                                                                  |
| [Generate microcode](/9.4/ida-actions/mv_genmicro.md)               | `mv:GenMicro`             | This command opens the **Microcode** view for the current function, displaying the decompiler's intermediate representation at various maturity levels. See [subviews](/9.4/core/user-interface/concepts/subviews.md) for more. |
| [Hide value numbers](/9.4/ida-actions/mv_toggledisplayvalnums.md)   | `mv:ToggleDisplayValnums` | Hide value numbers                                                                                                                                                                                                              |
| [Highest maturity level](/9.4/ida-actions/mv_highestmicro.md)       | `mv:HighestMicro`         | Highest maturity level                                                                                                                                                                                                          |
| [Insert assertion...](/9.4/ida-actions/mv_insertinsn.md)            | `mv:InsertInsn`           | Insert assertion                                                                                                                                                                                                                |
| [Jump to disassembly](/9.4/ida-actions/mv_jumptodisasm.md)          | `mv:JumpToDisasm`         | Jump to disassembly                                                                                                                                                                                                             |
| [List cross references from...](/9.4/ida-actions/mv_jmpxreffrom.md) | `mv:JmpXrefFrom`          | List cross references from                                                                                                                                                                                                      |
| [List cross references to...](/9.4/ida-actions/mv_jmpxref.md)       | `mv:JmpXref`              |                                                                                                                                                                                                                                 |
| [Lower maturity level](/9.4/ida-actions/mv_lowermicro.md)           | `mv:LowerMicro`           | Lower maturity level                                                                                                                                                                                                            |
| [Raise maturity level](/9.4/ida-actions/mv_raisemicro.md)           | `mv:RaiseMicro`           | Raise maturity level                                                                                                                                                                                                            |
| [Refresh](/9.4/ida-actions/mv_refresh.md)                           | `mv:Refresh`              | Refresh                                                                                                                                                                                                                         |
| [Short view](/9.4/ida-actions/mv_toggleviewshort.md)                | `mv:ToggleViewShort`      | Short view                                                                                                                                                                                                                      |
| [Show addresses](/9.4/ida-actions/mv_toggledisplayea.md)            | `mv:ToggleDisplayEA`      | Show addresses                                                                                                                                                                                                                  |
| [Show number origins](/9.4/ida-actions/mv_toggledisplaynumorig.md)  | `mv:ToggleDisplayNumorig` | Show number origins                                                                                                                                                                                                             |
| [Structural analysis...](/9.4/ida-actions/mv_structuralana.md)      | `mv:StructuralAna`        | Structural analysis                                                                                                                                                                                                             |

## CTree Viewer Actions

Below is an overview of all decompiler-related actions available in the CTree Viewer Actions.

| UI Action Name                                             | Action Name       | Description                                                                                                                                                                                                                                                                                                |
| ---------------------------------------------------------- | ----------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Generate ctree](/9.4/ida-actions/cv_genctree.md)          | `cv:GenCTree`     | Open the [CTree view](https://github.com/HexRaysSA/ida-docs/blob/9.4/core/decompiler/core/decompiler/concepts/ctree-view.md) that renders the decompiler's C-level AST (ctree) for the current function.                                                                                                   |
| [Jump to disassembly](/9.4/ida-actions/cv_jumptodisasm.md) | `cv:JumpToDisasm` | From the [CTree view](https://github.com/HexRaysSA/ida-docs/blob/9.4/core/decompiler/core/decompiler/concepts/ctree-view.md), jump to the instruction in the IDA View that corresponds to the ctree node under the cursor.                                                                                 |
| [Jump to pseudocode](/9.4/ida-actions/cv_jumptopseudo.md)  | `cv:JumpToPseudo` | From the [CTree view](https://github.com/HexRaysSA/ida-docs/blob/9.4/core/decompiler/core/decompiler/concepts/ctree-view.md), jump to the line in the Pseudocode view that corresponds to the ctree node under the cursor.                                                                                 |
| [Refresh](/9.4/ida-actions/cv_refresh.md)                  | `cv:Refresh`      | Regenerate the ctree for the current function and redisplay it in the [CTree view](https://github.com/HexRaysSA/ida-docs/blob/9.4/core/decompiler/core/decompiler/concepts/ctree-view.md). Use this after changes to the pseudocode (rename, retype, comments, etc.) that may affect the underlying ctree. |


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.hex-rays.com/9.4/core/decompiler/reference/decompiler-actions.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
