diff --git a/py_gen/codegen.py b/py_gen/codegen.py
index 75e5460..66e0454 100644
--- a/py_gen/codegen.py
+++ b/py_gen/codegen.py
@@ -32,132 +32,77 @@
 import loxi_utils.loxi_utils as utils
 import util
 import oftype
+from loxi_ir import *
 
-OFClass = namedtuple('OFClass', ['name', 'pyname', 'members', 'type_members',
-                                 'min_length', 'is_fixed_length'])
-Member = namedtuple('Member', ['name', 'oftype'])
-LengthMember = namedtuple('LengthMember', ['name', 'oftype'])
-FieldLengthMember = namedtuple('FieldLengthMember', ['name', 'oftype', 'field_name'])
-TypeMember = namedtuple('TypeMember', ['name', 'oftype', 'value'])
-PadMember = namedtuple('PadMember', ['length'])
+PyOFClass = namedtuple('PyOFClass', ['name', 'pyname', 'members', 'type_members',
+                                     'min_length', 'is_fixed_length'])
 
-# XXX move to frontend
-field_length_members = {
-    ('of_packet_out', 1, 'actions_len') : 'actions',
-    ('of_packet_out', 2, 'actions_len') : 'actions',
-    ('of_packet_out', 3, 'actions_len') : 'actions',
-    ('of_packet_out', 4, 'actions_len') : 'actions',
-}
-
-def get_type_values(cls, version):
-    """
-    Returns a map from the name of the type member to its value.
-    """
-    type_values = {}
-
-    # Primary wire type
-    if utils.class_is_message(cls):
-        type_values['version'] = 'const.OFP_VERSION'
-        type_values['type'] = util.constant_for_value(version, "ofp_type", util.primary_wire_type(cls, version))
-        if cls in type_maps.flow_mod_list:
-            type_values['_command'] = util.constant_for_value(version, "ofp_flow_mod_command",
-                                                              type_maps.flow_mod_types[version][cls[8:]])
-        if cls in type_maps.stats_request_list:
-            type_values['stats_type'] = util.constant_for_value(version, "ofp_stats_types",
-                                                                type_maps.stats_types[version][cls[3:-14]])
-        if cls in type_maps.stats_reply_list:
-            type_values['stats_type'] = util.constant_for_value(version, "ofp_stats_types",
-                                                                type_maps.stats_types[version][cls[3:-12]])
-        if type_maps.message_is_extension(cls, version):
-            type_values['experimenter'] = '%#x' % type_maps.extension_to_experimenter_id(cls)
-            type_values['subtype'] = type_maps.extension_message_to_subtype(cls, version)
-    elif utils.class_is_action(cls):
-        type_values['type'] = util.constant_for_value(version, "ofp_action_type", util.primary_wire_type(cls, version))
-        if type_maps.action_is_extension(cls, version):
-            type_values['experimenter'] = '%#x' % type_maps.extension_to_experimenter_id(cls)
-            type_values['subtype'] = type_maps.extension_action_to_subtype(cls, version)
-    elif utils.class_is_queue_prop(cls):
-        type_values['type'] = util.constant_for_value(version, "ofp_queue_properties", util.primary_wire_type(cls, version))
-    elif utils.class_is_hello_elem(cls):
-        type_values['type'] = util.constant_for_value(version, "ofp_hello_elem_type", util.primary_wire_type(cls, version))
+# Return the name for the generated Python class
+def generate_pyname(cls):
+    if utils.class_is_action(cls):
+        return cls[10:]
     elif utils.class_is_oxm(cls):
-        oxm_class = 0x8000
-        oxm_type = util.primary_wire_type(cls, version)
-        oxm_masked = cls.find('masked') != -1 and 1 or 0
-        oxm_len = of_g.base_length[(cls, version)] - 4
-        type_values['type_len'] = '%#x' % (oxm_class << 16 | oxm_type << 8 | \
-                                           oxm_masked << 8 | oxm_len)
-    elif cls == "of_match_v2":
-        type_values['type'] = 0
-    elif cls == "of_match_v3":
-        type_values['type'] = 1
+        return cls[7:]
     elif utils.class_is_meter_band(cls):
-        type_values['type'] = util.constant_for_value(version, "ofp_meter_band_type", util.primary_wire_type(cls, version))
+        return cls[14:]
     elif utils.class_is_instruction(cls):
-        type_values['type'] = util.constant_for_value(version, "ofp_instruction_type", util.primary_wire_type(cls, version))
+        return cls[15:]
+    else:
+        return cls[3:]
 
-    return type_values
-
-# Create intermediate representation
+# Create intermediate representation, extended from the LOXI IR
+# HACK the oftype member attribute is replaced with an OFType instance
 def build_ofclasses(version):
     blacklist = ["of_experimenter", "of_action_experimenter"]
     ofclasses = []
-    for cls in of_g.standard_class_order:
+    for ofclass in of_g.ir[version].classes:
+        cls = ofclass.name
         if type_maps.class_is_virtual(cls):
             continue
-        if version not in of_g.unified[cls] or cls in blacklist:
+        if cls in blacklist:
             continue
-        unified_class = util.lookup_unified_class(cls, version)
 
-        # Name for the generated Python class
-        if utils.class_is_action(cls):
-            pyname = cls[10:]
-        elif utils.class_is_oxm(cls):
-            pyname = cls[7:]
-        elif utils.class_is_meter_band(cls):
-            pyname = cls[14:]
-        elif utils.class_is_instruction(cls):
-            pyname = cls[15:]
-        else:
-            pyname = cls[3:]
-
-        type_values = get_type_values(cls, version)
         members = []
         type_members = []
 
-        pad_count = 0
-
-        for member in unified_class['members']:
-            if member['name'] in ['length', 'len']:
-                members.append(LengthMember(name=member['name'],
-                                            oftype=oftype.OFType(member['m_type'], version)))
-            elif (cls, version, member['name']) in field_length_members:
-                field_name = field_length_members[(cls, version, member['name'])]
-                members.append(FieldLengthMember(name=member['name'],
-                                                 oftype=oftype.OFType(member['m_type'], version),
-                                                 field_name=field_name))
-            elif member['name'] in type_values:
-                members.append(TypeMember(name=member['name'],
-                                          oftype=oftype.OFType(member['m_type'], version),
-                                          value=type_values[member['name']]))
+        for m in ofclass.members:
+            if type(m) == OFTypeMember:
+                members.append(OFTypeMember(
+                    name=m.name,
+                    oftype=oftype.OFType(m.oftype, version),
+                    value=m.value))
                 type_members.append(members[-1])
-            elif member['name'].startswith("pad"):
-                # HACK this should be moved to the frontend
-                pad_oftype = oftype.OFType(member['m_type'], version)
-                length = struct.calcsize("!" + pad_oftype._pack_fmt())
-                if pad_oftype.is_array: length *= pad_oftype.array_length
-                members.append(PadMember(length=length))
-            else:
-                members.append(Member(name=member['name'],
-                                      oftype=oftype.OFType(member['m_type'], version)))
+            elif type(m) == OFLengthMember:
+                members.append(OFLengthMember(
+                    name=m.name,
+                    oftype=oftype.OFType(m.oftype, version)))
+            elif type(m) == OFFieldLengthMember:
+                members.append(OFFieldLengthMember(
+                    name=m.name,
+                    oftype=oftype.OFType(m.oftype, version),
+                    field_name=m.field_name))
+            elif type(m) == OFPadMember:
+                members.append(m)
+            elif type(m) == OFDataMember:
+                if utils.class_is_message(ofclass.name) and m.name == 'version':
+                    # HACK move to frontend
+                    members.append(OFTypeMember(
+                        name=m.name,
+                        oftype=oftype.OFType(m.oftype, version),
+                        value=version))
+                    type_members.append(members[-1])
+                else:
+                    members.append(OFDataMember(
+                        name=m.name,
+                        oftype=oftype.OFType(m.oftype, version)))
 
         ofclasses.append(
-            OFClass(name=cls,
-                    pyname=pyname,
-                    members=members,
-                    type_members=type_members,
-                    min_length=of_g.base_length[(cls, version)],
-                    is_fixed_length=(cls, version) in of_g.is_fixed_length))
+            PyOFClass(name=cls,
+                      pyname=generate_pyname(cls),
+                      members=members,
+                      type_members=type_members,
+                      min_length=of_g.base_length[(cls, version)],
+                      is_fixed_length=(cls, version) in of_g.is_fixed_length))
     return ofclasses
 
 def generate_init(out, name, version):
diff --git a/py_gen/oftype.py b/py_gen/oftype.py
index 3f37f57..679d9d6 100644
--- a/py_gen/oftype.py
+++ b/py_gen/oftype.py
@@ -46,7 +46,7 @@
         self.is_array = self.array_length != 1
 
     def gen_init_expr(self):
-        if utils.class_is_list(self.base):
+        if self.base.startswith('list('):
             v = "[]"
         elif self.base.find("uint") == 0 or self.base in ["char", "of_port_no_t"]:
             v = "0"
@@ -89,7 +89,7 @@
             return 'struct.pack("!%s%s", *%s)' % (self.array_length, pack_fmt, expr_expr)
         elif self.base == 'of_octets_t':
             return expr_expr
-        elif utils.class_is_list(self.base):
+        elif self.base.startswith('list('):
             return '"".join([x.pack() for x in %s])' % expr_expr
         elif self.base == 'of_mac_addr_t':
             return 'struct.pack("!6B", *%s)' % expr_expr
@@ -114,7 +114,7 @@
         if pack_fmt and not self.is_array:
             return "%s.read('!%s')[0]" % (reader_expr, pack_fmt)
         elif pack_fmt and self.is_array:
-            return "list(%s.read('!%d%s'))" % (self.array_length, pack_fmt)
+            return "list(%s.read('!%d%s'))" % (reader_expr, self.array_length, pack_fmt)
         elif self.base == 'of_octets_t':
             return "str(%s.read_all())" % (reader_expr)
         elif self.base == 'of_mac_addr_t':
@@ -125,28 +125,28 @@
             return 'common.match.unpack(%s)' % (reader_expr)
         elif self.base == 'of_port_desc_t':
             return 'common.port_desc.unpack(%s)' % (reader_expr)
-        elif self.base == 'of_list_action_t':
+        elif self.base == 'list(of_action_t)':
             return 'action.unpack_list(%s)' % (reader_expr)
-        elif self.base == 'of_list_flow_stats_entry_t':
+        elif self.base == 'list(of_flow_stats_entry_t)':
             return 'common.unpack_list_flow_stats_entry(%s)' % (reader_expr)
-        elif self.base == 'of_list_queue_prop_t':
+        elif self.base == 'list(of_queue_prop_t)':
             return 'common.unpack_list_queue_prop(%s)' % (reader_expr)
-        elif self.base == 'of_list_packet_queue_t':
+        elif self.base == 'list(of_packet_queue_t)':
             return 'common.unpack_list_packet_queue(%s)' % (reader_expr)
-        elif self.base == 'of_list_hello_elem_t':
+        elif self.base == 'list(of_hello_elem_t)':
             return 'common.unpack_list_hello_elem(%s)' % (reader_expr)
-        elif self.base == 'of_list_oxm_t':
+        elif self.base == 'list(of_oxm_t)':
             # HACK need the match_v3 length field
             return 'oxm.unpack_list(%s.slice(_length-4))' % (reader_expr)
-        elif self.base == 'of_list_bucket_t':
+        elif self.base == 'list(of_bucket_t)':
             return 'common.unpack_list_bucket(%s)' % (reader_expr)
-        elif self.base == 'of_list_group_desc_stats_entry_t':
+        elif self.base == 'list(of_group_desc_stats_entry_t)':
             return 'common.unpack_list_group_desc_stats_entry(%s)' % (reader_expr)
-        elif self.base == 'of_list_group_stats_entry_t':
+        elif self.base == 'list(of_group_stats_entry_t)':
             return 'common.unpack_list_group_stats_entry(%s)' % (reader_expr)
-        elif self.base == 'of_list_meter_band_t':
+        elif self.base == 'list(of_meter_band_t)':
             return 'meter_band.unpack_list(%s)' % (reader_expr)
-        elif self.base == 'of_list_meter_stats_t':
+        elif self.base == 'list(of_meter_stats_t)':
             return 'common.unpack_list_meter_stats(%s)' % (reader_expr)
         elif self.base == 'of_port_name_t':
             return self._gen_string_unpack_expr(reader_expr, 16)
@@ -156,13 +156,13 @@
             return self._gen_string_unpack_expr(reader_expr, 256)
         elif self.base == 'of_meter_features_t':
             return 'common.meter_features.unpack(%s)' % (reader_expr)
-        elif self.base == 'of_list_instruction_t':
+        elif self.base == 'list(of_instruction_t)':
             return 'instruction.unpack_list(%s)' % (reader_expr)
-        elif utils.class_is_list(self.base):
-            element_cls = utils.list_to_entry_type(self.base)[:-2]
+        elif self.base.startswith('list('):
+            element_cls = self.base[5:-3]
             if ((element_cls, self.version) in of_g.is_fixed_length) \
                and not element_cls in loxi_front_end.type_maps.inheritance_map:
-                klass_name = self.base[8:-2]
+                klass_name = self.base[8:-3]
                 element_size, = of_g.base_length[(element_cls, self.version)],
                 return 'loxi.generic_util.unpack_list(%s, common.%s.unpack)' % (reader_expr, klass_name)
             else:
@@ -204,7 +204,7 @@
 class TestOFType(unittest.TestCase):
     def test_init(self):
         from oftype import OFType
-        self.assertEquals("None", OFType("of_list_action_t", 1).gen_init_expr())
+        self.assertEquals("None", OFType("list(of_action_t)", 1).gen_init_expr())
         self.assertEquals("[0,0,0]", OFType("uint32_t[3]", 1).gen_init_expr())
 
     def test_pack(self):
diff --git a/py_gen/templates/_ofclass.py b/py_gen/templates/_ofclass.py
index 8c21bb3..4c5358e 100644
--- a/py_gen/templates/_ofclass.py
+++ b/py_gen/templates/_ofclass.py
@@ -1,5 +1,5 @@
-:: from py_gen.codegen import Member, LengthMember, TypeMember
-:: normal_members = [m for m in ofclass.members if type(m) == Member]
+:: from loxi_ir import *
+:: normal_members = [m for m in ofclass.members if type(m) == OFDataMember]
 class ${ofclass.pyname}(${superclass}):
 :: for m in ofclass.type_members:
     ${m.name} = ${m.value}
diff --git a/py_gen/templates/_pack.py b/py_gen/templates/_pack.py
index 0c208f7..9a481b2 100644
--- a/py_gen/templates/_pack.py
+++ b/py_gen/templates/_pack.py
@@ -26,22 +26,22 @@
 :: # under the EPL.
 ::
 :: # TODO coalesce format strings
-:: from py_gen.codegen import Member, LengthMember, FieldLengthMember, TypeMember, PadMember
+:: from loxi_ir import *
 :: length_member = None
 :: length_member_index = None
 :: field_length_members = {}
 :: field_length_indexes = {}
 :: index = 0
 :: for m in ofclass.members:
-::     if type(m) == LengthMember:
+::     if type(m) == OFLengthMember:
 ::         length_member = m
 ::         length_member_index = index
         packed.append(${m.oftype.gen_pack_expr('0')}) # placeholder for ${m.name} at index ${index}
-::     elif type(m) == FieldLengthMember:
+::     elif type(m) == OFFieldLengthMember:
 ::         field_length_members[m.field_name] = m
 ::         field_length_indexes[m.field_name] = index
         packed.append(${m.oftype.gen_pack_expr('0')}) # placeholder for ${m.name} at index ${index}
-::     elif type(m) == PadMember:
+::     elif type(m) == OFPadMember:
         packed.append('\x00' * ${m.length})
 ::     else:
         packed.append(${m.oftype.gen_pack_expr('self.' + m.name)})
diff --git a/py_gen/templates/_pretty_print.py b/py_gen/templates/_pretty_print.py
index 86cb237..0a3a61c 100644
--- a/py_gen/templates/_pretty_print.py
+++ b/py_gen/templates/_pretty_print.py
@@ -29,8 +29,8 @@
         with q.group():
             with q.indent(2):
                 q.breakable()
-:: from py_gen.codegen import Member, LengthMember, TypeMember
-:: normal_members = [m for m in ofclass.members if type(m) == Member]
+:: from loxi_ir import *
+:: normal_members = [m for m in ofclass.members if type(m) == OFDataMember]
 :: first = True
 :: for m in normal_members:
 :: if not first:
diff --git a/py_gen/templates/_unpack.py b/py_gen/templates/_unpack.py
index 7f3ce2a..211043e 100644
--- a/py_gen/templates/_unpack.py
+++ b/py_gen/templates/_unpack.py
@@ -26,24 +26,24 @@
 :: # under the EPL.
 ::
 :: # TODO coalesce format strings
-:: from py_gen.codegen import Member, LengthMember, FieldLengthMember, TypeMember, PadMember
+:: from loxi_ir import *
         if type(buf) == loxi.generic_util.OFReader:
             reader = buf
         else:
             reader = loxi.generic_util.OFReader(buf)
 :: field_length_members = {}
 :: for m in ofclass.members:
-::     if type(m) == PadMember:
+::     if type(m) == OFPadMember:
         reader.skip(${m.length})
-::     elif type(m) == LengthMember:
+::     elif type(m) == OFLengthMember:
         _${m.name} = ${m.oftype.gen_unpack_expr('reader')}
-::     elif type(m) == FieldLengthMember:
+::     elif type(m) == OFFieldLengthMember:
 ::         field_length_members[m.field_name] = m
         _${m.name} = ${m.oftype.gen_unpack_expr('reader')}
-::     elif type(m) == TypeMember:
+::     elif type(m) == OFTypeMember:
         _${m.name} = ${m.oftype.gen_unpack_expr('reader')}
         assert(_${m.name} == ${m.value})
-::     elif type(m) == Member:
+::     elif type(m) == OFDataMember:
 ::         if m.name in field_length_members:
 ::             reader_expr = 'reader.slice(_%s)' % field_length_members[m.name].name
 ::         else:
diff --git a/py_gen/templates/action.py b/py_gen/templates/action.py
index d8f7c80..dccb46e 100644
--- a/py_gen/templates/action.py
+++ b/py_gen/templates/action.py
@@ -27,6 +27,7 @@
 ::
 :: import itertools
 :: import of_g
+:: import py_gen.util as util
 :: include('_copyright.py')
 
 :: include('_autogen.py')
@@ -76,6 +77,7 @@
 :: sort_key = lambda x: x.type_members[0].value
 :: msgtype_groups = itertools.groupby(sorted(ofclasses, key=sort_key), sort_key)
 :: for (k, v) in msgtype_groups:
+:: k = util.constant_for_value(version, "ofp_action_type", k)
 :: v = list(v)
 :: if len(v) == 1:
     ${k} : ${v[0].pyname}.unpack,
@@ -85,7 +87,7 @@
 :: #endfor
 }
 
-:: experimenter_ofclasses = [x for x in ofclasses if x.type_members[0].value == 'const.OFPAT_VENDOR']
+:: experimenter_ofclasses = [x for x in ofclasses if x.type_members[0].value == 0xffff]
 :: sort_key = lambda x: x.type_members[1].value
 :: experimenter_ofclasses.sort(key=sort_key)
 :: grouped = itertools.groupby(experimenter_ofclasses, sort_key)
diff --git a/py_gen/templates/instruction.py b/py_gen/templates/instruction.py
index bfa0628..88b0f89 100644
--- a/py_gen/templates/instruction.py
+++ b/py_gen/templates/instruction.py
@@ -27,6 +27,7 @@
 ::
 :: import itertools
 :: import of_g
+:: import py_gen.util as util
 :: include('_copyright.py')
 
 :: include('_autogen.py')
@@ -58,6 +59,7 @@
 :: sort_key = lambda x: x.type_members[0].value
 :: msgtype_groups = itertools.groupby(sorted(ofclasses, key=sort_key), sort_key)
 :: for (k, v) in msgtype_groups:
+:: k = util.constant_for_value(version, "ofp_instruction_type", k)
 :: v = list(v)
 :: if len(v) == 1:
     ${k} : ${v[0].pyname}.unpack,
diff --git a/py_gen/templates/message.py b/py_gen/templates/message.py
index 8e2f861..ffad6cf 100644
--- a/py_gen/templates/message.py
+++ b/py_gen/templates/message.py
@@ -27,6 +27,7 @@
 ::
 :: import itertools
 :: import of_g
+:: import py_gen.util as util
 :: include('_copyright.py')
 
 :: include('_autogen.py')
@@ -51,9 +52,9 @@
     xid = None
 
 :: for ofclass in ofclasses:
-:: from py_gen.codegen import Member, LengthMember, TypeMember
-:: normal_members = [m for m in ofclass.members if type(m) == Member]
-:: type_members = [m for m in ofclass.members if type(m) == TypeMember]
+:: from loxi_ir import *
+:: normal_members = [m for m in ofclass.members if type(m) == OFDataMember]
+:: type_members = [m for m in ofclass.members if type(m) == OFTypeMember]
 class ${ofclass.pyname}(Message):
 :: for m in type_members:
     ${m.name} = ${m.value}
@@ -193,6 +194,7 @@
 :: sort_key = lambda x: x.type_members[1].value
 :: msgtype_groups = itertools.groupby(sorted(ofclasses, key=sort_key), sort_key)
 :: for (k, v) in msgtype_groups:
+:: k = util.constant_for_value(version, "ofp_type", k)
 :: v = list(v)
 :: if len(v) == 1:
     ${k} : ${v[0].pyname}.unpack,
@@ -256,7 +258,7 @@
 # TODO OF 1.3 multipart messages
 :: #endif
 
-:: experimenter_ofclasses = [x for x in ofclasses if x.type_members[1].value == 'const.OFPT_VENDOR']
+:: experimenter_ofclasses = [x for x in ofclasses if x.type_members[1].value == 4]
 :: sort_key = lambda x: x.type_members[2].value
 :: experimenter_ofclasses.sort(key=sort_key)
 :: grouped = itertools.groupby(experimenter_ofclasses, sort_key)
diff --git a/py_gen/templates/meter_band.py b/py_gen/templates/meter_band.py
index ca111d5..eeb9ff2 100644
--- a/py_gen/templates/meter_band.py
+++ b/py_gen/templates/meter_band.py
@@ -27,6 +27,7 @@
 ::
 :: import itertools
 :: import of_g
+:: import py_gen.util as util
 :: include('_copyright.py')
 
 :: include('_autogen.py')
@@ -57,6 +58,7 @@
 :: sort_key = lambda x: x.type_members[0].value
 :: msgtype_groups = itertools.groupby(sorted(ofclasses, key=sort_key), sort_key)
 :: for (k, v) in msgtype_groups:
+:: k = util.constant_for_value(version, "ofp_meter_band_type", k)
 :: v = list(v)
 :: if len(v) == 1:
     ${k} : ${v[0].pyname}.unpack,
diff --git a/py_gen/templates/oxm.py b/py_gen/templates/oxm.py
index e11a0a4..2a10a5f 100644
--- a/py_gen/templates/oxm.py
+++ b/py_gen/templates/oxm.py
@@ -52,9 +52,9 @@
     pass
 
 :: for ofclass in ofclasses:
-:: from py_gen.codegen import Member, LengthMember, TypeMember
-:: normal_members = [m for m in ofclass.members if type(m) == Member]
-:: type_members = [m for m in ofclass.members if type(m) == TypeMember]
+:: from loxi_ir import *
+:: normal_members = [m for m in ofclass.members if type(m) == OFDataMember]
+:: type_members = [m for m in ofclass.members if type(m) == OFTypeMember]
 class ${ofclass.pyname}(OXM):
 :: for m in type_members:
     ${m.name} = ${m.value}
@@ -99,7 +99,7 @@
 :: #endfor
 
 parsers = {
-:: key = lambda x: int(x.type_members[0].value, 16)
+:: key = lambda x: x.type_members[0].value
 :: for ofclass in sorted(ofclasses, key=key):
     ${key(ofclass)} : ${ofclass.pyname}.unpack,
 :: #endfor