diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6990743d..06b60aee 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,10 @@
 
 This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.13.0] - 2022-05-02
+- Covergroup format revised.
+- Added support for Pseudoinstructions for coverage computation.
+
 ## [0.12.0] - 2022-04-15
 - Parallelized coverage computation.
 - Added feature to remove coverpoints when hit.
diff --git a/docs/source/cgf.rst b/docs/source/cgf.rst
index 00fcb01b..2372a6d3 100644
--- a/docs/source/cgf.rst
+++ b/docs/source/cgf.rst
@@ -12,7 +12,7 @@ Covergroup
 ==========
 A covergroup is a dictionary based on the following template. These dictionaries constitute the nodes in a cgf file. Each cover group contains the following type of coverpoints:
 
-* Opcode
+* Mnemonics (Used in conjunction with a `base_op` and a condtion `p_op_cond` node to describe a pseudo-instruction)
 * Register
 * Register Operand Combinations
 * Register/Immediate Value Combinations
@@ -22,16 +22,16 @@ A covergroup is a dictionary based on the following template. These dictionaries
 Template
 --------
 
-The template for defining a covergroup is as follows:
+The template for defining a non pseudo-op covergroup is as follows:
 
 .. code-block:: yaml
 
     <label>:
         config:
             - <config-str>
-        opcode:
-            <opcode-str>: 0
-            <opcode-str>: 0
+        mnemonics:
+            <mnemonics-str>: 0
+            <mnemonics-str>: 0
             ...
         rs1:
             <reg-str>: 0
@@ -64,7 +64,20 @@ The template for defining a covergroup is as follows:
             <crosscomb_str>:0
             <crosscomb_str>:0
            
+The template for defining a covergroup pertaining to a pseudo-op is as follows:
 
+.. code-block:: yaml
+
+    <label>:
+        config:
+            - <config-str>
+        mnemonics:
+            <mnemonics-str>: 0
+        base_op:
+            <base_op-str>
+        p_op_cond:
+            <p_op_cond-str>
+        ...
     
 Explanation
 -----------
@@ -84,13 +97,46 @@ A covergroup contains the following nodes:
 .. _RVTEST_CASE Condition Formating: https://riscof.readthedocs.io/en/latest/testformat.html?highlight=Macro#rvtest-case-condition-formating  
 .. _riscof: https://riscof.readthedocs.io/en/latest/index.html 
 
-* **opcode**
+* **mnemonics**
     *This node is mandatory for all covergroups except covergroups pertaining to CSR coverpoints (it's optional in this case).*
     
-    This node describes the *opcode coverpoints* necessary for the covergroup. Each *opcode* is treated as a valid coverpoint and the arguments of the corresponding instruction are used to update the rest of the coverpoint types.  
+    This node describes the *mnemonics coverpoints* necessary for the covergroup. Multiple entries are not allowed under this node when the `base_op` node is defined. Each mnemonic defined under *mnemonics* is treated as a valid coverpoint and the arguments of the corresponding instruction are used to update the rest of the coverpoint types.  
+
+        * **mnemonics-str**
+            A valid instruction or pseudoinstruction *mnemonic* in the RISCV Instruction Set.
+
+* **base_op**
+    *This node is optional and should be used only when the mnemonics node has a singular entry which is a pseudo-instruction.*
+
+    If the instruction defined in mnemonics is a pseudo-op, *base_op* field can be used to provide its corresponding base instruction.
+
+    Note that when *base_op* node is defined, the *mnemonics* node should only hold the pseudo-instruction.
+
+        * **base_op-str**
+            The base instruction corresponding to the pseudoinstruction defined in *mnemonics*
+
+* **p_op_cond**
+    *This node is mandatory when the ``base_op`` node is defined.*
+    
+    This node is used to supply the requisite conditions for the *base_op* to be identified as the pseudo-instruction in *mnemonics* node i.e describe th e instance of the base instruction corresponding to the pseudo-instruction.
 
-        * **opcode-str**
-            A valid *opcode* in the RISCV Instruction Set.
+        * **p_op_cond-str**
+            Conditions required for the base instruction to be congruent to the pseudoinstruction in *mnemonics*. Multiple conditions are joined using ``and``. For example, ``rs1 == x0 and imm == 3``
+            
+    Example: ``zext.h`` is a pseudo-instruction based on the ``pack`` instruction in ``RV32``. The node for ``zext.h`` will look like the following.
+    
+    .. code-block:: yaml
+    
+        zext.h_32:
+          config: 
+            - check ISA:=regex(.*RV32.*B.*)
+            - check ISA:=regex(.*RV32.*Zbb.*)
+          mnemonics: 
+            zext.h: 0
+          base_op: pack
+          p_op_cond: rs2 == x0
+          ...
+        
 
 * **rs1**
     *This node is optional.*
diff --git a/docs/source/pseudo_op_support.rst b/docs/source/pseudo_op_support.rst
new file mode 100644
index 00000000..ff610572
--- /dev/null
+++ b/docs/source/pseudo_op_support.rst
@@ -0,0 +1,48 @@
+*********************************
+Pseudo-Ops Support for RISCV-ISAC
+*********************************
+
+Coverpoints are defined in a CGF file under the ``opcode`` node in the CGF. This is a misnomer as ISAC and CTG
+deals with mnemonics of the instruction rather than the actual encoding. In order to deal with mnemonics of pseudo-Ops, 
+and its congruent base instruction definition, changes are brought to the CGF format.
+
+Format
+######
+The ``opcode`` field is renamed to ``mnemonics``. To support pseudo-instructions two new fields ``base_op`` and ``p_op_cond``
+are added to the covergroups. The ``base_op`` and ``p_op_cond`` are optional fields which specify the base operation and the
+condition over the different fields of the instruction which when satisfied results in the instruction being recognized as the
+pseudo-op mentioned in ``mnemonics``. As an example, ``zext.h`` is a pseudo-op of ``pack`` in RV32 and packw in RV64 with ``rs2``
+equal to ``x0``. Covergroup for ``zext.h`` pseudo-op can be expressed as follows: ::
+
+    zext.h_32:
+        config: 
+          - check ISA:=regex(.*RV32.*B.*)
+          - check ISA:=regex(.*RV32.*Zbb.*)
+        mnemonics: 
+          zext.h: 0
+        base_op: packw
+        p_op_cond: rs2 == x0
+        ...
+
+    zext.h_64:
+        config: 
+          - check ISA:=regex(.*RV64.*B.*)
+          - check ISA:=regex(.*RV64.*Zbb.*)
+        mnemonics: 
+          zext.h: 0
+        base_op: pack
+        p_op_cond: rs2 == x0
+        ...
+
+The ``expand_cgf`` method defined in ``cgf_normalize.py`` goes through every covergroup in the working cgf dictionary. If it encounters
+``opcode`` node, a deprecation warning is printed and ``opcode`` is renamed to ``mnemonics``. The method also facilitates checks to see
+if ``base_op`` and ``p_op_cond`` meets required conditions.
+
+While computing the coverage, if the decoded instruction under scrutiny is equal to the instruction mentioned in ``base_op`` of working
+covergroup, the conditions mentioned in ``p_op_cond`` are evaluated. If a match is found, the instruction defined in ``mnemonic`` field is
+assumed to be hit and the coverpoint hit statistics is updated accordingly. 
+
+Note
+####
+- The ``p_op_cond`` node is relevant only if the ``base_op`` node has been defined.
+- The ``mnemonics`` node is allowed to have multiple entries only if the ``base_op`` node is empty.
diff --git a/riscv_isac/__init__.py b/riscv_isac/__init__.py
index bd22125f..638deb32 100644
--- a/riscv_isac/__init__.py
+++ b/riscv_isac/__init__.py
@@ -4,4 +4,4 @@
 
 __author__ = """InCore Semiconductors Pvt Ltd"""
 __email__ = 'info@incoresemi.com'
-__version__ = '0.12.0'
+__version__ = '0.13.0'
diff --git a/riscv_isac/cgf_normalize.py b/riscv_isac/cgf_normalize.py
index 6ee8fdb1..0dba691b 100644
--- a/riscv_isac/cgf_normalize.py
+++ b/riscv_isac/cgf_normalize.py
@@ -6,6 +6,8 @@
 import copy
 from riscv_isac.fp_dataset import *
 
+import time
+
 def twos(val,bits):
     '''
     Finds the twos complement of the number
@@ -549,7 +551,7 @@ def alternate(var, size, signed=True, fltr_func=None,scale_func=None):
 def expand_cgf(cgf_files, xlen):
     '''
     This function will replace all the abstract functions with their unrolled
-    coverpoints
+    coverpoints. It replaces node
 
     :param cgf_files: list of yaml file paths which together define the coverpoints
     :param xlen: XLEN of the riscv-trace
@@ -557,10 +559,24 @@ def expand_cgf(cgf_files, xlen):
     :type cgf: list
     :type xlen: int
     '''
-
     cgf = utils.load_cgf(cgf_files)
     for labels, cats in cgf.items():
         if labels != 'datasets':
+            # If 'opcode' found, rename it to 'mnemonics'
+            if 'opcode' in cats:
+                logger.warning("Deprecated node used: 'opcode'. Use 'mnemonics' instead")
+                
+                temp = cgf[labels]['opcode']
+                del cgf[labels]['opcode']
+                cgf[labels].insert(1, 'mnemonics', temp)
+
+                if 'base_op' in cats:
+                    if 'p_op_cond' not in cats:
+                        logger.error(f'p_op_cond node not found in {labels} label.')
+
+                    if len(cgf[labels]['mnemonics'].keys()) > 1:
+                        logger.error(f'Multiple instruction mnemonics found when base_op label defined in {labels} label.')
+
             for label,node in cats.items():
                 if isinstance(node,dict):
                     if 'abstract_comb' in node:
diff --git a/riscv_isac/coverage.py b/riscv_isac/coverage.py
index 83c6f805..89600d5d 100644
--- a/riscv_isac/coverage.py
+++ b/riscv_isac/coverage.py
@@ -2,6 +2,7 @@
 # See LICENSE.incore for details
 # See LICENSE.iitm for details
 
+from itertools import islice
 import ruamel
 from ruamel.yaml import YAML
 import riscv_isac.utils as utils
@@ -375,13 +376,13 @@ def gen_report(cgf, detailed):
             total_uncovered = 0
             total_categories = 0
             for categories in value:
-                if categories not in ['cond','config','ignore']:
+                if categories not in ['cond','config','ignore', 'base_op', 'p_op_cond']:
                     for coverpoints, coverage in value[categories].items():
                         if coverage == 0:
                             total_uncovered += 1
                     total_categories += len(value[categories])
             for categories in value:
-                if categories not in ['cond','config','ignore']:
+                if categories not in ['cond','config','ignore', 'base_op', 'p_op_cond']:
                     uncovered = 0
                     for coverpoints, coverage in value[categories].items():
                         if coverage == 0:
@@ -478,7 +479,7 @@ def merge_coverage(inp_files, cgf, detailed, xlen, p=1):
     temp = merge_fn(files,cgf,p)
     for cov_labels, value in temp.items():
         for categories in value:
-            if categories not in ['cond','config','ignore','total_coverage','coverage']:
+            if categories not in ['cond','config','ignore','total_coverage','coverage', 'base_op', 'p_op_cond']:
                 for coverpoints, coverage in value[categories].items():
                     if coverpoints in cgf[cov_labels][categories]:
                         cgf[cov_labels][categories][coverpoints] += coverage
@@ -580,10 +581,10 @@ def compute_per_line(queue, event, cgf_queue, stats_queue, cgf, xlen, addr_pairs
             commitvalue = instr.reg_commit
 
             # assign default values to operands
-            rs1 = 0
-            rs2 = 0
-            rs3 = 0
-            rd  = 0
+            nxf_rs1 = 0
+            nxf_rs2 = 0
+            nxf_rs3 = 0
+            nxf_rd  = 0
             rs1_type = 'x'
             rs2_type = 'x'
             rs3_type = 'f'
@@ -605,27 +606,35 @@ def compute_per_line(queue, event, cgf_queue, stats_queue, cgf, xlen, addr_pairs
             
             # check if instruction lies within the valid region of interest
             if addr_pairs:
-
                 if any([instr.instr_addr >= saddr and instr.instr_addr < eaddr for saddr,eaddr in addr_pairs]):
                     enable = True
                 else:
                     enable = False
             else:
                 enable=True
+            
             # capture the operands and their values from the regfile
             if instr.rs1 is not None:
-                rs1 = instr.rs1[0]
                 rs1_type = instr.rs1[1]
+                rs1 = rs1_type + str(instr.rs1[0])
+                nxf_rs1 = instr.rs1[0]
+                exec(f'{rs1} = rs1')
             if instr.rs2 is not None:
-                rs2 = instr.rs2[0]
                 rs2_type = instr.rs2[1]
+                rs2 = rs2_type + str(instr.rs2[0])
+                nxf_rs2 = instr.rs2[0]
+                exec(f'{rs2} = rs2')
             if instr.rs3 is not None:
-                rs3 = instr.rs3[0]
                 rs3_type = instr.rs3[1]
+                rs3 = rs3_type + str(instr.rs3[0])
+                nxf_rs3 = instr.rs3[0]
+                exec(f'{rs3} = rs3')
             if instr.rd is not None:
-                rd = instr.rd[0]
                 is_rd_valid = True
                 rd_type = instr.rd[1]
+                rd = rd_type + str(instr.rd[0])
+                nxf_rd = instr.rd[0]
+                exec(f'{rd} = rd')
             else:
                 is_rd_valid = False
             if instr.imm is not None:
@@ -635,34 +644,34 @@ def compute_per_line(queue, event, cgf_queue, stats_queue, cgf, xlen, addr_pairs
             
             # special value conversion based on signed/unsigned operations
             if instr.instr_name in unsgn_rs1:
-                rs1_val = struct.unpack(unsgn_sz, bytes.fromhex(arch_state.x_rf[rs1]))[0]
+                rs1_val = struct.unpack(unsgn_sz, bytes.fromhex(arch_state.x_rf[nxf_rs1]))[0]
             elif instr.is_rvp:
-                rs1_val = struct.unpack(unsgn_sz, bytes.fromhex(arch_state.x_rf[rs1]))[0]
+                rs1_val = struct.unpack(unsgn_sz, bytes.fromhex(arch_state.x_rf[nxf_rs1]))[0]
                 if instr.rs1_nregs == 2:
-                    rs1_hi_val = struct.unpack(unsgn_sz, bytes.fromhex(arch_state.x_rf[rs1+1]))[0]
+                    rs1_hi_val = struct.unpack(unsgn_sz, bytes.fromhex(arch_state.x_rf[nxf_rs1+1]))[0]
                     rs1_val = (rs1_hi_val << 32) | rs1_val
             elif rs1_type == 'x':
-                rs1_val = struct.unpack(sgn_sz, bytes.fromhex(arch_state.x_rf[rs1]))[0]
+                rs1_val = struct.unpack(sgn_sz, bytes.fromhex(arch_state.x_rf[nxf_rs1]))[0]
                 if instr.instr_name in ["fmv.w.x"]:
-                    rs1_val = '0x' + (arch_state.x_rf[rs1]).lower()
+                    rs1_val = '0x' + (arch_state.x_rf[nxf_rs1]).lower()
             elif rs1_type == 'f':
-                rs1_val = struct.unpack(sgn_sz, bytes.fromhex(arch_state.f_rf[rs1]))[0]
+                rs1_val = struct.unpack(sgn_sz, bytes.fromhex(arch_state.f_rf[nxf_rs1]))[0]
                 if instr.instr_name in ["fadd.s","fsub.s","fmul.s","fdiv.s","fsqrt.s","fmadd.s","fmsub.s","fnmadd.s","fnmsub.s","fmax.s","fmin.s","feq.s","flt.s","fle.s","fmv.x.w","fmv.w.x","fcvt.wu.s","fcvt.s.wu","fcvt.w.s","fcvt.s.w","fsgnj.s","fsgnjn.s","fsgnjx.s","fclass.s"]:
-                    rs1_val = '0x' + (arch_state.f_rf[rs1]).lower()
+                    rs1_val = '0x' + (arch_state.f_rf[nxf_rs1]).lower()
             
             if instr.instr_name in unsgn_rs2:
-                rs2_val = struct.unpack(unsgn_sz, bytes.fromhex(arch_state.x_rf[rs2]))[0]
+                rs2_val = struct.unpack(unsgn_sz, bytes.fromhex(arch_state.x_rf[nxf_rs2]))[0]
             elif instr.is_rvp:
-                rs2_val = struct.unpack(unsgn_sz, bytes.fromhex(arch_state.x_rf[rs2]))[0]
+                rs2_val = struct.unpack(unsgn_sz, bytes.fromhex(arch_state.x_rf[nxf_rs2]))[0]
                 if instr.rs2_nregs == 2:
-                    rs2_hi_val = struct.unpack(unsgn_sz, bytes.fromhex(arch_state.x_rf[rs2+1]))[0]
+                    rs2_hi_val = struct.unpack(unsgn_sz, bytes.fromhex(arch_state.x_rf[nxf_rs2+1]))[0]
                     rs2_val = (rs2_hi_val << 32) | rs2_val
             elif rs2_type == 'x':
-                rs2_val = struct.unpack(sgn_sz, bytes.fromhex(arch_state.x_rf[rs2]))[0]
+                rs2_val = struct.unpack(sgn_sz, bytes.fromhex(arch_state.x_rf[nxf_rs2]))[0]
             elif rs2_type == 'f':
-                rs2_val = struct.unpack(sgn_sz, bytes.fromhex(arch_state.f_rf[rs2]))[0]
+                rs2_val = struct.unpack(sgn_sz, bytes.fromhex(arch_state.f_rf[nxf_rs2]))[0]
                 if instr.instr_name in ["fadd.s","fsub.s","fmul.s","fdiv.s","fmadd.s","fmsub.s","fnmadd.s","fnmsub.s","fmax.s","fmin.s","feq.s","flt.s","fle.s","fsgnj.s","fsgnjn.s","fsgnjx.s"]:
-                    rs2_val = '0x' + (arch_state.f_rf[rs2]).lower()
+                    rs2_val = '0x' + (arch_state.f_rf[nxf_rs2]).lower()
 
             sig_update = False
             if instr.instr_name in ['sh','sb','sw','sd','c.sw','c.sd','c.swsp','c.sdsp'] and sig_addrs:
@@ -678,7 +687,7 @@ def compute_per_line(queue, event, cgf_queue, stats_queue, cgf, xlen, addr_pairs
                 result_count = instr.rd_nregs
 
             if instr.instr_name in ["fmadd.s","fmsub.s","fnmadd.s","fnmsub.s"]:
-                rs3_val = '0x' + (arch_state.f_rf[rs3]).lower()
+                rs3_val = '0x' + (arch_state.f_rf[nxf_rs3]).lower()
 
             if instr.instr_name in ['csrrwi']:
                 arch_state.fcsr = instr.zimm
@@ -710,87 +719,86 @@ def compute_per_line(queue, event, cgf_queue, stats_queue, cgf, xlen, addr_pairs
                 local_dict[i] = int(csr_regfile[i],16)
 
             local_dict['xlen'] = xlen
-
+            
             if enable :
                 for cov_labels,value in cgf.items():
                     if cov_labels != 'datasets':
-                        if 'opcode' in value:
-                            if instr.instr_name in value['opcode']:
+                        if 'mnemonics' in value:
+                            
+                            req_node = 'mnemonics'
+                            is_found = False
+                            
+                            # Check if there is a base opcode
+                            if 'base_op' in value:
+                                # If base-op is the current instruction name, check for the p_op_cond node
+                                # If conditions satisfy, the instruction is equivalent to the mnemonic
+                                if instr.instr_name == value['base_op']:
+                                    
+                                    conds = value['p_op_cond']
+                                    # Construct and evaluate conditions
+                                    is_found = True
+                                    if not eval(conds):
+                                        is_found = False
+                                    
+                                    mnemonic = list(value[req_node].keys())
+                                    mnemonic = mnemonic[0]
+                                    
+                                    # Update hit statistics of the mnemonic
+                                    if is_found:
+                                        if value[req_node][mnemonic] == 0:
+                                            stats.ucovpt.append('mnemonic : ' + mnemonic)
+                                        stats.covpt.append('mnemonic : ' + mnemonic)
+                                        value[req_node][mnemonic] += 1
+                                        rcgf[cov_labels][req_node][mnemonic] += 1
+
+                            if instr.instr_name in value[req_node] or is_found:
                                 if stats.code_seq:
-                                    logger.error('Found a coverpoint without sign Upd ' + str(stats.code_seq))
+                                    #logger.error('Found a coverpoint without sign Upd ' + str(stats.code_seq))
                                     stats.stat3.append('\n'.join(stats.code_seq))
                                     stats.code_seq = []
                                     stats.covpt = []
                                     stats.ucovpt = []
                                     stats.ucode_seq = []
-
-                                if value['opcode'][instr.instr_name] == 0:
-                                    stats.ucovpt.append('opcode : ' + instr.instr_name)
-                                stats.covpt.append('opcode : ' + instr.instr_name)
-                                value['opcode'][instr.instr_name] += 1
-                                rcgf[cov_labels]['opcode'][instr.instr_name] += 1
                                 
-                                if 'rs1' in value and 'x'+str(rs1) in value['rs1']:
-                                    if value['rs1']['x'+str(rs1)] == 0:
-                                        stats.ucovpt.append('rs1 : ' + 'x'+str(rs1))
-                                        if no_count:
-                                            hit_covpts.append((cov_labels, 'rs1', 'x'+str(rs1)))
-                                    stats.covpt.append('rs1 : ' + 'x'+str(rs1))
-                                    value['rs1']['x'+str(rs1)] += 1
+                                # If mnemonic not detected via base-op
+                                if not is_found:
+                                    if value[req_node][instr.instr_name] == 0:
+                                        stats.ucovpt.append('mnemonic : ' + instr.instr_name)
+                                    stats.covpt.append('mnemonic : ' + instr.instr_name)
+                                    value[req_node][instr.instr_name] += 1
+                                    rcgf[cov_labels][req_node][instr.instr_name] += 1
                                 
-                                if 'rs2' in value and 'x'+str(rs2) in value['rs2']:
-                                    if value['rs2']['x'+str(rs2)] == 0:
-                                        stats.ucovpt.append('rs2 : ' + 'x'+str(rs2))
+                                if 'rs1' in value and rs1 in value['rs1']:
+                                    if value['rs1'][rs1] == 0:
+                                        stats.ucovpt.append('rs1 : ' + rs1)
                                         if no_count:
-                                            hit_covpts.append((cov_labels, 'rs2', 'x'+str(rs2)))
-
-                                    stats.covpt.append('rs2 : ' + 'x'+str(rs2))
-                                    value['rs2']['x'+str(rs2)] += 1
+                                            hit_covpts.append((cov_labels, 'rs1', rs1))
+                                    stats.covpt.append('rs1 : ' + rs1)
+                                    value['rs1'][rs1] += 1
                                 
-                                if 'rd' in value and is_rd_valid and 'x'+str(rd) in value['rd']:
-                                    if value['rd']['x'+str(rd)] == 0:
-                                        stats.ucovpt.append('rd : ' + 'x'+str(rd))
-                                        if no_count:
-                                            hit_covpts.append((cov_labels, 'rd', 'x'+str(rd)))
-
-                                    stats.covpt.append('rd : ' + 'x'+str(rd))
-                                    value['rd']['x'+str(rd)] += 1
-
-                                if 'rs1' in value and 'f'+str(rs1) in value['rs1']:
-                                    if value['rs1']['f'+str(rs1)] == 0:
-                                        stats.ucovpt.append('rs1 : ' + 'f'+str(rs1))
+                                if 'rs2' in value and rs2 in value['rs2']:
+                                    if value['rs2'][rs2] == 0:
+                                        stats.ucovpt.append('rs2 : ' + rs2)
                                         if no_count:
-                                            hit_covpts.append((cov_labels, 'rs1', 'f'+str(rs1)))
-
-                                    stats.covpt.append('rs1 : ' + 'f'+str(rs1))
-                                    value['rs1']['f'+str(rs1)] += 1
+                                            hit_covpts.append((cov_labels, 'rs2', rs2))
+                                    stats.covpt.append('rs2 : ' + rs2)
+                                    value['rs2'][rs2] += 1
                                 
-                                if 'rs2' in value and 'f'+str(rs2) in value['rs2']:
-                                    if value['rs2']['f'+str(rs2)] == 0:
-                                        stats.ucovpt.append('rs2 : ' + 'f'+str(rs2))
+                                if 'rd' in value and is_rd_valid and rd in value['rd']:
+                                    if value['rd'][rd] == 0:
+                                        stats.ucovpt.append('rd : ' + rd)
                                         if no_count:
-                                            hit_covpts.append((cov_labels, 'rs1', 'f'+str(rs2)))
-
-                                    stats.covpt.append('rs2 : ' + 'f'+str(rs2))
-                                    value['rs2']['f'+str(rs2)] += 1
-                                
-                                if 'rs3' in value and 'f'+str(rs3) in value['rs3']:
-                                    if value['rs3']['f'+str(rs3)] == 0:
-                                        stats.ucovpt.append('rs3 : ' + 'f'+str(rs3))
-                                        if no_count:
-                                            hit_covpts.append((cov_labels, 'rs3', 'f'+str(rs3)))
-
-                                    stats.covpt.append('rs3 : ' + 'f'+str(rs3))
-                                    value['rs3']['f'+str(rs3)] += 1
+                                            hit_covpts.append((cov_labels, 'rd', rd))
+                                    stats.covpt.append('rd : ' + rd)
+                                    value['rd'][rd] += 1
                                 
-                                if 'rd' in value and is_rd_valid and 'f'+str(rd) in value['rd']:
-                                    if value['rd']['f'+str(rd)] == 0:
-                                        stats.ucovpt.append('rd : ' + 'f'+str(rd))
+                                if 'rs3' in value and rs3 in value['rs3']:
+                                    if value['rs3'][rs3] == 0:
+                                        stats.ucovpt.append('rs3 : ' + rs3)
                                         if no_count:
-                                            hit_covpts.append((cov_labels, 'rd', 'x'+str(rd)))
-
-                                    stats.covpt.append('rd : ' + 'f'+str(rd))
-                                    value['rd']['f'+str(rd)] += 1
+                                            hit_covpts.append((cov_labels, 'rs3', rs3))
+                                    stats.covpt.append('rs3 : ' + rs3)
+                                    value['rs3'][rs3] += 1
 
                                 if 'op_comb' in value and len(value['op_comb']) != 0 :
                                     for coverpoints in value['op_comb']:
@@ -799,9 +807,9 @@ def compute_per_line(queue, event, cgf_queue, stats_queue, cgf, xlen, addr_pairs
                                                 stats.ucovpt.append(str(coverpoints))
                                                 if no_count:
                                                     hit_covpts.append((cov_labels, 'op_comb', coverpoints))
-
                                             stats.covpt.append(str(coverpoints))
                                             cgf[cov_labels]['op_comb'][coverpoints] += 1
+
                                 if 'val_comb' in value and len(value['val_comb']) != 0:
                                     if instr.instr_name in ['fadd.s',"fsub.s","fmul.s","fdiv.s","fmax.s","fmin.s","feq.s","flt.s","fle.s","fsgnj.s","fsgnjn.s","fsgnjx.s"]:
                                             val_key = fmt.extract_fields(32, rs1_val, str(1))
@@ -915,7 +923,7 @@ def compute_per_line(queue, event, cgf_queue, stats_queue, cgf, xlen, addr_pairs
 
             if instr.instr_name in ['sh','sb','sw','sd','c.sw','c.sd','c.swsp','c.sdsp'] and sig_addrs:
                 store_address = rs1_val + imm_val
-                store_val = '0x'+arch_state.x_rf[rs2]
+                store_val = '0x'+arch_state.x_rf[nxf_rs2]
                 for start, end in sig_addrs:
                     if store_address >= start and store_address <= end:
                         logger.debug('Signature update : ' + str(hex(store_address)))
@@ -1102,7 +1110,7 @@ def compute(trace_file, test_name, cgf, parser_name, decoder_name, detailed, xle
         if instr is None:
             continue
         instrObj = (decoder.decode(instrObj_temp = instrObj_temp))[0]
-
+        
         # Pass instrObjs to queues pertaining to each processes
         for each in queue_list:
             each.put_nowait(instrObj)
@@ -1179,7 +1187,7 @@ def compute(trace_file, test_name, cgf, parser_name, decoder_name, detailed, xle
                 total_uncovered = 0
                 total_categories = 0
                 for categories in value:
-                    if categories not in ['cond','config','ignore', 'total_coverage', 'coverage']:
+                    if categories not in ['cond','config','ignore', 'total_coverage', 'coverage', 'base_op', 'p_op_cond']:
                         for coverpoints, coverage in value[categories].items():
                             if coverage == 0:
                                 total_uncovered += 1
diff --git a/setup.cfg b/setup.cfg
index 355dfc47..7f2b805d 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.12.0
+current_version = 0.13.0
 commit = True
 tag = True
 
diff --git a/setup.py b/setup.py
index 3de519d7..40acdcbb 100644
--- a/setup.py
+++ b/setup.py
@@ -26,7 +26,7 @@ def read_requires():
 
 setup(
     name='riscv_isac',
-    version='0.12.0',
+    version='0.13.0',
     description="RISC-V ISAC",
     long_description=readme + '\n\n',
     classifiers=[