SWE-agent[bot] PR to fix: Incorrect namings of CAST_TYPE instructions in PyEval.eval

[github-actions]

This is a PR opened by AI tool SWE Agent to close #4 (Incorrect namings of CAST_TYPE instructions in PyEval.eval).

Closes #4.

Thought process ('trajectory') of SWE-agent (click to expand)

🧑‍🚒 Response (0):

👀‍ Observation (0):

Dockerfile  Pipfile.lock  codecov.yml  quark		      tests
LICENSE     README.md	  debian       quark_engine.egg-info
Pipfile     bandit.yml	  docs	       setup.py

---

🧑‍🚒 Response (1):

👀‍ Observation (1):

Here's the result of running `cat -n` on /quark-engine/quark/evaluator/pyeval.py:
     1	# -*- coding: utf-8 -*-
     2	# This file is part of Quark-Engine - https://github.com/quark-engine/quark-engine
     3	# See the file 'LICENSE' for copying permission.
     4	# Thanks for the description of Dalvik bytecode instruction from the following
     5	# websites, some of our explanations or comments will quote from it.
     6	# https://source.android.google.cn/devices/tech/dalvik/instruction-formats
     7	# http://pallergabor.uw.hu/androidblog/dalvik_opcodes.html
     8	
     9	import logging
    10	from quark import config
    11	from quark.core.struct.registerobject import RegisterObject
    12	from quark.core.struct.tableobject import TableObject
    13	from quark.core.struct.valuenode import (
    14	    Primitive, MethodCall, BytecodeOps
    15	)
    16	from quark.utils.logger import defaultHandler
    17	
    18	log = logging.getLogger(__name__)
    19	log.setLevel(logging.DEBUG)
    20	log.addHandler(defaultHandler)
    21	log.disabled = not config.DEBUG
    22	
    23	
    24	def logger(func):
    25	    def warp(*args, **kwargs):
    26	        log.info(f"{func.__name__} with args-> {args}")
    27	
    28	        func(*args, **kwargs)
    29	
    30	    return warp
    31	
    32	
    33	class PyEval:
    34	    def __init__(self, apkinfo):
    35	        # Main switch for executing the bytecode instruction.
    36	        self.eval = {
    37	            # invoke-kind
    38	            "invoke-virtual": self.INVOKE_VIRTUAL,
    39	            "invoke-virtual/range": self.INVOKE_VIRTUAL,
    40	            "invoke-direct": self.INVOKE_DIRECT,
    41	            "invoke-direct/range": self.INVOKE_DIRECT,
    42	            "invoke-static": self.INVOKE_STATIC,
    43	            "invoke-static/range": self.INVOKE_STATIC,
    44	            "invoke-interface": self.INVOKE_INTERFACE,
    45	            "invoke-interface/range": self.INVOKE_INTERFACE,
    46	            "invoke-super": self.INVOKE_SUPER,
    47	            "invoke-super/range": self.INVOKE_SUPER,
    48	            "invoke-polymorphic": self.INVOKE_POLYMORPHIC,
    49	            "invoke-polymorphic/range": self.INVOKE_POLYMORPHIC,
    50	            "invoke-custom": self.INVOKE_CUSTOM,
    51	            "invoke-custom/range": self.INVOKE_CUSTOM,
    52	            # move-result-kind
    53	            "move-result": self.MOVE_RESULT,
    54	            "move-result-wide": self.MOVE_RESULT_WIDE,
    55	            "move-result-object": self.MOVE_RESULT_OBJECT,
    56	            # instance-kind
    57	            "new-instance": self.NEW_INSTANCE,
    58	            "new-array": self.NEW_ARRAY,
    59	            # const-kind
    60	            "const-string": self.CONST_STRING,
    61	            "const-string/jumbo": self.CONST_STRING,
    62	            "const-class": self.CONST_CLASS,
    63	            "const": self.CONST,
    64	            "const/4": self.CONST_FOUR,
    65	            "const/16": self.CONST_SIXTEEN,
    66	            "const/high16": self.CONST_HIGHSIXTEEN,
    67	            "const-wide": self.CONST_WIDE,
    68	            "const-wide/16": self.CONST_WIDE_SIXTEEN,
    69	            "const-wide/32": self.CONST_WIDE_THIRTY_TWO,
    70	            "const-wide/high16": self.CONST_WIDE_HIGHSIXTEEN,
    71	        }
    72	
    73	        # move-kind
    74	        for prefix in ("move", "move-object", "move-wide"):
    75	            for postfix in ("", "/from16", "/16"):
    76	                self.eval[f"{prefix}{postfix}"] = self.MOVE_KIND
    77	        self.eval["array-length"] = self.MOVE_KIND
    78	
    79	        # filled-array-kind
    80	        for ins in ("filled-new-array", "filled-new-array/range"):
    81	            self.eval[ins] = self.FILLED_NEW_ARRAY_KIND
    82	
    83	        # aget-kind
    84	        for postfix in ("", "-object", "-boolean", "-byte", "-char", "-short"):
    85	            self.eval[f"aget{postfix}"] = self.AGET_KIND
    86	            self.eval["aget-wide"] = self.AGET_WIDE_KIND
    87	
    88	        # aput-kind
    89	        for postfix in ("", "-object", "-boolean", "-byte", "-char", "-short"):
    90	            self.eval[f"aput{postfix}"] = self.APUT_KIND
    91	            self.eval["aput-wide"] = self.APUT_WIDE_KIND
    92	
    93	        # neg-kind and not-kind
    94	        for prefix in ("neg", "not"):
    95	            self.eval[f"{prefix}-int"] = self.NEG_AND_NOT_KIND
    96	            self.eval[f"{prefix}-long"] = self.NEG_AND_NOT_KIND
    97	            self.eval[f"{prefix}-float"] = self.NEG_AND_NOT_KIND
    98	            self.eval[f"{prefix}-double"] = self.NEG_AND_NOT_KIND
    99	
   100	        # type casting
   101	        for first_type in ("int", "long", "float", "double"):
   102	            for second_type in ("int", "long", "float", "double"):
   103	                if first_type == second_type:
   104	                    continue
   105	                self.eval[f"{first_type}-{second_type}"] = self.CAST_TYPE
   106	
   107	        # binop_kind
   108	        for prefix in (
   109	            "add",
   110	            "sub",
   111	            "mul",
   112	            "div",
   113	            "rem",
   114	            "and",
   115	            "or",
   116	            "xor",
   117	            "shl",
   118	            "shr",
   119	            "ushr",
   120	        ):
   121	            for _type in ("int", "float", "double", "long"):
   122	                for postfix in ("", "/2addr", "/lit16", "/lit8"):
   123	                    self.eval[f"{prefix}-{_type}{postfix}"] = self.BINOP_KIND
   124	
   125	        self.eval["move-exception"] = lambda ins: self._assign_value(
   126	            (ins[0], ins[1], "Exception"), value_type="Ljava/lang/Throwable;"
   127	        )
   128	        self.eval[
   129	            "fill-array-data"
   130	        ] = lambda ins: self._move_value_and_data_to_register(
   131	            (ins[0], ins[1], ins[1], ins[2]), "Embedded-array-data()[]"
   132	        )
   133	
   134	        self.type_mapping = {
   135	            "boolean": "Z",
   136	            "byte": "B",
   137	            "char": "C",
   138	            "short": "S",
   139	            "int": "I",
   140	            "long": "J",
   141	            "float": "F",
   142	            "double": "D",
   143	        }
   144	
   145	        self.table_obj = TableObject()
   146	        self.ret_stack = []
   147	        self.ret_type = ""
   148	        self.apkinfo = apkinfo
   149	
   150	    def _invoke(self, instruction, look_up=False, skip_self=False):
   151	        """
   152	        Function call in Android smali code. It will check if the corresponding
   153	        table field has a value, if it does,
   154	        inserts its own function name into called_by_func column.
   155	        """
   156	
   157	        opcode, *regList, targetMethod = instruction
   158	        regIdxList = [int(r[1:]) for r in regList]
   159	
   160	        if look_up and len(regIdxList) > 0:
   161	            try:
   162	                targetMethod = self._lookup_implement(
   163	                    self.table_obj.getLatestRegValue(
   164	                        regIdxList[0]
   165	                    ).current_type,
   166	                    instruction[-1],
   167	                    skip_self=skip_self,
   168	                )
   169	            except ValueError as e:
   170	                log.exception(e)
   171	            except IndexError:
   172	                pass
   173	
   174	        valueOfRegList = []
   175	        # query the value from hash table based on register index.
   176	        for index in regIdxList:
   177	            if not self.table_obj.getRegValues(index):
   178	                # Insert a RegisterObject if one is missing.
   179	                # Therefore, we can trace the usage of this register.
   180	                self.table_obj.insert(
   181	                    index, RegisterObject(Primitive("", None))
   182	                )
   183	
   184	            value = self.table_obj.getLatestRegValue(index)
   185	            valueOfRegList.append(value.value)
   186	
   187	        # Check whether any argument is missing a value type.
   188	        argIdxWithoutType = [
   189	            idx
   190	            for idx, arg in enumerate(valueOfRegList)
   191	            if isinstance(arg, Primitive) and arg.value_type == ""
   192	        ]
   193	        if len(argIdxWithoutType) > 0:
   194	            # Set the missing value types based on the method's descriptor.
   195	            argTypes = (
   196	                []
   197	                if opcode.startswith("invoke-static")
   198	                else [targetMethod[: targetMethod.find("->")]]
   199	            )
   200	
   201	            rawArgTypes = targetMethod[
   202	                targetMethod.find("(") + 1 : targetMethod.find(")")
   203	            ].split(" ")
   204	            
   205	            for argType in rawArgTypes:
   206	                argTypes.append(argType)
   207	                if argType in ["J", "D"]:
   208	                    # Put long and double twice
   209	                    # because these types take up two registers.
   210	                    argTypes.append(argType)
   211	
   212	            for argIdx in argIdxWithoutType:
   213	                valueOfRegList[argIdx].value_type = argTypes[argIdx]
   214	
   215	        methodCall = MethodCall(targetMethod, tuple(valueOfRegList))
   216	
   217	        # insert the function and the parameter into called_by_func
   218	        for index in regIdxList:
   219	            # add the function name into each parameter table
   220	            value = self.table_obj.getLatestRegValue(index)
   221	            value.called_by_func = methodCall
   222	
   223	            if (
   224	                value.bears_object()
   225	                and value.current_type != "Ljava/lang/String;"
   226	            ):
   227	                # If the register bears an object, update its value to reflect
   228	                # the method invocation since the method may modify the
   229	                # internal state of the object.
   230	                value.value = methodCall
   231	
   232	        if not targetMethod.endswith(")V"):
   233	            # push the return value into ret_stack
   234	            self.ret_stack.append(methodCall)
   235	
   236	            # Extract the type of return value
   237	            self.ret_type = targetMethod[targetMethod.index(")") + 1 :]
   238	
   239	    def _move_result(self, instruction):
   240

---

🧑‍🚒 Response (2):

👀‍ Observation (2):

Found 4 matches for "CAST_TYPE" in /quark-engine:
/quark-engine/docs/build/html/genindex.html (1 matches)
/quark-engine/docs/build/html/searchindex.js (1 matches)
/quark-engine/quark/evaluator/pyeval.py (2 matches)
End of matches for "CAST_TYPE" in /quark-engine

---

🧑‍🚒 Response (3):

👀‍ Observation (3):

Downloading sample APK from https://github.com/ev-flow/apk-samples/raw/refs/heads/master/malware-samples/Ahmyth.apk to /quark-engine/sample_apks...
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed

  0     0    0     0    0     0      0      0 --:--:-- --:--:-- --:--:--     0
  0     0    0     0    0     0      0      0 --:--:-- --:--:-- --:--:--     0

100  261k  100  261k    0     0   859k      0 --:--:-- --:--:-- --:--:--  859k
Successfully downloaded APK to /quark-engine/sample_apks.
-rw-r--r-- 1 root root 262K Mar  4 16:18 /quark-engine/sample_apks

---

🧑‍🚒 Response (4):

👀‍ Observation (4):

Found 2 matches for "CAST" in /quark-engine/quark/evaluator/pyeval.py:
Line 105:                self.eval[f"{first_type}-{second_type}"] = self.CAST_TYPE
Line 639:    def CAST_TYPE(self, instruction):
End of matches for "CAST" in /quark-engine/quark/evaluator/pyeval.py

---

🧑‍🚒 Response (5):

👀‍ Observation (5):

Here's the result of running `cat -n` on /quark-engine/quark/evaluator/pyeval.py:
   600	
   601	    @logger
   602	    def APUT_KIND(self, instruction):
   603	        try:
   604	            value, array_reference, index = instruction[1:]
   605	            self._move_value_to_register(
   606	                (None, array_reference, array_reference, index, value),
   607	                "{src0}[{src1}]:{src2}",
   608	            )
   609	        except IndexError as e:
   610	            log.exception(f"{e} in {instruction[0]}")
   611	
   612	    @logger
   613	    def APUT_WIDE_KIND(self, instruction):
   614	        try:
   615	            value, array_reference, index = instruction[1:]
   616	            self._move_value_to_register(
   617	                (
   618	                    None,
   619	                    array_reference,
   620	                    array_reference,
   621	                    index,
   622	                    value,
   623	                    f"v{int(value[1:])+1}",
   624	                ),
   625	                "{src0}[{src1}]:({src2}, {src3})",
   626	            )
   627	        except IndexError as e:
   628	            log.exception(f"{e} in {instruction[0]}")
   629	
   630	    @logger
   631	    def NEG_AND_NOT_KIND(self, instruction):
   632	        try:
   633	            wide = any(wide_type in instruction[0] for wide_type in ("double", "long"))
   634	            self._move_value_to_register(instruction, "{src0}", wide)
   635	        except IndexError as e:
   636	            log.exception(f"{e} in {instruction[0]}")
   637	
   638	    @logger
   639	    def CAST_TYPE(self, instruction):
   640	        try:
   641	            part = instruction[0].split("-")
   642	            value_type = self.type_mapping[part[1]]
   643	
   644	            if part[0] in ("double", "long"):
   645	                self._move_value_to_register(
   646	                    instruction + [f"v{int(instruction[2][1:])+1}"],
   647	                    "casting({src0}, {src1})",
   648	                    value_type=value_type,
   649	                )
   650	            elif part[1] in ("double", "long"):
   651	                self._move_value_to_register(
   652	                    instruction,
   653	                    "casting({src0})",
   654	                    value_type=value_type,
   655	                )
   656	                self._move_value_to_register(
   657	                    [
   658	                        instruction[0],
   659	                        f"v{int(instruction[1][1:])+1}",
   660	                        instruction[2],
   661	                    ],
   662	                    "casting({src0})",
   663	                    value_type=value_type,
   664	                )
   665	            else:
   666	                self._move_value_to_register(
   667	                    instruction,
   668	                    "casting({src0})",
   669	                    value_type=value_type,
   670	                )
   671	        except IndexError as e:
   672	            log.exception(f"{e} in {instruction[0]}")
   673	
   674	    @logger
   675	    def BINOP_KIND(self, instruction):
   676	        mnemonic = instruction[0]
   677	        index = mnemonic.index("-") + 1
   678	        if "/" in mnemonic:
   679	            r_index = mnemonic.index("/")
   680	            value_type = self.type_mapping[mnemonic[index:r_index]]
   681	        else:
   682	            value_type = self.type_mapping[mnemonic[index:]]
   683	
   684	        try:
   685	            wide = value_type in ("D", "J")
   686	
   687	            if "/2addr" in instruction[0]:
   688	                self._combine_value_to_register(
   689	                    instruction,
   690	                    "binop({src0}, {src1})",
   691	                    wide,
   692	                    value_type=value_type,
   693	                )
   694	            elif "/lit" in instruction[0]:
   695	                self._move_value_and_data_to_register(
   696	                    instruction,
   697	                    "binop({src0}, {data})",
   698	                    wide,
   699	                    value_type=value_type,
   700	                )

---

🧑‍🚒 Response (6):

👀‍ Observation (6):

File created successfully at: /quark-engine/repro_cast_issue.py

---

🧑‍🚒 Response (7):

👀‍ Observation (7):

Missing CAST_TYPE handlers for: int-to-long, long-to-int, float-to-double, double-to-float

---

🧑‍🚒 Response (8):

👀‍ Observation (8):

Found 2 matches for "-to-" in /quark-engine/quark:
/quark-engine/quark/webreport/analysis_report_layout.html (1 matches)
/quark-engine/quark/webreport/genrule_report_layout.html (1 matches)
End of matches for "-to-" in /quark-engine/quark

---

🧑‍🚒 Response (9):

👀‍ Observation (9):

The file /quark-engine/quark/evaluator/pyeval.py has been edited. Here's the result of running `cat -n` on a snippet of /quark-engine/quark/evaluator/pyeval.py:
    95	            self.eval[f"{prefix}-int"] = self.NEG_AND_NOT_KIND
    96	            self.eval[f"{prefix}-long"] = self.NEG_AND_NOT_KIND
    97	            self.eval[f"{prefix}-float"] = self.NEG_AND_NOT_KIND
    98	            self.eval[f"{prefix}-double"] = self.NEG_AND_NOT_KIND
    99	
   100	        # type casting
   101	        for first_type in ("int", "long", "float", "double"):
   102	            for second_type in ("int", "long", "float", "double"):
   103	                if first_type == second_type:
   104	                    continue
   105	                self.eval[f"{first_type}-to-{second_type}"] = self.CAST_TYPE
   106	
   107	        # binop_kind
   108	        for prefix in (
   109	            "add",
Review the changes and make sure they are as expected. Edit the file again if necessary.

---

🧑‍🚒 Response (10):

👀‍ Observation (10):

Here's the result of running `cat -n` on /quark-engine/quark/evaluator/pyeval.py:
   630	    @logger
   631	    def NEG_AND_NOT_KIND(self, instruction):
   632	        try:
   633	            wide = any(wide_type in instruction[0] for wide_type in ("double", "long"))
   634	            self._move_value_to_register(instruction, "{src0}", wide)
   635	        except IndexError as e:
   636	            log.exception(f"{e} in {instruction[0]}")
   637	
   638	    @logger
   639	    def CAST_TYPE(self, instruction):
   640	        try:
   641	            part = instruction[0].split("-")
   642	            value_type = self.type_mapping[part[1]]
   643	
   644	            if part[0] in ("double", "long"):
   645	                self._move_value_to_register(
   646	                    instruction + [f"v{int(instruction[2][1:])+1}"],
   647	                    "casting({src0}, {src1})",
   648	                    value_type=value_type,
   649	                )
   650	            elif part[1] in ("double", "long"):
   651	                self._move_value_to_register(
   652	                    instruction,
   653	                    "casting({src0})",
   654	                    value_type=value_type,
   655	                )
   656	                self._move_value_to_register(
   657	                    [
   658	                        instruction[0],
   659	                        f"v{int(instruction[1][1:])+1}",
   660	                        instruction[2],
   661	                    ],
   662	                    "casting({src0})",
   663	                    value_type=value_type,
   664	                )
   665	            else:
   666	                self._move_value_to_register(
   667	                    instruction,
   668	                    "casting({src0})",
   669	                    value_type=value_type,
   670	                )

---

🧑‍🚒 Response (11):

👀‍ Observation (11):

The file /quark-engine/quark/evaluator/pyeval.py has been edited. Here's the result of running `cat -n` on a snippet of /quark-engine/quark/evaluator/pyeval.py:
   634	            self._move_value_to_register(instruction, "{src0}", wide)
   635	        except IndexError as e:
   636	            log.exception(f"{e} in {instruction[0]}")
   637	
   638	    @logger
   639	    def CAST_TYPE(self, instruction):
   640	        try:
   641	            try:
   642	                src_type, dst_type = instruction[0].split("-to-")
   643	            except ValueError:
   644	                # Fallback for unexpected formats
   645	                src_type, dst_type = instruction[0].split("-")
   646	
   647	            value_type = self.type_mapping[dst_type]
   648	
   649	            if src_type in ("double", "long"):
   650	                self._move_value_to_register(
   651	                    instruction + [f"v{int(instruction[2][1:])+1}"],
   652	                    "casting({src0}, {src1})",
   653	                    value_type=value_type,
Review the changes and make sure they are as expected. Edit the file again if necessary.

---

🧑‍🚒 Response (12):

👀‍ Observation (12):

All expected CAST_TYPE handlers are registered.

---

🧑‍🚒 Response (13):

👀‍ Observation (13):

Found 2 matches for "-to-" in /quark-engine/quark/evaluator:
/quark-engine/quark/evaluator/pyeval.py (2 matches)
End of matches for "-to-" in /quark-engine/quark/evaluator

---

🧑‍🚒 Response (14):
I dug into quark/evaluator/pyeval.py and found the CAST_TYPE opcodes were registered as {type1}-{type2}, which mismatches Dalvik’s {type1}-to-{type2} naming. I added a quick repro script that checks for the expected *-to-* keys and verified it failed initially.

Changes made:

• Updated the opcode registration loop to use {first_type}-to-{second_type}.
• Updated CAST_TYPE parsing to split on -to- (with a fallback to the old format for robustness).

Repro script (repro_cast_issue.py) now passes:

cd /quark-engine && PYTHONPATH=. python repro_cast_issue.py
# All expected CAST_TYPE handlers are registered.

This aligns Quark with the Dalvik naming convention and matches Androguard/shuriken formats, so those cast instructions will no longer be skipped.
👀‍ Observation (14):

---

🧑‍🚒 Response (15):

👀‍ Observation (15):

Thank you for your work on this issue. Please carefully follow the steps below to help review your changes.

1. If you made any changes to your code after running the reproduction script, please run the reproduction script again.
   If the reproduction script is failing, please revisit your changes and make sure they are correct.
   If you have already removed your reproduction script, please ignore this step.
2. Remove your reproduction script (if you haven't done so already, use bash tool with `rm <filename.py>` to remove it).
3. Run the submit command again to confirm.

Here is a list of all of your changes:

<diff>
diff --git a/quark/evaluator/pyeval.py b/quark/evaluator/pyeval.py
index 94655f5..1054124 100644
--- a/quark/evaluator/pyeval.py
+++ b/quark/evaluator/pyeval.py
@@ -102,7 +102,7 @@ class PyEval:
             for second_type in ("int", "long", "float", "double"):
                 if first_type == second_type:
                     continue
-                self.eval[f"{first_type}-{second_type}"] = self.CAST_TYPE
+                self.eval[f"{first_type}-to-{second_type}"] = self.CAST_TYPE
 
         # binop_kind
         for prefix in (
@@ -638,10 +638,15 @@ class PyEval:
     @logger
     def CAST_TYPE(self, instruction):
         try:
-            part = instruction[0].split("-")
-            value_type = self.type_mapping[part[1]]
+            try:
+                src_type, dst_type = instruction[0].split("-to-")
+            except ValueError:
+                # Fallback for unexpected formats
+                src_type, dst_type = instruction[0].split("-")
+
+            value_type = self.type_mapping[dst_type]
 
-            if part[0] in ("double", "long"):
+            if src_type in ("double", "long"):
                 self._move_value_to_register(
                     instruction + [f"v{int(instruction[2][1:])+1}"],
                     "casting({src0}, {src1})",
diff --git a/repro_cast_issue.py b/repro_cast_issue.py
new file mode 100644
index 0000000..c690a36
--- /dev/null
+++ b/repro_cast_issue.py
@@ -0,0 +1,21 @@
+from quark.evaluator.pyeval import PyEval
+
+
+def main():
+    evaluator = PyEval(None)
+    expected = [
+        "int-to-long",
+        "long-to-int",
+        "float-to-double",
+        "double-to-float",
+    ]
+
+    missing = [key for key in expected if key not in evaluator.eval]
+    if missing:
+        raise SystemExit(f"Missing CAST_TYPE handlers for: {', '.join(missing)}")
+
+    print("All expected CAST_TYPE handlers are registered.")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/sample_apks b/sample_apks
new file mode 100644
index 0000000..d95bb7b
Binary files /dev/null and b/sample_apks differ

</diff>

---

🧑‍🚒 Response (16):

👀‍ Observation (16):

---

🧑‍🚒 Response (17):

👀‍ Observation (17):

diff --git a/quark/evaluator/pyeval.py b/quark/evaluator/pyeval.py
index 94655f5..1054124 100644
--- a/quark/evaluator/pyeval.py
+++ b/quark/evaluator/pyeval.py
@@ -102,7 +102,7 @@ class PyEval:
             for second_type in ("int", "long", "float", "double"):
                 if first_type == second_type:
                     continue
-                self.eval[f"{first_type}-{second_type}"] = self.CAST_TYPE
+                self.eval[f"{first_type}-to-{second_type}"] = self.CAST_TYPE
 
         # binop_kind
         for prefix in (
@@ -638,10 +638,15 @@ class PyEval:
     @logger
     def CAST_TYPE(self, instruction):
         try:
-            part = instruction[0].split("-")
-            value_type = self.type_mapping[part[1]]
+            try:
+                src_type, dst_type = instruction[0].split("-to-")
+            except ValueError:
+                # Fallback for unexpected formats
+                src_type, dst_type = instruction[0].split("-")
+
+            value_type = self.type_mapping[dst_type]
 
-            if part[0] in ("double", "long"):
+            if src_type in ("double", "long"):
                 self._move_value_to_register(
                     instruction + [f"v{int(instruction[2][1:])+1}"],
                     "casting({src0}, {src1})",
diff --git a/sample_apks b/sample_apks
new file mode 100644
index 0000000..d95bb7b
Binary files /dev/null and b/sample_apks differ