diff --git a/Makefile b/Makefile
index 02e144d..1016c2d 100644
--- a/Makefile
+++ b/Makefile
@@ -31,8 +31,6 @@
 DOCKER_TAG                 ?= ${VERSION}$(shell [[ ${DOCKER_LABEL_VCS_DIRTY} == "true" ]] && echo "-dirty" || true)
 RWCORE_IMAGENAME           := ${DOCKER_REGISTRY}${DOCKER_REPOSITORY}voltha-rw-core
 ROCORE_IMAGENAME           := ${DOCKER_REGISTRY}${DOCKER_REPOSITORY}voltha-ro-core
-OFAGENT_IMAGENAME          := ${DOCKER_REGISTRY}${DOCKER_REPOSITORY}voltha-ofagent
-CLI_IMAGENAME              := ${DOCKER_REGISTRY}${DOCKER_REPOSITORY}voltha-cli
 
 ## Docker labels. Only set ref and commit date if committed
 DOCKER_LABEL_VCS_URL       ?= $(shell git remote get-url $(shell git remote))
@@ -57,10 +55,9 @@
 	--build-arg org_opencord_vcs_dirty="${DOCKER_LABEL_VCS_DIRTY}"
 
 DOCKER_BUILD_ARGS_LOCAL ?= ${DOCKER_BUILD_ARGS} \
-	--build-arg LOCAL_PYVOLTHA=${LOCAL_PYVOLTHA} \
 	--build-arg LOCAL_PROTOS=${LOCAL_PROTOS}
 
-.PHONY: rw_core ro_core local-protos local-pyvoltha
+.PHONY: rw_core ro_core local-protos
 
 # This should to be the first and default target in this Makefile
 help:
@@ -71,11 +68,8 @@
 	@echo "                         - If this is the first time you are building, choose 'make build' option."
 	@echo "rw_core              : Build the rw_core docker image"
 	@echo "ro_core              : Build the ro_core docker image"
-	@echo "ofagent              : Build the openflow agent docker image"
-	@echo "cli                  : Build the voltha CLI docker image"
-	@echo "venv                 : Build local Python virtualenv"
 	@echo "clean                : Remove files created by the build and tests"
-	@echo "distclean            : Remove venv directory"
+	@echo "distclean            : Remove sca directory and clean"
 	@echo "docker-push          : Push the docker images to an external repository"
 	@echo "lint-dockerfile      : Perform static analysis on Dockerfiles"
 	@echo "lint-style           : Verify code is properly gofmt-ed"
@@ -88,13 +82,9 @@
 
 ## Local Development Helpers
 local-protos:
-	@mkdir -p python/local_imports
 ifdef LOCAL_PROTOS
 	mkdir -p vendor/github.com/opencord/voltha-protos/v2/go
 	cp -r ${LOCAL_PROTOS}/go/* vendor/github.com/opencord/voltha-protos/v2/go
-	rm -rf python/local_imports/voltha-protos
-	mkdir -p python/local_imports/voltha-protos/dist
-	cp ${LOCAL_PROTOS}/dist/*.tar.gz python/local_imports/voltha-protos/dist/
 endif
 
 ## Local Development Helpers
@@ -104,37 +94,11 @@
 	cp -r ${LOCAL_LIB_GO}/pkg/* vendor/github.com/opencord/voltha-lib-go/v2/pkg/
 endif
 
-local-pyvoltha:
-	@mkdir -p python/local_imports
-ifdef LOCAL_PYVOLTHA
-	rm -rf python/local_imports/pyvoltha
-	mkdir -p python/local_imports/pyvoltha/dist
-	cp ${LOCAL_PYVOLTHA}/dist/*.tar.gz python/local_imports/pyvoltha/dist/
-endif
-
-## Python venv dev environment
-
-VENVDIR := python/venv-volthago
-
-venv: distclean local-protos local-pyvoltha
-	virtualenv ${VENVDIR};\
-	source ./${VENVDIR}/bin/activate ; set -u ;\
-	rm -f ${VENVDIR}/local/bin ${VENVDIR}/local/lib ${VENVDIR}/local/include ;\
-	pip install -r python/requirements.txt
-ifdef LOCAL_PYVOLTHA
-	source ./${VENVDIR}/bin/activate ; set -u ;\
-	pip install python/local_imports/pyvoltha/dist/*.tar.gz
-endif
-ifdef LOCAL_PROTOS
-	source ./${VENVDIR}/bin/activate ; set -u ;\
-	pip install python/local_imports/voltha-protos/dist/*.tar.gz
-endif
-
 ## Docker targets
 
 build: docker-build
 
-docker-build: rw_core ro_core ofagent cli
+docker-build: rw_core ro_core
 
 rw_core: local-protos local-lib-go
 	docker build $(DOCKER_BUILD_ARGS) -t ${RWCORE_IMAGENAME}:${DOCKER_TAG} -t ${RWCORE_IMAGENAME}:latest -f docker/Dockerfile.rw_core .
@@ -142,17 +106,9 @@
 ro_core: local-protos local-lib-go
 	docker build $(DOCKER_BUILD_ARGS) -t ${ROCORE_IMAGENAME}:${DOCKER_TAG} -t ${ROCORE_IMAGENAME}:latest -f docker/Dockerfile.ro_core .
 
-ofagent: local-protos local-pyvoltha
-	docker build $(DOCKER_BUILD_ARGS_LOCAL) -t ${OFAGENT_IMAGENAME}:${DOCKER_TAG} -t ${OFAGENT_IMAGENAME}:latest -f python/docker/Dockerfile.ofagent python
-
-cli: local-protos local-pyvoltha
-	docker build $(DOCKER_BUILD_ARGS_LOCAL) -t ${CLI_IMAGENAME}:${DOCKER_TAG} -t ${CLI_IMAGENAME}:latest -f python/docker/Dockerfile.cli python
-
 docker-push:
 	docker push ${RWCORE_IMAGENAME}:${DOCKER_TAG}
 	docker push ${ROCORE_IMAGENAME}:${DOCKER_TAG}
-	docker push ${OFAGENT_IMAGENAME}:${DOCKER_TAG}
-	docker push ${CLI_IMAGENAME}:${DOCKER_TAG}
 
 ## lint and unit tests
 
@@ -238,7 +194,7 @@
 sca: golangci_lint_tool_install
 	rm -rf ./sca-report
 	@mkdir -p ./sca-report
-	$(GOLANGCI_LINT_TOOL) run -E golint -D structcheck --out-format junit-xml ./cli/... ./rw_core/... ./ro_core/... ./tests/... ./common/... 2>&1 | tee ./sca-report/sca-report.xml
+	$(GOLANGCI_LINT_TOOL) run -E golint -D structcheck --out-format junit-xml ./rw_core/... ./ro_core/... ./tests/... ./common/... 2>&1 | tee ./sca-report/sca-report.xml
 
 test: go_junit_install gocover_cobertura_install local-lib-go
 	@mkdir -p ./tests/results
@@ -249,11 +205,9 @@
 	exit $$RETURN
 
 clean:
-	rm -rf python/local_imports
-	find python -name '*.pyc' | xargs rm -f
 
 distclean: clean
-	rm -rf ${VENVDIR} ./sca_report
+	rm -rf ./sca_report
 
 mod-update:
 	go mod tidy
diff --git a/python/__init__.py b/python/__init__.py
deleted file mode 100644
index cfcdc97..0000000
--- a/python/__init__.py
+++ /dev/null
@@ -1,15 +0,0 @@
-#
-# Copyright 2017 the original author or authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
\ No newline at end of file
diff --git a/python/adapters/BUILD_ENV.md b/python/adapters/BUILD_ENV.md
deleted file mode 100644
index e445141..0000000
--- a/python/adapters/BUILD_ENV.md
+++ /dev/null
@@ -1,53 +0,0 @@
-
-Build Environment for Ubuntu
-============================
-
-1. The following commands were executed on a Ubuntu 16.04 (b4 bits) VM with following configuation (OpenStack Flavor: m1.medium):
-	- vCPUs - 2
-	- RAM - 4 GB
-	- HDD - 40 GB
-	- Network - Floating IP attached to Internal IP NIC. Internet access available
-
-
-2. login as root as docker command needs root access. When logged-in as root 'sudo' becomes optional in each command below
-
-git clone https://gerrit.opencord.org/voltha-go
-sudo apt-get install make
-sudo apt-get install python
-sudo apt-get install virtualenv
-sudo apt-get install gcc
-sudo apt-get install python-dev
-sudo apt-get install g++
-sudo apt-get install libpcap-dev
-sudo apt-get install apt-utils
-sudo apt-get install docker-compose
-
-
-3. Install docker CE for Ubuntu as mentioned in this link: https://docs.docker.com/install/linux/docker-ce/ubuntu/#set-up-the-repository. These are commands executed to install docker
-
-sudo apt-get update
-
-sudo apt-get install \
-    apt-transport-https \
-    ca-certificates \
-    curl \
-    software-properties-common
-
-curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
-
-sudo apt-key fingerprint 0EBFCD88
-
-sudo add-apt-repository \
-   "deb [arch=amd64] https://download.docker.com/linux/ubuntu \
-   $(lsb_release -cs) \
-   stable"
-
-sudo apt-get update
-
-sudo apt-get install docker-ce
-
-
-4. Verify that Docker CE is installed correctly by running the hello-world image. The following command downloads a test image and runs it in a container. When the container runs, it prints an informational message and exits.
-
-sudo docker run hello-world
-
diff --git a/python/adapters/README.md b/python/adapters/README.md
deleted file mode 100644
index 49e4a7e..0000000
--- a/python/adapters/README.md
+++ /dev/null
@@ -1,116 +0,0 @@
-# How to Build and Run a Voltha Adapter
-
-The build and development environment of a Voltha Adapter is left to the developer's choice.  The 
-environment used below is the macOS. 
-
-# Create fresh build setup
-When creating a fresh build setup various packages, applications and libraries are required to Build successfully.
-Please refer BUILD_ENV.md for details to create fresh setup on your choice of OS.
-This file will increment as new setups are created on difference OSes.
-
-### Build
-
-To build the adapters (so far Ponsim OLT and Ponsim ONU adapters) and dependent containers follow 
-the commands below. The base directory is voltha-go. 
-
-```
-cd python
-source env.sh
-VOLTHA_BUILD=docker make build
-```
-
-The above build command generates a few docker images. An example is below:
-
-```
-$ docker images
-REPOSITORY                  TAG                                        IMAGE ID            CREATED             SIZE
-voltha-adapter-ponsim-onu   latest                                     3638b16b5262        36 seconds ago      774MB
-voltha-adapter-ponsim-olt   latest                                     9e98a3a8e1aa        58 seconds ago      775MB
-voltha-base                 latest                                     40ed93942a6a        23 minutes ago      771MB
-voltha-protos               latest                                     d458a391cc81        12 days ago         2.66MB
-voltha-protoc               latest                                     a67dda73f695        2 months ago        1.41GB
-```
-
-Now build the Voltha Core from the voltha-go directory
-```
-make rw_core
-```
-
-Now build the Voltha CLI image from the voltha-go/python directory (used below for provisioning)
-```
-make cli
-```
-
-This will create the following images:
-```
-REPOSITORY                   TAG                                        IMAGE ID            CREATED             SIZE
-voltha-rw-core               latest                                     eab4b288adea        47 seconds ago      36.8MB
-voltha-cli                   latest                                     a0a4b8f25373        About an hour ago   827MB
-```
-
-### Run the Adapters locally (development environment)
-
-We will use Ponsim as the example.  Ponsim has two containers, one being the Ponsim OLT Adapter and 
-the other one the Ponsim ONU Adapter. We will use the docker-compose command to run these containers locally 
-as it is straight forward.
-
-#### Setup
-Since an adapter communicates with the Voltha Core via the Kafka bus and uses the Etcd KV store then we 
-need to have these containers running as well.   There is no dependency in the order in which they need to 
-start as an adapter must be able to handle this scenario. 
- 
-First run the dependent containers from the voltha-go directory. In the commands below, replace the IP 
-with the IP of the host.
-```
-DOCKER_HOST_IP=<Host IP> docker-compose -f compose/docker-compose-zk-kafka-test.yml up -d
-DOCKER_HOST_IP=<Host IP> docker-compose -f compose/docker-compose-etcd.yml up -d
-DOCKER_HOST_IP=<Host IP> docker-compose -f compose/rw_core.yml up -d
-DOCKER_HOST_IP=<Host IP> docker-compose -f compose/cli.yml up -d
-```
-#### Running the Ponsim Adapters
-
-Start the Ponsim OLT and ONU adapters
-```
-DOCKER_HOST_IP=<Host IP> docker-compose -f compose/adapters-ponsim.yml up -d
-```
-
-Start also the Ponsim OLT and ONU containers.  We are using only PonsimV2. You may want to change the 
-image names from the yml files below if you are pulling the Ponsim OLT and ONU images from somewhere else.
-
-```
-docker-compose -f compose/ponsim_olt.yml up -d
-docker-compose -f compose/ponsim_onu.yml up -d
-```
-
-#### Provisioning a device
-
-First get the IP address of the Ponsim OLT container by using the docker inspect command.
-
-Now, start the CLI. Password for 'voltha' user is 'admin'. Please see Dockerfile.cli for passwords
-
-```shell
-ssh -p 5022 voltha@localhost
-```
-
-Perform the provisioning
-
-```shell
-preprovision_olt -t ponsim_olt -H <IP of Ponsim OLT>:50060
-enable <deviceId>  // Use the device ID returned in the previous command
-```
-
-At this point you can send flows to the devices using the test option in the CLI. 
-```shell
-test
-install_eapol_flow <logical_device_id>
-install_dhcp_flows  <logical_device_id>
-install_all_controller_bound_flows <logical_device_id>
-install_all_sample_flows <logical_device_id>
-```
-
-You can also see the metrics the Ponsim OLT and ONU adapters are pushing onto the kafka bus.
-
-```shell
-kafkacat -b <host IP>:9092 -t voltha.kpis -p 0  -o beginning
-```
-
diff --git a/python/adapters/__init__.py b/python/adapters/__init__.py
deleted file mode 100644
index 58aca1e..0000000
--- a/python/adapters/__init__.py
+++ /dev/null
@@ -1,13 +0,0 @@
-# Copyright 2018 the original author or authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
diff --git a/python/cli/__init__.py b/python/cli/__init__.py
deleted file mode 100644
index b0fb0b2..0000000
--- a/python/cli/__init__.py
+++ /dev/null
@@ -1,13 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
diff --git a/python/cli/alarm_filters.py b/python/cli/alarm_filters.py
deleted file mode 100644
index 57a782f..0000000
--- a/python/cli/alarm_filters.py
+++ /dev/null
@@ -1,236 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright 2017 the original author or authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-"""
-Alarm filter CLI commands
-"""
-from optparse import make_option, OptionValueError
-
-from cmd2 import Cmd, options
-from google.protobuf.empty_pb2 import Empty
-
-from table import print_pb_list_as_table
-from voltha_protos import voltha_pb2
-from voltha_protos.events_pb2 import AlarmEventType, AlarmEventSeverity, AlarmEventCategory
-
-
-
-class AlarmFiltersCli(Cmd):
-    def __init__(self, get_stub):
-        Cmd.__init__(self)
-        self.get_stub = get_stub
-        self.prompt = '(' + self.colorize(
-            self.colorize('alarm_filters', 'red'), 'bold') + ') '
-
-    def cmdloop(self):
-        self._cmdloop()
-
-    def help_show(self):
-        self.poutput(
-'''
-Display the list of configured filters.
-
-Valid options:
-
--i FILTER_ID | --filter-id=FILTER_ID                Display the filter rules for a specific filter id (OPTIONAL)
-
-'''
-        )
-
-    @options([
-        make_option('-i', '--filter-id', action="store", dest='filter_id')
-    ])
-    def do_show(self, line, opts):
-        stub = self.get_stub()
-
-        if not opts.filter_id:
-            result = stub.ListAlarmFilters(Empty())
-            print_pb_list_as_table("Alarm Filters:", result.filters, {}, self.poutput)
-        else:
-            result = stub.GetAlarmFilter(voltha_pb2.ID(id=opts.filter_id))
-            print_pb_list_as_table("Rules for Filter ID = {}:".format(opts.filter_id),
-                                   result.rules, {}, self.poutput)
-
-    @staticmethod
-    def construct_rule(raw_rule):
-        rule = dict()
-
-        rule_kv = raw_rule.strip().split(':')
-
-        if len(rule_kv) == 2:
-            rule['key'] = rule_kv[0].lower()
-            rule['value'] = rule_kv[1].lower()
-        else:
-            raise OptionValueError("Error: A rule must be a colon separated key/value pair")
-
-        return rule
-
-    def parse_filter_rules(option, opt_str, value, parser):
-        rules = getattr(parser.values, option.dest)
-        if rules is None:
-            rules = list()
-            rules.append(AlarmFiltersCli.construct_rule(value))
-
-            for arg in parser.rargs:
-                if (arg[:2] == "--" and len(arg) > 2) or (arg[:1] == "-" and len(arg) > 1 and arg[1] != "-"):
-                    break
-                else:
-                    rules.append(AlarmFiltersCli.construct_rule(arg))
-
-            setattr(parser.values, option.dest, rules)
-        else:
-            raise OptionValueError('Warning: The filter rule option can only be specified once')
-
-    def help_create(self):
-        types = list(
-            k for k, v in
-            AlarmEventType.DESCRIPTOR.enum_values_by_name.items())
-        categories = list(
-            k for k, v in
-            AlarmEventCategory.DESCRIPTOR.enum_values_by_name.items())
-        severities = list(
-            k for k, v in
-            AlarmEventSeverity.DESCRIPTOR.enum_values_by_name.items())
-
-        alarm_types = types
-        alarm_categories = categories
-        alarm_severities = severities
-
-        usage = '''
-Create a new alarm filter.
-
-Valid options:
-
--r rule:value ... | --filter-rules rule:value ...   Specify one or more filter rules as key/value pairs (REQUIRED)
-
-Valid rule keys and expected values:
-
-id          : Identifier of an incoming alarm
-type        : Type of an incoming alarm {}
-category    : Category of an incoming alarm {}
-severity    : Severity of an incoming alarm {}
-resource_id : Resource identifier of an incoming alarm
-device_id   : Device identifier of an incoming alarm
-
-Example:
-
-# Filter any alarm that matches the following criteria
-
-create -r type:environment severity:indeterminate
-create -r device_id:754f9dcbe4a6
-
-'''.format(alarm_types, alarm_categories, alarm_severities)
-
-        self.poutput(usage)
-
-    @options([
-        make_option('-r', '--filter-rules', help='<key>:<value>...', action="callback",
-                    callback=parse_filter_rules, type='string', dest='filter_rules'),
-    ])
-    def do_create(self, line, opts):
-        if opts.filter_rules:
-            stub = self.get_stub()
-            result = stub.CreateAlarmFilter(voltha_pb2.AlarmFilter(rules=opts.filter_rules))
-            print_pb_list_as_table("Rules for Filter ID = {}:".format(result.id),
-                                   result.rules, {}, self.poutput)
-
-    def help_delete(self):
-        self.poutput(
-'''
-Delete a specific alarm filter entry.
-
-Valid options:
-
--i FILTER_ID | --filter-id=FILTER_ID                Display the filter rules for a specific filter id (REQUIRED)
-
-'''
-        )
-
-    @options([
-        make_option('-i', '--filter-id', action="store", dest='filter_id')
-    ])
-    def do_delete(self, line, opts):
-        if not opts.filter_id:
-            self.poutput(self.colorize('Error: ', 'red') + 'Specify ' + \
-                         self.colorize(self.colorize('"filter id"', 'blue'),
-                                       'bold') + ' to update')
-            return
-
-        stub = self.get_stub()
-        stub.DeleteAlarmFilter(voltha_pb2.ID(id=opts.filter_id))
-
-    def help_update(self):
-        types = list(
-            k for k, v in
-            AlarmEventType.DESCRIPTOR.enum_values_by_name.items())
-        categories = list(
-            k for k, v in
-            AlarmEventCategory.DESCRIPTOR.enum_values_by_name.items())
-        severities = list(
-            k for k, v in
-            AlarmEventSeverity.DESCRIPTOR.enum_values_by_name.items())
-
-        alarm_types = types
-        alarm_categories = categories
-        alarm_severities = severities
-
-        usage = '''
-Update the filter rules for an existing alarm filter.
-
-Valid options:
-
--i FILTER_ID | --filter-id=FILTER_ID                Indicate the alarm filter identifier to update (REQUIRED)
--r rule:value ... | --filter-rules rule:value ...   Specify one or more filter rules as key/value pairs (REQUIRED)
-
-Valid rule keys and expected values:
-
-id          : Identifier of an incoming alarm
-type        : Type of an incoming alarm {}
-category    : Category of an incoming alarm {}
-severity    : Severity of an incoming alarm {}
-resource_id : Resource identifier of an incoming alarm
-device_id   : Device identifier of an incoming alarm
-
-Example:
-
-# Filter any alarm that matches the following criteria
-
-update -i 9da115b900bc -r type:environment severity:indeterminate resource_id:1554b0517a07
-
-'''.format(alarm_types, alarm_categories, alarm_severities)
-
-        self.poutput(usage)
-
-    @options([
-        make_option('-r', '--filter-rules', help='<key>:<value>...', action="callback",
-                    callback=parse_filter_rules, type='string', dest='filter_rules'),
-        make_option('-i', '--filter-id', action="store", dest='filter_id')
-    ])
-    def do_update(self, line, opts):
-        if not opts.filter_id:
-            self.poutput(self.colorize('Error: ', 'red') + 'Specify ' + \
-                         self.colorize(self.colorize('"filter id"', 'blue'),
-                                       'bold') + ' to update')
-            return
-
-        if opts.filter_rules:
-            stub = self.get_stub()
-            result = stub.UpdateAlarmFilter(
-                voltha_pb2.AlarmFilter(id=opts.filter_id, rules=opts.filter_rules)
-            )
-            print_pb_list_as_table("Rules for Filter ID = {}:".format(result.id),
-                                   result.rules, {}, self.poutput)
diff --git a/python/cli/device.py b/python/cli/device.py
deleted file mode 100755
index 25ad72b..0000000
--- a/python/cli/device.py
+++ /dev/null
@@ -1,705 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright 2016 the original author or authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-"""
-Device level CLI commands
-"""
-from optparse import make_option
-from cmd2 import Cmd, options
-from simplejson import dumps
-
-from table import print_pb_as_table, print_pb_list_as_table
-from utils import print_flows, pb2dict, enum2name
-
-from voltha_protos import voltha_pb2, common_pb2
-import sys
-import json
-from google.protobuf.json_format import MessageToDict
-
-# Since proto3 won't send fields that are set to 0/false/"" any object that
-# might have those values set in them needs to be replicated here such that the
-# fields can be adequately
-
-
-class DeviceCli(Cmd):
-
-    def __init__(self, device_id, get_stub):
-        Cmd.__init__(self)
-        self.get_stub = get_stub
-        self.device_id = device_id
-        self.prompt = '(' + self.colorize(
-            self.colorize('device {}'.format(device_id), 'red'), 'bold') + ') '
-        self.pm_config_last = None
-        self.pm_config_dirty = False
-
-    def cmdloop(self):
-        self._cmdloop()
-
-    def get_device(self, depth=0):
-        stub = self.get_stub()
-        res = stub.GetDevice(voltha_pb2.ID(id=self.device_id),
-                             metadata=(('get-depth', str(depth)), ))
-        return res
-
-    do_exit = Cmd.do_quit
-
-    def do_quit(self, line):
-        if self.pm_config_dirty:
-            self.poutput("Uncommited changes for " + \
-                         self.colorize(
-                             self.colorize("perf_config,", "blue"),
-                             "bold") + " please either " + self.colorize(
-                             self.colorize("commit", "blue"), "bold") + \
-                         " or " + self.colorize(
-                             self.colorize("reset", "blue"), "bold") + \
-                         " your changes using " + \
-                         self.colorize(
-                             self.colorize("perf_config", "blue"), "bold"))
-            return False
-        else:
-            return self._STOP_AND_EXIT
-
-    def do_show(self, line):
-        """Show detailed device information"""
-        print_pb_as_table('Device {}'.format(self.device_id),
-                          self.get_device(depth=-1))
-
-    def do_ports(self, line):
-        """Show ports of device"""
-        device = self.get_device(depth=-1)
-        omit_fields = {
-        }
-        print_pb_list_as_table('Device ports:', device.ports,
-                               omit_fields, self.poutput)
-
-    def complete_perf_config(self, text, line, begidx, endidx):
-        sub_cmds = {"show", "set", "commit", "reset"}
-        sub_opts = {"-f", "-e", "-d", "-o"}
-        # Help the interpreter complete the paramters.
-        completions = []
-        if not self.pm_config_last:
-            device = self.get_device(depth=-1)
-            self.pm_config_last = device.pm_configs
-        m_names = [d.name for d in self.pm_config_last.metrics]
-        cur_cmd = line.strip().split(" ")
-        try:
-            if not text and len(cur_cmd) == 1:
-                completions = ("show", "set", "commit", "reset")
-            elif len(cur_cmd) == 2:
-                if "set" == cur_cmd[1]:
-                    completions = [d for d in sub_opts]
-                else:
-                    completions = [d for d in sub_cmds if d.startswith(text)]
-            elif len(cur_cmd) > 2 and cur_cmd[1] == "set":
-                if cur_cmd[len(cur_cmd)-1] == "-":
-                    completions = [list(d)[1] for d in sub_opts]
-                elif cur_cmd[len(cur_cmd)-1] == "-f":
-                    completions = ("\255","Please enter a sampling frequency in 10ths of a second")
-                elif cur_cmd[len(cur_cmd)-2] == "-f":
-                    completions = [d for d in sub_opts]
-                elif cur_cmd[len(cur_cmd)-1] in {"-e","-d","-o"}:
-                    if self.pm_config_last.grouped:
-                        pass
-                    else:
-                        completions = [d.name for d in self.pm_config_last.metrics]
-                elif cur_cmd[len(cur_cmd)-2] in {"-e","-d"}:
-                    if text and text not in m_names:
-                        completions = [d for d in m_names if d.startswith(text)]
-                    else:
-                        completions = [d for d in sub_opts]
-                elif cur_cmd[len(cur_cmd)-2] == "-o":
-                    if cur_cmd[len(cur_cmd)-1] in [d.name for d in self.pm_config_last.metrics]:
-                        completions = ("\255","Please enter a sampling frequency in 10ths of a second")
-                    else:
-                        completions = [d for d in m_names if d.startswith(text)]
-                elif cur_cmd[len(cur_cmd)-3] == "-o":
-                    completions = [d for d in sub_opts]
-        except:
-            e = sys.exc_info()
-            print(e)
-        return completions
-
-
-    def help_perf_config(self):
-        self.poutput(
-'''
-perf_config [show | set | commit | reset] [-f <default frequency>] [{-e <metric/group
-            name>}] [{-d <metric/group name>}] [{-o <metric/group name> <override
-            frequency>}]
-
-show: displays the performance configuration of the device
-set: changes the parameters specified with -e, -d, and -o
-reset: reverts any changes made since the last commit
-commit: commits any changes made which applies them to the device.
-
--e: enable collection of the specified metric, more than one -e may be
-            specified.
--d: disable collection of the specified metric, more than on -d may be
-            specified.
--o: override the collection frequency of the specified metric, more than one -o
-            may be specified. Note that -o isn't valid unless
-            frequency_override is set to True for the device.
-
-Changes made by set are held locally until a commit or reset command is issued.
-A commit command will write the configuration to the device and it takes effect
-immediately. The reset command will undo any changes since the start of the
-device session.
-
-If grouped is true then the -d, -e and -o commands refer to groups and not
-individual metrics.
-'''
-        )
-
-    @options([
-        make_option('-f', '--default_freq', action="store", dest='default_freq',
-                    type='long', default=None),
-        make_option('-e', '--enable', action='append', dest='enable',
-                    default=None),
-        make_option('-d', '--disable', action='append', dest='disable',
-                    default=None),
-        make_option('-o', '--override', action='append', dest='override',
-                    nargs=2, default=None, type='string'),
-    ])
-    def do_perf_config(self, line, opts):
-        """Show and set the performance monitoring configuration of the device"""
-
-        device = self.get_device(depth=-1)
-        if not self.pm_config_last:
-            self.pm_config_last = device.pm_configs
-
-        # Ensure that a valid sub-command was provided
-        if line.strip() not in {"set", "show", "commit", "reset", ""}:
-                self.poutput(self.colorize('Error: ', 'red') +
-                             self.colorize(self.colorize(line.strip(), 'blue'),
-                                           'bold') + ' is not recognized')
-                return
-
-        # Ensure no options are provided when requesting to view the config
-        if line.strip() == "show" or line.strip() == "":
-            if opts.default_freq or opts.enable or opts.disable:
-                self.poutput(opts.disable)
-                self.poutput(self.colorize('Error: ', 'red') + 'use ' +
-                             self.colorize(self.colorize('"set"', 'blue'),
-                                           'bold') + ' to change settings')
-                return
-
-        if line.strip() == "set":  # Set the supplied values
-            metric_list = set()
-            if opts.enable is not None:
-                metric_list |= {metric for metric in opts.enable}
-            if opts.disable is not None:
-                metric_list |= {metric for metric in opts.disable}
-            if opts.override is not None:
-                metric_list |= {metric for metric, _ in opts.override}
-
-            # The default frequency
-            if opts.default_freq:
-                self.pm_config_last.default_freq = opts.default_freq
-                self.pm_config_dirty = True
-
-            # Field or group visibility
-            if self.pm_config_last.grouped:
-                for g in self.pm_config_last.groups:
-                    if opts.enable:
-                        if g.group_name in opts.enable:
-                            g.enabled = True
-                            self.pm_config_dirty = True
-                            metric_list.discard(g.group_name)
-                for g in self.pm_config_last.groups:
-                    if opts.disable:
-                        if g.group_name in opts.disable:
-                            g.enabled = False
-                            self.pm_config_dirty = True
-                            metric_list.discard(g.group_name)
-            else:
-                for m in self.pm_config_last.metrics:
-                    if opts.enable:
-                        if m.name in opts.enable:
-                            m.enabled = True
-                            self.pm_config_dirty = True
-                            metric_list.discard(m.name)
-                for m in self.pm_config_last.metrics:
-                    if opts.disable:
-                        if m.name in opts.disable:
-                            m.enabled = False
-                            self.pm_config_dirty = True
-                            metric_list.discard(m.name)
-
-            # Frequency overrides.
-            if opts.override:
-                if self.pm_config_last.freq_override:
-                    oo = dict()
-                    for o in opts.override:
-                        oo[o[0]] = o[1]
-                    if self.pm_config_last.grouped:
-                        for g in self.pm_config_last.groups:
-                            if g.group_name in oo:
-                                try:
-                                    g.group_freq = int(oo[g.group_name])
-                                except ValueError:
-                                    self.poutput(self.colorize('Warning: ',
-                                                               'yellow') +
-                                                 self.colorize(oo[g.group_name],
-                                                               'blue') +
-                                                 " is not an integer... ignored")
-                                del oo[g.group_name]
-                                self.pm_config_dirty = True
-                                metric_list.discard(g.group_name)
-                    else:
-                        for m in self.pm_config_last.metrics:
-                            if m.name in oo:
-                                try:
-                                    m.sample_freq = int(oo[m.name])
-                                except ValueError:
-                                    self.poutput(self.colorize('Warning: ',
-                                                               'yellow') +
-                                                 self.colorize(oo[m.name],
-                                                               'blue') +
-                                                 " is not an integer... ignored")
-                                del oo[m.name]
-                                self.pm_config_dirty = True
-                                metric_list.discard(m.name)
-
-                    # If there's anything left the input was typoed
-                    if self.pm_config_last.grouped:
-                        field = 'group'
-                    else:
-                        field = 'metric'
-                    for o in oo:
-                        self.poutput(self.colorize('Warning: ', 'yellow') +
-                                     'the parameter' + ' ' +
-                                     self.colorize(o, 'blue') + ' is not ' +
-                                     'a ' + field + ' name... ignored')
-                    if oo:
-                        return
-
-                else:  # Frequency overrides not enabled
-                    self.poutput(self.colorize('Error: ', 'red') +
-                                 'Individual overrides are only ' +
-                                 'supported if ' +
-                                 self.colorize('freq_override', 'blue') +
-                                 ' is set to ' + self.colorize('True', 'blue'))
-                    return
-
-            if len(metric_list):
-                metric_name_list = ", ".join(str(metric) for metric in metric_list)
-                self.poutput(self.colorize('Error: ', 'red') +
-                             'Metric/Metric Group{} '.format('s' if len(metric_list) > 1 else '') +
-                             self.colorize(metric_name_list, 'blue') +
-                             ' {} not found'.format('were' if len(metric_list) > 1 else 'was'))
-                return
-
-            self.poutput("Success")
-            return
-
-        elif line.strip() == "commit" and self.pm_config_dirty:
-            stub = self.get_stub()
-            stub.UpdateDevicePmConfigs(self.pm_config_last)
-            self.pm_config_last = self.get_device(depth=-1).pm_configs
-            self.pm_config_dirty = False
-
-        elif line.strip() == "reset" and self.pm_config_dirty:
-            self.pm_config_last = self.get_device(depth=-1).pm_configs
-            self.pm_config_dirty = False
-
-        omit_fields = {'groups', 'metrics', 'id'}
-        print_pb_as_table('PM Config:', self.pm_config_last, omit_fields,
-                          self.poutput,show_nulls=True)
-        if self.pm_config_last.grouped:
-            #self.poutput("Supported metric groups:")
-            for g in self.pm_config_last.groups:
-                if self.pm_config_last.freq_override:
-                    omit_fields = {'metrics'}
-                else:
-                    omit_fields = {'group_freq','metrics'}
-                print_pb_as_table('', g, omit_fields, self.poutput,
-                                  show_nulls=True)
-                if g.enabled:
-                    state = 'enabled'
-                else:
-                    state = 'disabled'
-                print_pb_list_as_table(
-                    'Metric group {} is {}'.format(g.group_name,state),
-                    g.metrics, {'enabled', 'sample_freq'}, self.poutput,
-                    dividers=100, show_nulls=True)
-        else:
-            if self.pm_config_last.freq_override:
-                omit_fields = {}
-            else:
-                omit_fields = {'sample_freq'}
-            print_pb_list_as_table('Supported metrics:', self.pm_config_last.metrics,
-                                   omit_fields, self.poutput, dividers=100,
-                                   show_nulls=True)
-
-    def do_flows(self, line):
-        """Show flow table for device"""
-        device = pb2dict(self.get_device(-1))
-        print_flows(
-            'Device',
-            self.device_id,
-            type=device['type'],
-            flows=device['flows']['items'],
-            groups=device['flow_groups']['items']
-        )
-
-    def do_images(self, line):
-        """Show software images on the device"""
-        device = self.get_device(depth=-1)
-        omit_fields = {}
-        print_pb_list_as_table('Software Images:', device.images.image,
-                               omit_fields, self.poutput, show_nulls=True)
-
-    @options([
-        make_option('-u', '--url', action='store', dest='url',
-                    help="URL to get sw image"),
-        make_option('-n', '--name', action='store', dest='name',
-                    help="Image name"),
-        make_option('-c', '--crc', action='store', dest='crc',
-                    help="CRC code to verify with", default=0),
-        make_option('-v', '--version', action='store', dest='version',
-                    help="Image version", default=0),
-    ])
-    def do_img_dnld_request(self, line, opts):
-        """
-        Request image download to a device
-        """
-        device = self.get_device(depth=-1)
-        self.poutput('device_id {}'.format(device.id))
-        self.poutput('name {}'.format(opts.name))
-        self.poutput('url {}'.format(opts.url))
-        self.poutput('crc {}'.format(opts.crc))
-        self.poutput('version {}'.format(opts.version))
-        try:
-            device_id = device.id
-            if device_id and opts.name and opts.url:
-                kw = dict(id=device_id)
-                kw['name'] = opts.name
-                kw['url'] = opts.url
-            else:
-                self.poutput('Device ID and URL are needed')
-                raise Exception('Device ID and URL are needed')
-        except Exception as e:
-            self.poutput('Error request img dnld {}.  Error:{}'.format(device_id, e))
-            return
-        kw['crc'] = long(opts.crc)
-        kw['image_version'] = opts.version
-        response = None
-        try:
-            request = voltha_pb2.ImageDownload(**kw)
-            stub = self.get_stub()
-            response = stub.DownloadImage(request)
-        except Exception as e:
-            self.poutput('Error download image {}. Error:{}'.format(kw['id'], e))
-            return
-        name = enum2name(common_pb2.OperationResp,
-                        'OperationReturnCode', response.code)
-        self.poutput('response: {}'.format(name))
-        self.poutput('{}'.format(response))
-
-    @options([
-        make_option('-n', '--name', action='store', dest='name',
-                    help="Image name"),
-    ])
-    def do_img_dnld_status(self, line, opts):
-        """
-        Get a image download status
-        """
-        device = self.get_device(depth=-1)
-        self.poutput('device_id {}'.format(device.id))
-        self.poutput('name {}'.format(opts.name))
-        try:
-            device_id = device.id
-            if device_id and opts.name:
-                kw = dict(id=device_id)
-                kw['name'] = opts.name
-            else:
-                self.poutput('Device ID, Image Name are needed')
-                raise Exception('Device ID, Image Name are needed')
-        except Exception as e:
-            self.poutput('Error get img dnld status {}.  Error:{}'.format(device_id, e))
-            return
-        status = None
-        try:
-            img_dnld = voltha_pb2.ImageDownload(**kw)
-            stub = self.get_stub()
-            status = stub.GetImageDownloadStatus(img_dnld)
-        except Exception as e:
-            self.poutput('Error get img dnld status {}. Error:{}'.format(device_id, e))
-            return
-        fields_to_omit = {
-              'crc',
-              'local_dir',
-        }
-        try:
-            print_pb_as_table('ImageDownload Status:', status, fields_to_omit, self.poutput)
-        except Exception, e:
-            self.poutput('Error {}.  Error:{}'.format(device_id, e))
-
-    def do_img_dnld_list(self, line):
-        """
-        List all image download records for a given device
-        """
-        device = self.get_device(depth=-1)
-        device_id = device.id
-        self.poutput('Get all img dnld records {}'.format(device_id))
-        try:
-            stub = self.get_stub()
-            img_dnlds = stub.ListImageDownloads(voltha_pb2.ID(id=device_id))
-        except Exception, e:
-            self.poutput('Error list img dnlds {}.  Error:{}'.format(device_id, e))
-            return
-        fields_to_omit = {
-              'crc',
-              'local_dir',
-        }
-        try:
-            print_pb_list_as_table('ImageDownloads:', img_dnlds.items, fields_to_omit, self.poutput)
-        except Exception, e:
-            self.poutput('Error {}.  Error:{}'.format(device_id, e))
-
-
-    @options([
-        make_option('-n', '--name', action='store', dest='name',
-                    help="Image name"),
-    ])
-    def do_img_dnld_cancel(self, line, opts):
-        """
-        Cancel a requested image download
-        """
-        device = self.get_device(depth=-1)
-        self.poutput('device_id {}'.format(device.id))
-        self.poutput('name {}'.format(opts.name))
-        device_id = device.id
-        try:
-            if device_id and opts.name:
-                kw = dict(id=device_id)
-                kw['name'] = opts.name
-            else:
-                self.poutput('Device ID, Image Name are needed')
-                raise Exception('Device ID, Image Name are needed')
-        except Exception as e:
-            self.poutput('Error cancel sw dnld {}. Error:{}'.format(device_id, e))
-            return
-        response = None
-        try:
-            img_dnld = voltha_pb2.ImageDownload(**kw)
-            stub = self.get_stub()
-            img_dnld = stub.GetImageDownload(img_dnld)
-            response = stub.CancelImageDownload(img_dnld)
-        except Exception as e:
-            self.poutput('Error cancel sw dnld {}. Error:{}'.format(device_id, e))
-            return
-        name = enum2name(common_pb2.OperationResp,
-                        'OperationReturnCode', response.code)
-        self.poutput('response: {}'.format(name))
-        self.poutput('{}'.format(response))
-
-    def help_simulate_alarm(self):
-        self.poutput(
-'''
-simulate_alarm <alarm_name> [-b <bit rate>] [-c] [-d <drift>] [-e <eqd>]
-            [-i <interface id>] [-o <onu device id>] [-p <port type name>]
-
-<name> is the name of the alarm to raise. Other rguments are alarm specific
-and only have meaning in the context of a particular alarm. Below is a list
-of the alarms that may be raised:
-
-simulate_alarm los -i <interface_id> -p <port_type_name>
-simulate_alarm dying_gasp -i <interface_id> -o <onu_device_id>
-simulate_alarm onu_los -i <interface_id> -o <onu_device_id>
-simulate_alarm onu_lopc_miss -i <interface_id> -o <onu_device_id>
-simulate_alarm onu_lopc_mic -i <interface_id> -o <onu_device_id>
-simulate_alarm onu_lob -i <interface_id> -o <onu_device_id>
-simulate_alarm onu_signal_degrade -i <interface_id> -o <onu_device_id>
-               -b <bit_rate>
-simulate_alarm onu_drift_of_window -i <interface_id>
-               -o <onu_device_id> -d <drift> -e <eqd>
-simulate_alarm onu_signal_fail -i <interface_id> -o <onu_device_id>
-               -b <bit_rate>
-simulate_alarm onu_activation -i <interface_id> -o <onu_device_id>
-simulate_alarm onu_startup -i <interface_id> -o <onu_device_id>
-simulate_alarm onu_discovery -i <interface_id> -s <onu_serial_number>
-
-If the -c option is specified then the alarm will be cleared. By default,
-it will be raised. Note that only some alarms can be cleared.
-'''
-        )
-
-    @options([
-        make_option('-c', '--clear', action='store_true', default=False,
-                    help="Clear alarm instead of raising"),
-        make_option('-b', '--inverse_bit_error_rate', action='store', dest='inverse_bit_error_rate',
-                    help="Inverse bit error rate", default=0, type="int"),
-        make_option('-d', '--drift', action='store', dest='drift',
-                    help="Drift", default=0, type="int"),
-        make_option('-e', '--new_eqd', action='store', dest='new_eqd',
-                    help="New EQD", default=0, type="int"),
-        make_option('-i', '--intf_id', action='store', dest='intf_id',
-                    help="Interface ID", default=""),
-        make_option('-o', '--onu_device_id', action='store', dest='onu_device_id',
-                    help="ONU device ID", default=""),
-        make_option('-p', '--port_type_name', action='store', dest='port_type_name',
-                    help="Port type name", default=""),
-        make_option('-s', '--onu_serial_number', action='store', dest='onu_serial_number',
-                    help="ONU Serial Number", default=""),
-    ])
-    def do_simulate_alarm(self, line, opts):
-        indicator = line
-        device = self.get_device(depth=-1)
-        device_id = device.id
-
-        alarm_args = {"los": ["intf_id", "port_type_name"],
-                      "dying_gasp": ["intf_id", "onu_device_id"],
-                      "onu_los": ["intf_id", "onu_device_id"],
-                      "onu_lopc_miss": ["intf_id", "onu_device_id"],
-                      "onu_lopc_mic": ["intf_id", "onu_device_id"],
-                      "onu_lob": ["intf_id", "onu_device_id"],
-                      "onu_signal_degrade": ["intf_id", "onu_device_id", "inverse_bit_error_rate"],
-                      "onu_drift_of_window": ["intf_id", "onu_device_id", "drift", "new_eqd"],
-                      "onu_signal_fail": ["intf_id", "onu_device_id", "inverse_bit_error_rate"],
-                      "onu_activation": ["intf_id", "onu_device_id"],
-                      "onu_startup": ["intf_id", "onu_device_id"],
-                      "onu_discovery": ["intf_id", "onu_serial_number"]
-                      }
-        try:
-            if indicator not in alarm_args:
-                self.poutput("Unknown alarm indicator %s. Valid choices are %s." % (indicator,
-                                                                                    ", ".join(alarm_args.keys())))
-                raise Exception("Unknown alarm indicator %s" % indicator)
-
-            for arg_name in alarm_args[indicator]:
-                if not getattr(opts, arg_name):
-                    self.poutput("Option %s is required for alarm %s. See help." % (arg_name, indicator))
-                    raise Exception("Option %s is required for alarm %s" % (arg_name, indicator))
-
-            # TODO: check for required arguments
-            kw = dict(id=device_id)
-
-            kw["indicator"] = indicator
-            kw["intf_id"] = opts.intf_id
-            kw["onu_device_id"] = opts.onu_device_id
-            kw["port_type_name"] = opts.port_type_name
-            kw["inverse_bit_error_rate"] = opts.inverse_bit_error_rate
-            kw["drift"] = opts.drift
-            kw["new_eqd"] = opts.new_eqd
-            kw["onu_serial_number"] = opts.onu_serial_number
-
-            if opts.clear:
-                kw["operation"] = voltha_pb2.SimulateAlarmRequest.CLEAR
-            else:
-                kw["operation"] = voltha_pb2.SimulateAlarmRequest.RAISE
-        except Exception as e:
-            self.poutput('Error simulate alarm {}. Error:{}'.format(device_id, e))
-            return
-        response = None
-        try:
-            simulate_alarm = voltha_pb2.SimulateAlarmRequest(**kw)
-            stub = self.get_stub()
-            response = stub.SimulateAlarm(simulate_alarm)
-        except Exception as e:
-            self.poutput('Error simulate alarm {}. Error:{}'.format(kw['id'], e))
-            return
-        name = enum2name(common_pb2.OperationResp,
-                        'OperationReturnCode', response.code)
-        self.poutput('response: {}'.format(name))
-        self.poutput('{}'.format(response))
-
-    @options([
-        make_option('-n', '--name', action='store', dest='name',
-                    help="Image name"),
-        make_option('-s', '--save', action='store', dest='save_config',
-                    help="Save Config", default="True"),
-        make_option('-d', '--dir', action='store', dest='local_dir',
-                    help="Image on device location"),
-    ])
-    def do_img_activate(self, line, opts):
-        """
-        Activate an image update on device
-        """
-        device = self.get_device(depth=-1)
-        device_id = device.id
-        try:
-            if device_id and opts.name and opts.local_dir:
-                kw = dict(id=device_id)
-                kw['name'] = opts.name
-                kw['local_dir'] = opts.local_dir
-            else:
-                self.poutput('Device ID, Image Name, and Location are needed')
-                raise Exception('Device ID, Image Name, and Location are needed')
-        except Exception as e:
-            self.poutput('Error activate image {}. Error:{}'.format(device_id, e))
-            return
-        kw['save_config'] = json.loads(opts.save_config.lower())
-        self.poutput('activate image update {} {} {} {}'.format( \
-                    kw['id'], kw['name'],
-                    kw['local_dir'], kw['save_config']))
-        response = None
-        try:
-            img_dnld = voltha_pb2.ImageDownload(**kw)
-            stub = self.get_stub()
-            img_dnld = stub.GetImageDownload(img_dnld)
-            response = stub.ActivateImageUpdate(img_dnld)
-        except Exception as e:
-            self.poutput('Error activate image {}. Error:{}'.format(kw['id'], e))
-            return
-        name = enum2name(common_pb2.OperationResp,
-                        'OperationReturnCode', response.code)
-        self.poutput('response: {}'.format(name))
-        self.poutput('{}'.format(response))
-
-    @options([
-        make_option('-n', '--name', action='store', dest='name',
-                    help="Image name"),
-        make_option('-s', '--save', action='store', dest='save_config',
-                    help="Save Config", default="True"),
-        make_option('-d', '--dir', action='store', dest='local_dir',
-                    help="Image on device location"),
-    ])
-    def do_img_revert(self, line, opts):
-        """
-        Revert an image update on device
-        """
-        device = self.get_device(depth=-1)
-        device_id = device.id
-        try:
-            if device_id and opts.name and opts.local_dir:
-                kw = dict(id=device_id)
-                kw['name'] = opts.name
-                kw['local_dir'] = opts.local_dir
-            else:
-                self.poutput('Device ID, Image Name, and Location are needed')
-                raise Exception('Device ID, Image Name, and Location are needed')
-        except Exception as e:
-            self.poutput('Error revert image {}. Error:{}'.format(device_id, e))
-            return
-        kw['save_config'] = json.loads(opts.save_config.lower())
-        self.poutput('revert image update {} {} {} {}'.format( \
-                    kw['id'], kw['name'],
-                    kw['local_dir'], kw['save_config']))
-        response = None
-        try:
-            img_dnld = voltha_pb2.ImageDownload(**kw)
-            stub = self.get_stub()
-            img_dnld = stub.GetImageDownload(img_dnld)
-            response = stub.RevertImageUpdate(img_dnld)
-        except Exception as e:
-            self.poutput('Error revert image {}. Error:{}'.format(kw['id'], e))
-            return
-        name = enum2name(common_pb2.OperationResp,
-                        'OperationReturnCode', response.code)
-        self.poutput('response: {}'.format(name))
-        self.poutput('{}'.format(response))
diff --git a/python/cli/docs/README.md b/python/cli/docs/README.md
deleted file mode 100644
index e09f60e..0000000
--- a/python/cli/docs/README.md
+++ /dev/null
@@ -1,116 +0,0 @@
-# Voltha CLI (~/cli)
-
-## Overview
-
-The Voltha CLI allows a user to manage OLT and ONU devices along with their corresponding logical devices.   
-
-
-## Building the CLI
-
-From the voltha-go directory:
-```
-cd python
-source env.sh
-make cli
-```
-
-## Usage
-
-#### Setup (Development Mode)
-Since the CLI does not do much by itself, then to fully use it, you will need a somewhat complete 
-set of dependent containers running as well.  These will include the rw_core, OLT/ONU adapters and the actual OLT
- and ONU devices. For the examples below we will use ponsim as the adapters and ponsimv2 as the devices.  In order to get 
- everything running we also need Kafka (with zookeeper) and the Etcd KV store. 
- 
-First run the dependent containers from the voltha-go directory. In the commands below, replace the IP 
-with the IP of the host.
-```
-DOCKER_HOST_IP=<Host IP> docker-compose -f compose/docker-compose-zk-kafka-test.yml up -d
-DOCKER_HOST_IP=<Host IP> docker-compose -f compose/docker-compose-etcd.yml up -d
-DOCKER_HOST_IP=<Host IP> docker-compose -f compose/rw_core.yml up -d
-DOCKER_HOST_IP=<Host IP> docker-compose -f compose/cli.yml up -d
-DOCKER_HOST_IP=<Host IP> docker-compose -f compose/adapters-ponsim.yml up -d
-REPOSITORY=voltha/ docker-compose -f compose/ponsim_olt.yml up -d
-REPOSITORY=voltha/ docker-compose -f compose/ponsim_onu.yml up -d
-```
-
-#### Starting the CLI
-
-Now, start the CLI. Password for 'voltha' user is 'admin'. Please see Dockerfile.cli for passwords
-
-```shell
-tput rmam // If you are running on MAC for a clean output
-ssh -p 5022 voltha@localhost
-```
-
-At the prompt, if you type ```help``` you will see all the supported commands and sub-commands.
-
-####Provisioning and activating an OLT device
-
-Run the following at the prompt
-
-```shell
-preprovision_olt -t ponsim_olt -H <IP of Ponsim OLT>:50060 // Note this is the actial ponsim_olt container IP
-enable <deviceId>  // Use the device ID returned in the previous command
-```
-
-The ```enable``` command returns the logical device Id assigned to that OLT.  It is typically the MAC address 
-(without the ```:```) of the OLT device.
-
-Now go and try out the commands and sub-commands of the CLI.
-
-####Changing the logging level of the RW Core via the CLI
-
-You can dynamically change the logging level on the Voltha RW Core.  The change can be done at a package 
-level or for the entire RW Core.  
-
-The syntax to change log level is as follows:
-
-```
-log -p [package_name] -l log_level
-
-where 
-    package_name (optional) is one of:
-        db/kvstore
-        db/model
-        kafka
-        rw_core/core
-        rw_core/flow_decomposition
-        rw_core/graph
-    
-    log_level is one of:
-        DEBUG
-        INFO
-        WARNING
-        ERROR
-        CRITICAL
-        FATAL 
-```
-
-Below are some examples.
-```shell
-log -l ERROR // This sets the entire RW_CORE to output ERROR and above logs for all packages
-log -p rw_core/core -l DEBUG // This sets the rw_core/core package to debug level
-```
-
-Typically, if you want to debug, say something with the kvstore, then you would set the log level for
-the entire RW Core to error followed by setting the log level to debug for the kvstore as shown below.
-```shell
-log -l ERROR // This sets the entire RW_CORE to output ERROR and above logs for all packages
-log -p db/kvstore -l DEBUG // This sets the db/kvstore package to debug level
-```
-
-###Future CLI improvements
-
-* Add auto-completion for most common args like device and logical device ids
-* Add consistent argument checking
-* Unify code that retrieves data from gRPC
-* Unify code that prints out data/response, to allow:
-  * Selectable output mode:
-    * JSON
-    * Tabular
-* Organize history per sub context so that in each context the commands 
-  entered in that context will show
-* Metaprogramming [BIG ONE]: Make large part of the commands come from annotations embedded in
-  the protobuf files and have corresponding handler auto-generated by protoc
-* Package CLI as docker container, bake it into composition
diff --git a/python/cli/logical_device.py b/python/cli/logical_device.py
deleted file mode 100644
index a49f6f8..0000000
--- a/python/cli/logical_device.py
+++ /dev/null
@@ -1,127 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright 2016 the original author or authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-"""
-Logical device level CLI commands
-"""
-from cmd2 import Cmd
-from simplejson import dumps
-
-from table import print_pb_as_table, print_pb_list_as_table
-from utils import pb2dict
-from utils import print_flows, print_groups
-from google.protobuf.empty_pb2 import Empty
-
-from voltha_protos import voltha_pb2
-
-
-class LogicalDeviceCli(Cmd):
-
-    def __init__(self, logical_device_id, get_stub):
-        Cmd.__init__(self)
-        self.get_stub = get_stub
-        self.logical_device_id = logical_device_id
-        self.prompt = '(' + self.colorize(
-            self.colorize('logical device {}'.format(logical_device_id), 'red'),
-            'bold') + ') '
-
-    def cmdloop(self):
-        self._cmdloop()
-
-    def get_logical_device(self, depth=0):
-        stub = self.get_stub()
-        res = stub.GetLogicalDevice(voltha_pb2.ID(id=self.logical_device_id),
-                                    metadata=(('get-depth', str(depth)), ))
-        return res
-
-    def get_device(self, id):
-        stub = self.get_stub()
-        return stub.GetDevice(voltha_pb2.ID(id=id))
-
-    def get_devices(self):
-        stub = self.get_stub()
-        res = stub.ListDevices(Empty())
-        return res.items
-
-    do_exit = Cmd.do_quit
-
-    def do_show(self, _):
-        """Show detailed logical device information"""
-        print_pb_as_table('Logical device {}'.format(self.logical_device_id),
-                          self.get_logical_device(depth=-1))
-
-    def do_ports(self, _):
-        """Show ports of logical device"""
-        device = self.get_logical_device(depth=-1)
-        omit_fields = {
-            'ofp_port.advertised',
-            'ofp_port.peer',
-            'ofp_port.max_speed'
-        }
-        print_pb_list_as_table('Logical device ports:', device.ports,
-                               omit_fields, self.poutput)
-
-    def do_flows(self, _):
-        """Show flow table for logical device"""
-        logical_device = pb2dict(self.get_logical_device(-1))
-        print_flows(
-            'Logical Device',
-            self.logical_device_id,
-            type='n/a',
-            flows=logical_device['flows']['items'],
-            groups=logical_device['flow_groups']['items']
-        )
-
-    def do_groups(self, _):
-        """Show flow group table for logical device"""
-        logical_device = pb2dict(self.get_logical_device(-1))
-        print_groups(
-            'Logical Device',
-            self.logical_device_id,
-            type='n/a',
-            groups=logical_device['flow_groups']['items']
-        )
-
-    def do_meters(self, _):
-        """Show flow meter table for logical device"""
-        logical_device = pb2dict(self.get_logical_device(-1))
-        print_meters(
-            'Logical Device',
-            self.logical_device_id,
-            type='n/a',
-            meters=logical_device['meters']['items']
-        )
-
-    def do_devices(self, line):
-        """List devices that belong to this logical device"""
-        logical_device = self.get_logical_device()
-        root_device_id = logical_device.root_device_id
-        devices = [self.get_device(root_device_id)]
-        for d in self.get_devices():
-            if d.parent_id == root_device_id:
-                devices.append(d)
-        omit_fields = {
-            'adapter',
-            'vendor',
-            'model',
-            'hardware_version',
-            'software_version',
-            'firmware_version',
-            'serial_number'
-        }
-        print_pb_list_as_table('Devices:', devices, omit_fields, self.poutput)
-
diff --git a/python/cli/main.py b/python/cli/main.py
deleted file mode 100755
index d8ef9f8..0000000
--- a/python/cli/main.py
+++ /dev/null
@@ -1,945 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright 2016 the original author or authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-import argparse
-import os
-import readline
-import sys
-from optparse import make_option
-from time import sleep, time
-
-import grpc
-import requests
-from cmd2 import Cmd, options
-from consul import Consul
-from google.protobuf.empty_pb2 import Empty
-from simplejson import dumps
-
-from device import DeviceCli
-from omci import OmciCli
-from alarm_filters import AlarmFiltersCli
-from logical_device import LogicalDeviceCli
-from table import print_pb_list_as_table
-from pyvoltha.common.openflow.utils import *
-from voltha_protos import voltha_pb2
-from voltha_protos import voltha_pb2_grpc
-from voltha_protos.openflow_13_pb2 import FlowTableUpdate, FlowGroupTableUpdate
-
-from python.cli.utils import pb2dict
-
-defs = dict(
-    # config=os.environ.get('CONFIG', './cli.yml'),
-    consul=os.environ.get('CONSUL', 'localhost:8500'),
-    voltha_grpc_endpoint=os.environ.get('VOLTHA_GRPC_ENDPOINT',
-                                        'localhost:50057'),
-    voltha_sim_rest_endpoint=os.environ.get('VOLTHA_SIM_REST_ENDPOINT',
-                                            'localhost:18880'),
-    global_request=os.environ.get('GLOBAL_REQUEST', False)
-)
-
-banner = """\
-         _ _   _            ___ _    ___
-__ _____| | |_| |_  __ _   / __| |  |_ _|
-\ V / _ \ |  _| ' \/ _` | | (__| |__ | |
- \_/\___/_|\__|_||_\__,_|  \___|____|___|
-(to exit type quit or hit Ctrl-D)
-"""
-
-
-class VolthaCli(Cmd):
-    prompt = 'voltha'
-    history_file_name = '.voltha_cli_history'
-
-    # Settable CLI parameters
-    voltha_grpc = 'localhost:50057'
-    voltha_sim_rest = 'localhost:18880'
-    global_request = False
-    max_history_lines = 500
-    default_device_id = None
-    default_logical_device_id = None
-
-    Cmd.settable.update(dict(
-        voltha_grpc='Voltha GRPC endpoint in form of <host>:<port>',
-        voltha_sim_rest='Voltha simulation back door for testing in form '
-                        'of <host>:<port>',
-        max_history_lines='Maximum number of history lines stored across '
-                          'sessions',
-        default_device_id='Device id used when no device id is specified',
-        default_logical_device_id='Logical device id used when no device id '
-                                  'is specified',
-    ))
-
-    # cleanup of superfluous commands from cmd2
-    del Cmd.do_cmdenvironment
-    del Cmd.do_load
-    del Cmd.do__relative_load
-
-    def __init__(self, voltha_grpc, voltha_sim_rest, global_request=False):
-
-        VolthaCli.voltha_grpc = voltha_grpc
-        VolthaCli.voltha_sim_rest = voltha_sim_rest
-        VolthaCli.global_request = global_request
-        Cmd.__init__(self)
-        self.prompt = '(' + self.colorize(
-            self.colorize(self.prompt, 'blue'), 'bold') + ') '
-        self.channel = None
-        self.stub = None
-        self.device_ids_cache = None
-        self.device_ids_cache_ts = time()
-        self.logical_device_ids_cache = None
-        self.logical_device_ids_cache_ts = time()
-
-    # we override cmd2's method to avoid its optparse conflicting with our
-    # command line parsing
-    def cmdloop(self):
-        self._cmdloop()
-
-    def load_history(self):
-        """Load saved command history from local history file"""
-        try:
-            with file(self.history_file_name, 'r') as f:
-                for line in f.readlines():
-                    stripped_line = line.strip()
-                    self.history.append(stripped_line)
-                    readline.add_history(stripped_line)
-        except IOError:
-            pass  # ignore if file cannot be read
-
-    def save_history(self):
-        try:
-            with open(self.history_file_name, 'w') as f:
-                f.write('\n'.join(self.history[-self.max_history_lines:]))
-        except IOError as e:
-            self.perror('Could not save history in {}: {}'.format(
-                self.history_file_name, e))
-        else:
-            self.poutput('History saved as {}'.format(
-                self.history_file_name))
-
-    def perror(self, errmsg, statement=None):
-        # Touch it up to make sure error is prefixed and colored
-        Cmd.perror(self, self.colorize('***ERROR: ', 'red') + errmsg,
-                   statement)
-
-    def get_channel(self):
-        if self.channel is None:
-            self.channel = grpc.insecure_channel(self.voltha_grpc)
-        return self.channel
-
-    def get_stub(self):
-        if self.stub is None:
-            self.stub = voltha_pb2_grpc.VolthaServiceStub(self.get_channel())
-            # self.stub = \
-            #     voltha_pb2.VolthaGlobalServiceStub(self.get_channel()) \
-            #         if self.global_request else \
-            #             voltha_pb2.VolthaLocalServiceStub(self.get_channel())
-        return self.stub
-
-    # ~~~~~~~~~~~~~~~~~ ACTUAL COMMAND IMPLEMENTATIONS ~~~~~~~~~~~~~~~~~~~~~~~~
-
-    def do_reset_history(self, line):
-        """Reset CLI history"""
-        while self.history:
-            self.history.pop()
-
-    @options([
-        make_option('-p', '--package', action="store", dest='package',
-                    help="Package Name"),
-        make_option('-l', '--level', action='store', dest='level'),
-    ])
-    def do_log(self, line, opts):
-
-        def logLevel(level):
-            switcher= {
-                "DEBUG": 0,
-                "INFO":1,
-                "WARNING":2,
-                "ERROR":3,
-                "CRITICAL":4,
-                "FATAL":5
-            }
-            return switcher.get(level, 3)
-
-        if opts.level is None:
-            return
-
-        stub = self.get_stub()
-        kw = dict()
-        if opts.package:
-            kw['package_name'] = "github.com/opencord/voltha-go/" + opts.package
-
-        kw['level'] = logLevel(opts.level.upper())
-
-        try:
-            logging = voltha_pb2.Logging(**kw)
-            stub.UpdateLogLevel(logging)
-            self.poutput('success')
-        except Exception as e:
-            self.poutput('Exception - {})'.format(e))
-
-    def do_launch(self, line):
-        """If Voltha is not running yet, launch it"""
-        raise NotImplementedError('not implemented yet')
-
-    def do_restart(self, line):
-        """Launch Voltha, but if it is already running, terminate it first"""
-        pass
-
-    def do_adapters(self, line):
-        """List loaded adapter"""
-        stub = self.get_stub()
-        res = stub.ListAdapters(Empty())
-        omit_fields = {'config.log_level', 'logical_device_ids'}
-        print_pb_list_as_table('Adapters:', res.items, omit_fields, self.poutput)
-
-    def get_devices(self):
-        stub = self.get_stub()
-        res = stub.ListDevices(Empty())
-        return res.items
-
-    def get_logical_devices(self):
-        stub = self.get_stub()
-        res = stub.ListLogicalDevices(Empty())
-        return res.items
-
-    def do_devices(self, line):
-        """List devices registered in Voltha"""
-        devices = self.get_devices()
-        omit_fields = {
-            'adapter',
-            'vendor',
-            'model',
-            'hardware_version',
-            'images',
-            'firmware_version',
-            'vendor_id',
-            'flows',
-            'pm_configs',
-            'proxy_address',
-            'ports',
-            'vlan'
-        }
-        print_pb_list_as_table('Devices:', devices, omit_fields, self.poutput)
-
-    def do_logical_devices(self, line):
-        """List logical devices in Voltha"""
-        stub = self.get_stub()
-        res = stub.ListLogicalDevices(Empty())
-        omit_fields = {
-            'desc.mfr_desc',
-            'desc.hw_desc',
-            'desc.sw_desc',
-            'desc.dp_desc',
-            'desc.serial_number',
-            'switch_features.capabilities'
-        }
-        presfns = {
-            'datapath_id': lambda x: "{0:0{1}x}".format(int(x), 16)
-        }
-        print_pb_list_as_table('Logical devices:', res.items, omit_fields,
-                               self.poutput, presfns=presfns)
-
-    def do_device(self, line):
-        """Enter device level command mode"""
-        device_id = line.strip() or self.default_device_id
-        if not device_id:
-            raise Exception('<device-id> parameter needed')
-        if device_id not in self.device_ids():
-            self.poutput( self.colorize('Error: ', 'red') +
-                            'There is no such device')
-            raise Exception('<device-id> is not a valid one')
-        sub = DeviceCli(device_id, self.get_stub)
-        sub.cmdloop()
-
-    def do_logical_device(self, line):
-        """Enter logical device level command mode"""
-        logical_device_id = line.strip() or self.default_logical_device_id
-        if not logical_device_id:
-            raise Exception('<logical-device-id> parameter needed')
-        if logical_device_id not in self.logical_device_ids():
-            self.poutput( self.colorize('Error: ', 'red') +
-                            'There is no such device')
-            raise Exception('<logical-device-id> is not a valid one')
-        sub = LogicalDeviceCli(logical_device_id, self.get_stub)
-        sub.cmdloop()
-
-    def device_ids(self, force_refresh=False):
-        if force_refresh or self.device_ids is None or \
-                        (time() - self.device_ids_cache_ts) > 1:
-            self.device_ids_cache = [d.id for d in self.get_devices()]
-            self.device_ids_cache_ts = time()
-        return self.device_ids_cache
-
-    def logical_device_ids(self, force_refresh=False):
-        if force_refresh or self.logical_device_ids is None or \
-                        (time() - self.logical_device_ids_cache_ts) > 1:
-            self.logical_device_ids_cache = [d.id for d
-                                             in self.get_logical_devices()]
-            self.logical_device_ids_cache_ts = time()
-        return self.logical_device_ids_cache
-
-    def complete_device(self, text, line, begidx, endidx):
-        if not text:
-            completions = self.device_ids()[:]
-        else:
-            completions = [d for d in self.device_ids() if d.startswith(text)]
-        return completions
-
-    def complete_logical_device(self, text, line, begidx, endidx):
-        if not text:
-            completions = self.logical_device_ids()[:]
-        else:
-            completions = [d for d in self.logical_device_ids()
-                           if d.startswith(text)]
-        return completions
-
-    def do_omci(self, line):
-        """omci <device_ID> - Enter OMCI level command mode"""
-
-        device_id = line.strip() or self.default_device_id
-        if not device_id:
-            raise Exception('<device-id> parameter needed')
-        sub = OmciCli(device_id, self.get_stub)
-        sub.cmdloop()
-
-    def do_pdb(self, line):
-        """Launch PDB debug prompt in CLI (for CLI development)"""
-        from pdb import set_trace
-        set_trace()
-
-    def do_version(self, line):
-        """Show the VOLTHA core version"""
-        stub = self.get_stub()
-        voltha = stub.GetVoltha(Empty())
-        self.poutput('{}'.format(voltha.version))
-
-    def do_health(self, line):
-        """Show connectivity status to Voltha status"""
-        stub = voltha_pb2.HealthServiceStub(self.get_channel())
-        res = stub.GetHealthStatus(Empty())
-        self.poutput(dumps(pb2dict(res), indent=4))
-
-    @options([
-        make_option('-t', '--device-type', action="store", dest='device_type',
-                    help="Device type", default='simulated_olt'),
-        make_option('-m', '--mac-address', action='store', dest='mac_address',
-                    default='00:0c:e2:31:40:00'),
-        make_option('-i', '--ip-address', action='store', dest='ip_address'),
-        make_option('-H', '--host_and_port', action='store',
-                    dest='host_and_port'),
-    ])
-    def do_preprovision_olt(self, line, opts):
-        """Preprovision a new OLT with given device type"""
-        stub = self.get_stub()
-        kw = dict(type=opts.device_type)
-        if opts.host_and_port:
-            kw['host_and_port'] = opts.host_and_port
-        elif opts.ip_address:
-            kw['ipv4_address'] = opts.ip_address
-        elif opts.mac_address:
-            kw['mac_address'] = opts.mac_address.lower()
-        else:
-            raise Exception('Either IP address or Mac Address is needed')
-        # Pass any extra arguments past '--' to the device as custom arguments
-        kw['extra_args'] = line
-
-        device = voltha_pb2.Device(**kw)
-        device = stub.CreateDevice(device)
-        self.poutput('success (device id = {})'.format(device.id))
-        self.default_device_id = device.id
-
-    def do_enable(self, line):
-        """
-        Enable a device. If the <id> is not provided, it will be on the last
-        pre-provisioned device.
-        """
-        device_id = line or self.default_device_id
-        if device_id not in self.device_ids():
-            self.poutput('Error: There is no such preprovisioned device')
-            return
-
-        try:
-            stub = self.get_stub()
-            device = stub.GetDevice(voltha_pb2.ID(id=device_id))
-            if device.admin_state == voltha_pb2.AdminState.ENABLED:
-                if device.oper_status != voltha_pb2.OperStatus.ACTIVATING:
-                    self.poutput('Error: Device is already enabled')
-                    return
-            else:
-                stub.EnableDevice(voltha_pb2.ID(id=device_id))
-                self.poutput('enabling {}'.format(device_id))
-
-            while True:
-                device = stub.GetDevice(voltha_pb2.ID(id=device_id))
-                # If this is an OLT then acquire logical device id
-                if device.oper_status == voltha_pb2.OperStatus.ACTIVE:
-                    if device.type.endswith('_olt'):
-                        assert device.parent_id
-                        self.default_logical_device_id = device.parent_id
-                        self.poutput('success (logical device id = {})'.format(
-                            self.default_logical_device_id))
-                    else:
-                        self.poutput('success (device id = {})'.format(device.id))
-                    break
-                self.poutput('waiting for device to be enabled...')
-                sleep(.5)
-        except Exception as e:
-            self.poutput('Error enabling {}.  Error:{}'.format(device_id, e))
-
-    complete_activate_olt = complete_device
-
-    def do_reboot(self, line):
-        """
-        Rebooting a device. ID of the device needs to be provided
-        """
-        device_id = line or self.default_device_id
-        self.poutput('rebooting {}'.format(device_id))
-        try:
-            stub = self.get_stub()
-            stub.RebootDevice(voltha_pb2.ID(id=device_id))
-            self.poutput('rebooted {}'.format(device_id))
-        except Exception as e:
-            self.poutput('Error rebooting {}.  Error:{}'.format(device_id, e))
-
-    def do_self_test(self, line):
-        """
-        Self Test a device. ID of the device needs to be provided
-        """
-        device_id = line or self.default_device_id
-        self.poutput('Self Testing {}'.format(device_id))
-        try:
-            stub = self.get_stub()
-            res = stub.SelfTest(voltha_pb2.ID(id=device_id))
-            self.poutput('Self Tested {}'.format(device_id))
-            self.poutput(dumps(pb2dict(res), indent=4))
-        except Exception as e:
-            self.poutput('Error in self test {}.  Error:{}'.format(device_id, e))
-
-    def do_delete(self, line):
-        """
-        Deleting a device. ID of the device needs to be provided
-        """
-        device_id = line or self.default_device_id
-        self.poutput('deleting {}'.format(device_id))
-        try:
-            stub = self.get_stub()
-            stub.DeleteDevice(voltha_pb2.ID(id=device_id))
-            self.poutput('deleted {}'.format(device_id))
-        except Exception as e:
-            self.poutput('Error deleting {}.  Error:{}'.format(device_id, e))
-
-    def do_disable(self, line):
-        """
-        Disable a device. ID of the device needs to be provided
-        """
-        device_id = line
-        if device_id not in self.device_ids():
-            self.poutput('Error: There is no such device')
-            return
-        try:
-            stub = self.get_stub()
-            device = stub.GetDevice(voltha_pb2.ID(id=device_id))
-            if device.admin_state == voltha_pb2.AdminState.DISABLED:
-                self.poutput('Error: Device is already disabled')
-                return
-            stub.DisableDevice(voltha_pb2.ID(id=device_id))
-            self.poutput('disabling {}'.format(device_id))
-
-            # Do device query and verify that the device admin status is
-            # DISABLED and Operational Status is unknown
-            device = stub.GetDevice(voltha_pb2.ID(id=device_id))
-            if device.admin_state == voltha_pb2.AdminState.DISABLED:
-                self.poutput('disabled successfully {}'.format(device_id))
-            else:
-                self.poutput('disabling failed {}.  Admin State:{} '
-                             'Operation State: {}'.format(device_id,
-                                                          device.admin_state,
-                                                          device.oper_status))
-        except Exception as e:
-            self.poutput('Error disabling {}.  Error:{}'.format(device_id, e))
-
-    def do_test(self, line):
-        """Enter test mode, which makes a bunch on new commands available"""
-        sub = TestCli(self.history, self.voltha_grpc,
-                      self.get_stub, self.voltha_sim_rest)
-        sub.cmdloop()
-
-    def do_alarm_filters(self, line):
-        sub = AlarmFiltersCli(self.get_stub)
-        sub.cmdloop()
-
-
-class TestCli(VolthaCli):
-    def __init__(self, history, voltha_grpc, get_stub, voltha_sim_rest):
-        VolthaCli.__init__(self, voltha_grpc, voltha_sim_rest)
-        self.history = history
-        self.get_stub = get_stub
-        self.prompt = '(' + self.colorize(self.colorize('test', 'cyan'),
-                                          'bold') + ') '
-
-    def get_device(self, device_id, depth=0):
-        stub = self.get_stub()
-        res = stub.GetDevice(voltha_pb2.ID(id=device_id),
-                             metadata=(('get-depth', str(depth)),))
-        return res
-
-    def do_arrive_onus(self, line):
-        """
-        Simulate the arrival of ONUs (available only on simulated_olt)
-        """
-        device_id = line or self.default_device_id
-
-        # verify that device is of type simulated_olt
-        device = self.get_device(device_id)
-        assert device.type == 'simulated_olt', (
-            'Cannot use it on this device type (only on simulated_olt type)')
-
-        requests.get('http://{}/devices/{}/detect_onus'.format(
-            self.voltha_sim_rest, device_id
-        ))
-
-    complete_arrive_onus = VolthaCli.complete_device
-
-    def get_logical_ports(self, logical_device_id):
-        """
-        Return the NNI port number and the first usable UNI port of logical
-        device, and the vlan associated with the latter.
-        """
-        stub = self.get_stub()
-        ports = stub.ListLogicalDevicePorts(
-            voltha_pb2.ID(id=logical_device_id)).items
-        nni = None
-        unis = []
-        for port in ports:
-            if port.root_port:
-                assert nni is None, "There shall be only one root port"
-                nni = port.ofp_port.port_no
-            else:
-                uni = port.ofp_port.port_no
-                uni_device = self.get_device(port.device_id)
-                vlan = uni_device.vlan
-                unis.append((uni, vlan))
-
-        assert nni is not None, "No NNI port found"
-        assert unis, "Not a single UNI?"
-
-        return nni, unis
-
-    def do_install_eapol_flow(self, line):
-        """
-        Install an EAPOL flow on the given logical device. If device is not
-        given, it will be applied to logical device of the last pre-provisioned
-        OLT device.
-        """
-
-        logical_device_id = line or self.default_logical_device_id
-
-        # gather NNI and UNI port IDs
-        nni_port_no, unis = self.get_logical_ports(logical_device_id)
-
-        # construct and push flow rule
-        stub = self.get_stub()
-        print "I am now here", unis
-        for uni_port_no, _ in unis:
-            update = FlowTableUpdate(
-                id=logical_device_id,
-                flow_mod=mk_simple_flow_mod(
-                    priority=2000,
-                    match_fields=[in_port(uni_port_no), eth_type(0x888e)],
-                    actions=[
-                        # push_vlan(0x8100),
-                        # set_field(vlan_vid(4096 + 4000)),
-                        output(ofp.OFPP_CONTROLLER)
-                    ]
-                )
-            )
-            print "I am now here"
-            res = stub.UpdateLogicalDeviceFlowTable(update)
-            self.poutput('success for uni {} ({})'.format(uni_port_no, res))
-
-    complete_install_eapol_flow = VolthaCli.complete_logical_device
-
-    def do_install_all_controller_bound_flows(self, line):
-        """
-        Install all flow rules for controller bound flows, including EAPOL,
-        IGMP and DHCP. If device is not given, it will be applied to logical
-        device of the last pre-provisioned OLT device.
-        """
-        logical_device_id = line or self.default_logical_device_id
-
-        # gather NNI and UNI port IDs
-        nni_port_no, unis = self.get_logical_ports(logical_device_id)
-
-        # construct and push flow rules
-        stub = self.get_stub()
-
-        for uni_port_no, _ in unis:
-            stub.UpdateLogicalDeviceFlowTable(FlowTableUpdate(
-                id=logical_device_id,
-                flow_mod=mk_simple_flow_mod(
-                    priority=2000,
-                    match_fields=[
-                        in_port(uni_port_no),
-                        eth_type(0x888e)
-                    ],
-                    actions=[output(ofp.OFPP_CONTROLLER)]
-                )
-            ))
-            stub.UpdateLogicalDeviceFlowTable(FlowTableUpdate(
-                id=logical_device_id,
-                flow_mod=mk_simple_flow_mod(
-                    priority=1000,
-                    match_fields=[
-                        in_port(uni_port_no),
-                        eth_type(0x800),
-                        ip_proto(2)
-                    ],
-                    actions=[output(ofp.OFPP_CONTROLLER)]
-                )
-            ))
-            stub.UpdateLogicalDeviceFlowTable(FlowTableUpdate(
-                id=logical_device_id,
-                flow_mod=mk_simple_flow_mod(
-                    priority=1000,
-                    match_fields=[
-                        in_port(uni_port_no),
-                        eth_type(0x800),
-                        ip_proto(17),
-                        udp_dst(67)
-                    ],
-                    actions=[output(ofp.OFPP_CONTROLLER)]
-                )
-            ))
-        self.poutput('success')
-
-    complete_install_all_controller_bound_flows = \
-        VolthaCli.complete_logical_device
-
-    def do_install_all_sample_flows(self, line):
-        """
-        Install all flows that are representative of the virtualized access
-        scenario in a PON network.
-        """
-        logical_device_id = line or self.default_logical_device_id
-
-        # gather NNI and UNI port IDs
-        nni_port_no, unis = self.get_logical_ports(logical_device_id)
-
-        # construct and push flow rules
-        stub = self.get_stub()
-
-        for uni_port_no, c_vid in unis:
-            # Controller-bound flows
-            stub.UpdateLogicalDeviceFlowTable(FlowTableUpdate(
-                id=logical_device_id,
-                flow_mod=mk_simple_flow_mod(
-                    priority=2000,
-                    match_fields=[in_port(uni_port_no), eth_type(0x888e)],
-                    actions=[
-                        # push_vlan(0x8100),
-                        # set_field(vlan_vid(4096 + 4000)),
-                        output(ofp.OFPP_CONTROLLER)
-                    ]
-                )
-            ))
-            stub.UpdateLogicalDeviceFlowTable(FlowTableUpdate(
-                id=logical_device_id,
-                flow_mod=mk_simple_flow_mod(
-                    priority=1000,
-                    match_fields=[eth_type(0x800), ip_proto(2)],
-                    actions=[output(ofp.OFPP_CONTROLLER)]
-                )
-            ))
-            stub.UpdateLogicalDeviceFlowTable(FlowTableUpdate(
-                id=logical_device_id,
-                flow_mod=mk_simple_flow_mod(
-                    priority=1000,
-                    match_fields=[eth_type(0x800), ip_proto(17), udp_dst(67)],
-                    actions=[output(ofp.OFPP_CONTROLLER)]
-                )
-            ))
-
-            # Unicast flows:
-            # Downstream flow 1
-            stub.UpdateLogicalDeviceFlowTable(FlowTableUpdate(
-                id=logical_device_id,
-                flow_mod=mk_simple_flow_mod(
-                    priority=500,
-                    match_fields=[
-                        in_port(nni_port_no),
-                        vlan_vid(4096 + 1000),
-                        metadata(c_vid)  # here to mimic an ONOS artifact
-                    ],
-                    actions=[pop_vlan()],
-                    next_table_id=1
-                )
-            ))
-            # Downstream flow 2
-            stub.UpdateLogicalDeviceFlowTable(FlowTableUpdate(
-                id=logical_device_id,
-                flow_mod=mk_simple_flow_mod(
-                    priority=500,
-                    table_id=1,
-                    match_fields=[in_port(nni_port_no), vlan_vid(4096 + c_vid)],
-                    actions=[set_field(vlan_vid(4096 + 0)), output(uni_port_no)]
-                )
-            ))
-            # Upstream flow 1 for 0-tagged case
-            stub.UpdateLogicalDeviceFlowTable(FlowTableUpdate(
-                id=logical_device_id,
-                flow_mod=mk_simple_flow_mod(
-                    priority=500,
-                    match_fields=[in_port(uni_port_no), vlan_vid(4096 + 0)],
-                    actions=[set_field(vlan_vid(4096 + c_vid))],
-                    next_table_id=1
-                )
-            ))
-            # Upstream flow 1 for untagged case
-            stub.UpdateLogicalDeviceFlowTable(FlowTableUpdate(
-                id=logical_device_id,
-                flow_mod=mk_simple_flow_mod(
-                    priority=500,
-                    match_fields=[in_port(uni_port_no), vlan_vid(0)],
-                    actions=[push_vlan(0x8100), set_field(vlan_vid(4096 + c_vid))],
-                    next_table_id=1
-                )
-            ))
-            # Upstream flow 2 for s-tag
-            stub.UpdateLogicalDeviceFlowTable(FlowTableUpdate(
-                id=logical_device_id,
-                flow_mod=mk_simple_flow_mod(
-                    priority=500,
-                    table_id=1,
-                    match_fields=[in_port(uni_port_no), vlan_vid(4096 + c_vid)],
-                    actions=[
-                        push_vlan(0x8100),
-                        set_field(vlan_vid(4096 + 1000)),
-                        output(nni_port_no)
-                    ]
-                )
-            ))
-
-        # Push a few multicast flows
-        # 1st with one bucket for our uni 0
-        stub.UpdateLogicalDeviceFlowGroupTable(FlowGroupTableUpdate(
-            id=logical_device_id,
-            group_mod=mk_multicast_group_mod(
-                group_id=1,
-                buckets=[
-                    ofp.ofp_bucket(actions=[
-                        pop_vlan(),
-                        output(unis[0][0])
-                    ])
-                ]
-            )
-        ))
-        stub.UpdateLogicalDeviceFlowTable(FlowTableUpdate(
-            id=logical_device_id,
-            flow_mod=mk_simple_flow_mod(
-                priority=1000,
-                match_fields=[
-                    in_port(nni_port_no),
-                    eth_type(0x800),
-                    vlan_vid(4096 + 140),
-                    ipv4_dst(0xe4010101)
-                ],
-                actions=[group(1)]
-            )
-        ))
-
-        # 2nd with one bucket for uni 0 and 1
-        stub.UpdateLogicalDeviceFlowGroupTable(FlowGroupTableUpdate(
-            id=logical_device_id,
-            group_mod=mk_multicast_group_mod(
-                group_id=2,
-                buckets=[
-                    ofp.ofp_bucket(actions=[pop_vlan(), output(unis[0][0])])
-                    #                    ofp.ofp_bucket(actions=[pop_vlan(), output(unis[1][0])])
-                ]
-            )
-        ))
-        stub.UpdateLogicalDeviceFlowTable(FlowTableUpdate(
-            id=logical_device_id,
-            flow_mod=mk_simple_flow_mod(
-                priority=1000,
-                match_fields=[
-                    in_port(nni_port_no),
-                    eth_type(0x800),
-                    vlan_vid(4096 + 140),
-                    ipv4_dst(0xe4020202)
-                ],
-                actions=[group(2)]
-            )
-        ))
-
-        # 3rd with empty bucket
-        stub.UpdateLogicalDeviceFlowGroupTable(FlowGroupTableUpdate(
-            id=logical_device_id,
-            group_mod=mk_multicast_group_mod(
-                group_id=3,
-                buckets=[]
-            )
-        ))
-        stub.UpdateLogicalDeviceFlowTable(FlowTableUpdate(
-            id=logical_device_id,
-            flow_mod=mk_simple_flow_mod(
-                priority=1000,
-                match_fields=[
-                    in_port(nni_port_no),
-                    eth_type(0x800),
-                    vlan_vid(4096 + 140),
-                    ipv4_dst(0xe4030303)
-                ],
-                actions=[group(3)]
-            )
-        ))
-
-        self.poutput('success')
-
-    complete_install_all_sample_flows = VolthaCli.complete_logical_device
-
-    def do_install_dhcp_flows(self, line):
-        """
-        Install all dhcp flows that are representative of the virtualized access
-        scenario in a PON network.
-        """
-        logical_device_id = line or self.default_logical_device_id
-
-        # gather NNI and UNI port IDs
-        nni_port_no, unis = self.get_logical_ports(logical_device_id)
-
-        # construct and push flow rules
-        stub = self.get_stub()
-
-        # Controller-bound flows
-        for uni_port_no, _ in unis:
-            stub.UpdateLogicalDeviceFlowTable(FlowTableUpdate(
-                id=logical_device_id,
-                flow_mod=mk_simple_flow_mod(
-                    priority=1000,
-                    match_fields=[
-                        in_port(uni_port_no),
-                        eth_type(0x800),
-                        ip_proto(17),
-                        udp_dst(67)
-                    ],
-                    actions=[output(ofp.OFPP_CONTROLLER)]
-                )
-            ))
-
-        self.poutput('success')
-
-    complete_install_dhcp_flows = VolthaCli.complete_logical_device
-
-    def do_delete_all_flows(self, line):
-        """
-        Remove all flows and flow groups from given logical device
-        """
-        logical_device_id = line or self.default_logical_device_id
-        stub = self.get_stub()
-        stub.UpdateLogicalDeviceFlowTable(FlowTableUpdate(
-            id=logical_device_id,
-            flow_mod=ofp.ofp_flow_mod(
-                command=ofp.OFPFC_DELETE,
-                table_id=ofp.OFPTT_ALL,
-                cookie_mask=0,
-                out_port=ofp.OFPP_ANY,
-                out_group=ofp.OFPG_ANY
-            )
-        ))
-        stub.UpdateLogicalDeviceFlowGroupTable(FlowGroupTableUpdate(
-            id=logical_device_id,
-            group_mod=ofp.ofp_group_mod(
-                command=ofp.OFPGC_DELETE,
-                group_id=ofp.OFPG_ALL
-            )
-        ))
-        self.poutput('success')
-
-    complete_delete_all_flows = VolthaCli.complete_logical_device
-
-    def do_send_simulated_upstream_eapol(self, line):
-        """
-        Send an EAPOL upstream from a simulated OLT
-        """
-        device_id = line or self.default_device_id
-        requests.get('http://{}/devices/{}/test_eapol_in'.format(
-            self.voltha_sim_rest, device_id
-        ))
-
-    complete_send_simulated_upstream_eapol = VolthaCli.complete_device
-
-    def do_inject_eapol_start(self, line):
-        """
-        Send out an an EAPOL start message into the given Unix interface
-        """
-        pass
-
-
-if __name__ == '__main__':
-
-    parser = argparse.ArgumentParser()
-
-    _help = '<hostname>:<port> to consul agent (default: %s)' % defs['consul']
-    parser.add_argument(
-        '-C', '--consul', action='store', default=defs['consul'], help=_help)
-
-    _help = 'Lookup Voltha endpoints based on service entries in Consul'
-    parser.add_argument(
-        '-L', '--lookup', action='store_true', help=_help)
-
-    _help = 'All requests to the Voltha gRPC service are global'
-    parser.add_argument(
-        '-G', '--global_request', action='store_true', help=_help)
-
-    _help = '<hostname>:<port> of Voltha gRPC service (default={})'.format(
-        defs['voltha_grpc_endpoint'])
-    parser.add_argument('-g', '--grpc-endpoint', action='store',
-                        default=defs['voltha_grpc_endpoint'], help=_help)
-
-    _help = '<hostname>:<port> of Voltha simulated adapter backend for ' \
-            'testing (default={})'.format(
-        defs['voltha_sim_rest_endpoint'])
-    parser.add_argument('-s', '--sim-rest-endpoint', action='store',
-                        default=defs['voltha_sim_rest_endpoint'], help=_help)
-
-    args = parser.parse_args()
-
-    if args.lookup:
-        host = args.consul.split(':')[0].strip()
-        port = int(args.consul.split(':')[1].strip())
-        consul = Consul(host=host, port=port)
-
-        _, services = consul.catalog.service('voltha-grpc')
-        if not services:
-            print('No voltha-grpc service registered in consul; exiting')
-            sys.exit(1)
-        args.grpc_endpoint = '{}:{}'.format(services[0]['ServiceAddress'],
-                                            services[0]['ServicePort'])
-
-        _, services = consul.catalog.service('voltha-sim-rest')
-        if not services:
-            print('No voltha-sim-rest service registered in consul; exiting')
-            sys.exit(1)
-        args.sim_rest_endpoint = '{}:{}'.format(services[0]['ServiceAddress'],
-                                                services[0]['ServicePort'])
-
-    c = VolthaCli(args.grpc_endpoint, args.sim_rest_endpoint,
-                  args.global_request)
-    c.poutput(banner)
-    c.load_history()
-    c.cmdloop()
-    c.save_history()
diff --git a/python/cli/omci.py b/python/cli/omci.py
deleted file mode 100755
index e1ed4b1..0000000
--- a/python/cli/omci.py
+++ /dev/null
@@ -1,356 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright 2018 the original author or authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-"""
-OpenOMCI level CLI commands
-"""
-from optparse import make_option
-from cmd2 import Cmd, options
-from datetime import datetime
-from google.protobuf.empty_pb2 import Empty
-from table import print_pb_list_as_table
-from voltha_protos import voltha_pb2
-from voltha_protos.omci_mib_db_pb2 import MibDeviceData, MibClassData, \
-    MibInstanceData
-from voltha_protos.omci_alarm_db_pb2 import AlarmDeviceData, AlarmClassData, \
-    AlarmInstanceData
-from os import linesep
-
-
-
-class OmciCli(Cmd):
-    CREATED_KEY = 'created'
-    MODIFIED_KEY = 'modified'
-    MDS_KEY = 'mib_data_sync'
-    LAST_SYNC_KEY = 'last_mib_sync'
-    VERSION_KEY = 'version'
-    DEVICE_ID_KEY = 'device_id'
-    CLASS_ID_KEY = 'class_id'
-    INSTANCE_ID_KEY = 'instance_id'
-    ATTRIBUTES_KEY = 'attributes'
-    TIME_FORMAT = '%Y%m%d-%H%M%S.%f'
-    ME_KEY = 'managed_entities'
-    MSG_TYPE_KEY = 'message_types'
-
-    MSG_TYPE_TO_NAME = {
-        4: 'Create',
-        5: 'Create Complete',
-        6: 'Delete',
-        8: 'Set',
-        9: 'Get',
-        10: 'Get Complete',
-        11: 'Get All Alarms',
-        12: 'Get All Alarms Next',
-        13: 'Mib Upload',
-        14: 'Mib Upload Next',
-        15: 'Mib Reset',
-        16: 'Alarm Notification',
-        17: 'Attribute Value Change',
-        18: 'Test',
-        19: 'Start Software Download',
-        20: 'Download Section',
-        21: 'End Software Download',
-        22: 'Activate Software',
-        23: 'Commit Software',
-        24: 'Synchronize Time',
-        25: 'Reboot',
-        26: 'Get Next',
-        27: 'Test Result',
-        28: 'Get Current Data',
-        29: 'Set Table'
-    }
-
-    def __init__(self, device_id, get_stub):
-        Cmd.__init__(self)
-        self.get_stub = get_stub
-        self.device_id = device_id
-        self.prompt = '(' + self.colorize(
-            self.colorize('omci {}'.format(device_id), 'green'),
-            'bold') + ') '
-
-    def cmdloop(self, intro=None):
-        self._cmdloop()
-
-    do_exit = Cmd.do_quit
-
-    def do_quit(self, line):
-        return self._STOP_AND_EXIT
-
-    def get_device_mib(self, device_id, depth=-1):
-        stub = self.get_stub()
-
-        try:
-            res = stub.GetMibDeviceData(voltha_pb2.ID(id=device_id),
-                                        metadata=(('get-depth', str(depth)), ))
-        except Exception as e:
-            pass
-
-        return res
-
-    def help_show_mib(self):
-        self.poutput('show_mib [-d <device-id>] [-c <class-id> [-i <instance-id>]]' +
-                     linesep + '-d: <device-id>   ONU Device ID' +
-                     linesep + '-c: <class-id>    Managed Entity Class ID' +
-                     linesep + '-i: <instance-id> ME Instance ID')
-
-    @options([
-        make_option('-d', '--device-id', action="store", dest='device_id', type='string',
-                    help='ONU Device ID', default=None),
-        make_option('-c', '--class-id', action="store", dest='class_id',
-                    type='int', help='Managed Entity Class ID', default=None),
-        make_option('-i', '--instance-id', action="store", dest='instance_id',
-                    type='int', help='ME Instance ID', default=None)
-    ])
-    def do_show_mib(self, _line, opts):
-        """
-        Show OMCI MIB Database Information
-        """
-        device_id = opts.device_id or self.device_id
-
-        if opts.class_id is not None and not 1 <= opts.class_id <= 0xFFFF:
-            self.poutput(self.colorize('Error: ', 'red') +
-                         self.colorize('Class ID must be 1..65535', 'blue'))
-            return
-
-        if opts.instance_id is not None and opts.class_id is None:
-            self.poutput(self.colorize('Error: ', 'red') +
-                         self.colorize('Class ID required if specifying an Instance ID',
-                                       'blue'))
-            return
-
-        if opts.instance_id is not None and not 0 <= opts.instance_id <= 0xFFFF:
-            self.poutput(self.colorize('Error: ', 'red') +
-                         self.colorize('Instance ID must be 0..65535', 'blue'))
-            return
-
-        try:
-            mib_db = self.get_device_mib(device_id, depth=-1)
-
-        except Exception:   # UnboundLocalError if Device ID not found in DB
-            self.poutput(self.colorize('Failed to get MIB database for ONU {}'
-                                       .format(device_id), 'red'))
-            return
-
-        mib = self._device_to_dict(mib_db)
-
-        self.poutput('OpenOMCI MIB Database for ONU {}'.format(device_id))
-
-        if opts.class_id is None and opts.instance_id is None:
-            self.poutput('Version            : {}'.format(mib[OmciCli.VERSION_KEY]))
-            self.poutput('Created            : {}'.format(mib[OmciCli.CREATED_KEY]))
-            self.poutput('Last In-Sync Time  : {}'.format(mib[OmciCli.LAST_SYNC_KEY]))
-            self.poutput('MIB Data Sync Value: {}'.format(mib[OmciCli.MDS_KEY]))
-
-        class_ids = [k for k in mib.iterkeys()
-                     if isinstance(k, int) and
-                     (opts.class_id is None or opts.class_id == k)]
-        class_ids.sort()
-
-        if len(class_ids) == 0 and opts.class_id is not None:
-            self.poutput(self.colorize('Class ID {} not found in MIB Database'
-                                       .format(opts.class_id), 'red'))
-            return
-
-        for cls_id in class_ids:
-            class_data = mib[cls_id]
-            self.poutput('  ----------------------------------------------')
-            self.poutput('  Class ID: {0} - ({0:#x})'.format(cls_id))
-
-            inst_ids = [k for k in class_data.iterkeys()
-                        if isinstance(k, int) and
-                        (opts.instance_id is None or opts.instance_id == k)]
-            inst_ids.sort()
-
-            if len(inst_ids) == 0 and opts.instance_id is not None:
-                self.poutput(self.colorize('Instance ID {} of Class ID {} not ' +
-                                           'found in MIB Database'.
-                                           format(opts.instance_id, opts.class_id),
-                                           'red'))
-                return
-
-            for inst_id in inst_ids:
-                inst_data = class_data[inst_id]
-                self.poutput('    Instance ID: {0} - ({0:#x})'.format(inst_id))
-                self.poutput('    Created    : {}'.format(inst_data[OmciCli.CREATED_KEY]))
-                self.poutput('    Modified   : {}'.format(inst_data[OmciCli.MODIFIED_KEY]))
-
-                attributes = inst_data[OmciCli.ATTRIBUTES_KEY]
-                attr_names = attributes.keys()
-                attr_names.sort()
-                max_len = max([len(attr) for attr in attr_names])
-
-                for attr in attr_names:
-                    name = self._cleanup_attribute_name(attr).ljust(max_len)
-                    value = attributes[attr]
-                    try:
-                        ivalue = int(value)
-                        self.poutput('      {0}: {1} - ({1:#x})'.format(name, ivalue))
-
-                    except ValueError:
-                        self.poutput('      {}: {}'.format(name, value))
-
-                if inst_id is not inst_ids[-1]:
-                    self.poutput(linesep)
-
-    def _cleanup_attribute_name(self, attr):
-        """Change underscore to space and capitalize first character"""
-        return ' '.join([v[0].upper() + v[1:] for v in attr.split('_')])
-
-    def _instance_to_dict(self, instance):
-        if not isinstance(instance, (MibInstanceData, AlarmInstanceData)):
-            raise TypeError('{} is not of type MIB/Alarm Instance Data'.format(type(instance)))
-
-        data = {
-            OmciCli.INSTANCE_ID_KEY: instance.instance_id,
-            OmciCli.CREATED_KEY: self._string_to_time(instance.created),
-            OmciCli.MODIFIED_KEY: self._string_to_time(instance.modified),
-            OmciCli.ATTRIBUTES_KEY: dict()
-        }
-        for attribute in instance.attributes:
-            data[OmciCli.ATTRIBUTES_KEY][attribute.name] = str(attribute.value)
-
-        return data
-
-    def _class_to_dict(self, val):
-        if not isinstance(val, (MibClassData, AlarmClassData)):
-            raise TypeError('{} is not of type MIB/Alarm Class Data'.format(type(val)))
-
-        data = {
-            OmciCli.CLASS_ID_KEY: val.class_id,
-        }
-        for instance in val.instances:
-            data[instance.instance_id] = self._instance_to_dict(instance)
-        return data
-
-    def _device_to_dict(self, val):
-        if not isinstance(val, MibDeviceData):
-            raise TypeError('{} is not of type MibDeviceData'.format(type(val)))
-
-        data = {
-            OmciCli.DEVICE_ID_KEY: val.device_id,
-            OmciCli.CREATED_KEY: self._string_to_time(val.created),
-            OmciCli.LAST_SYNC_KEY: self._string_to_time(val.last_sync_time),
-            OmciCli.MDS_KEY: val.mib_data_sync,
-            OmciCli.VERSION_KEY: val.version,
-            OmciCli.ME_KEY: dict(),
-            OmciCli.MSG_TYPE_KEY: set()
-        }
-        for class_data in val.classes:
-            data[class_data.class_id] = self._class_to_dict(class_data)
-
-        for managed_entity in val.managed_entities:
-            data[OmciCli.ME_KEY][managed_entity.class_id] = managed_entity.name
-
-        for msg_type in val.message_types:
-            data[OmciCli.MSG_TYPE_KEY].add(msg_type.message_type)
-
-        return data
-
-    def _string_to_time(self, time):
-        return datetime.strptime(time, OmciCli.TIME_FORMAT) if len(time) else None
-
-    def help_show_me(self):
-        self.poutput('show_me [-d <device-id>]' +
-                     linesep + '-d: <device-id>   ONU Device ID')
-
-    @options([
-        make_option('-d', '--device-id', action="store", dest='device_id', type='string',
-                    help='ONU Device ID', default=None),
-    ])
-    def do_show_me(self, _line, opts):
-        """ Show supported OMCI Managed Entities"""
-
-        device_id = opts.device_id or self.device_id
-
-        try:
-            mib_db = self.get_device_mib(device_id, depth=1)
-            mib = self._device_to_dict(mib_db)
-
-        except Exception:   # UnboundLocalError if Device ID not found in DB
-            self.poutput(self.colorize('Failed to get supported ME information for ONU {}'
-                                       .format(device_id), 'red'))
-            return
-
-        class_ids = [class_id for class_id in mib[OmciCli.ME_KEY].keys()]
-        class_ids.sort()
-
-        self.poutput('Supported Managed Entities for ONU {}'.format(device_id))
-        for class_id in class_ids:
-            self.poutput('    {0} - ({0:#x}): {1}'.format(class_id,
-                                                          mib[OmciCli.ME_KEY][class_id]))
-
-    def help_show_msg_types(self):
-        self.poutput('show_msg_types [-d <device-id>]' +
-                     linesep + '-d: <device-id>   ONU Device ID')
-
-    @options([
-        make_option('-d', '--device-id', action="store", dest='device_id', type='string',
-                    help='ONU Device ID', default=None),
-    ])
-    def do_show_msg_types(self, _line, opts):
-        """ Show supported OMCI Message Types"""
-        device_id = opts.device_id or self.device_id
-
-        try:
-            mib_db = self.get_device_mib(device_id, depth=1)
-            mib = self._device_to_dict(mib_db)
-
-        except Exception:   # UnboundLocalError if Device ID not found in DB
-            self.poutput(self.colorize('Failed to get supported Message Types for ONU {}'
-                                       .format(device_id), 'red'))
-            return
-
-        msg_types = [msg_type for msg_type in mib[OmciCli.MSG_TYPE_KEY]]
-        msg_types.sort()
-
-        self.poutput('Supported Message Types for ONU {}'.format(device_id))
-        for msg_type in msg_types:
-            self.poutput('    {0} - ({0:#x}): {1}'.
-                         format(msg_type,
-                                OmciCli.MSG_TYPE_TO_NAME.get(msg_type, 'Unknown')))
-
-    def get_devices(self):
-        stub = self.get_stub()
-        res = stub.ListDevices(Empty())
-        return res.items
-
-    def do_devices(self, line):
-        """List devices registered in Voltha reduced for OMCI menu"""
-        devices = self.get_devices()
-        omit_fields = {
-            'adapter',
-            'model',
-            'hardware_version',
-            'images',
-            'firmware_version',
-            'serial_number',
-            'vlan',
-            'root',
-            'extra_args',
-            'proxy_address',
-        }
-        print_pb_list_as_table('Devices:', devices, omit_fields, self.poutput)
-
-    def help_devices(self):
-        self.poutput('TODO: Provide some help')
-
-    def poutput(self, msg):
-        """Convenient shortcut for self.stdout.write(); adds newline if necessary."""
-        if msg:
-            self.stdout.write(msg)
-            if msg[-1] != '\n':
-                self.stdout.write('\n')
diff --git a/python/cli/setup.sh b/python/cli/setup.sh
deleted file mode 100755
index 6cab0bf..0000000
--- a/python/cli/setup.sh
+++ /dev/null
@@ -1,43 +0,0 @@
-#!/bin/bash
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-while getopts LGC:g:s: option
-do
-    case "${option}"
-    in
-	L) LOOKUP_OPT="-L";;
-	G) GLOBAL_REQUEST_OPT="-G";;
-	C) CONSUL_OPT="-C ${OPTARG}";;
-	g) GRPC_OPT="-g ${OPTARG}";;
-	s) SIM_OPT="-s ${OPTARG}";;
-    esac
-done
-
-if [ -z "$CONSUL_OPT" ]
-then
-    CONSUL_OPT="-C $DOCKER_HOST_IP:8500"
-fi
-
-echo "export DOCKER_HOST_IP=$DOCKER_HOST_IP" > /home/voltha/.bashrc
-echo "export PYTHONPATH=/voltha" >> /home/voltha/.bashrc
-echo "export PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin" >> /home/voltha/.bashrc
-echo "export DOCKER_HOST_IP=$DOCKER_HOST_IP" > /home/voltha/.bash_profile
-echo "export PYTHONPATH=/voltha" >> /home/voltha/.bash_profile
-echo "export PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin" >> /home/voltha/.bash_profile
-echo "/voltha/python/cli/main.py $LOOKUP_OPT $GLOBAL_REQUEST_OPT $CONSUL_OPT $GRPC_OPT $SIM_OPT" >> /home/voltha/.bash_profile
-echo "logout" >> /home/voltha/.bash_profile
-chown voltha.voltha /home/voltha/.bash_profile
-/usr/sbin/sshd -D
-
diff --git a/python/cli/table.py b/python/cli/table.py
deleted file mode 100644
index 7e6a4d8..0000000
--- a/python/cli/table.py
+++ /dev/null
@@ -1,204 +0,0 @@
-#
-# Copyright 2016 the original author or authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-import sys
-
-from google.protobuf.message import Message
-from termcolor import colored
-
-_printfn = lambda l: sys.stdout.write(l + '\n')
-
-
-class TablePrinter(object):
-    """Simple tabular data printer utility. For usage, see bottom of file"""
-
-    def __init__(self):
-        self.max_field_lengths = {}
-        self.field_names = {}
-        self.cell_values = {}
-
-    def add_cell(self, row_number, field_key, field_name, value):
-        if not isinstance(value, str):
-            value = str(value)
-        self._add_field_type(field_key, field_name)
-        row = self.cell_values.setdefault(row_number, {})
-        row[field_key] = value
-        self._update_max_length(field_key, value)
-
-    def number_of_rows(self):
-        return len(self.cell_values)
-
-    def print_table(self, header=None, printfn=_printfn, dividers=10):
-
-        if header is not None:
-            printfn(header)
-
-        field_keys = sorted(self.field_names.keys())
-
-        if not field_keys:
-            printfn('table empty')
-            return
-
-        def p_sep():
-            printfn('+' + '+'.join(
-                [(self.max_field_lengths[k] + 2) * '-'
-                 for k in field_keys]) + '+')
-
-        p_sep()
-
-        printfn('| ' + ' | '.join(
-            '%%%ds' % self.max_field_lengths[k] % self.field_names[k]
-            for k in field_keys) + ' |')
-        p_sep()
-
-        for i in range(len(self.cell_values)):
-            row = self.cell_values[i]
-            printfn(colored('| ' + ' | '.join(
-                '%%%ds' % self.max_field_lengths[k] % row.get(k, '')
-                for k in field_keys
-            ) + ' |'))
-            if not ((i + 1) % dividers):
-                p_sep()
-
-        if (i + 1) % dividers:
-            p_sep()
-
-    def _update_max_length(self, field_key, string):
-        length = len(string)
-        if length > self.max_field_lengths.get(field_key, 0):
-            self.max_field_lengths[field_key] = length
-
-    def _add_field_type(self, field_key, field_name):
-        if field_key not in self.field_names:
-            self.field_names[field_key] = field_name
-            self._update_max_length(field_key, field_name)
-        else:
-            assert self.field_names[field_key] == field_name
-
-
-def print_pb_list_as_table(header, items, fields_to_omit=None,
-                           printfn=_printfn, dividers=10, show_nulls=False,
-                           presfns={}):
-    from utils import pb2dict
-
-    t = TablePrinter()
-    for row, obj in enumerate(items):
-        assert isinstance(obj, Message)
-
-        def set_row(pd_dict, _row, field, value, t, prefix,
-                      fields_to_omit, number):
-            fname = prefix + field.name
-            if fname in fields_to_omit:
-                return
-            if isinstance(value, Message):
-                add(_row, value, fname + '.',
-                    100 * (number + field.number))
-            else:
-                presentationfn = presfns[fname] if fname in presfns else lambda x: x
-                t.add_cell(_row, number + field.number, fname,
-                           presentationfn(pd_dict.get(field.name)))
-
-        def add(_row, pb, prefix='', number=0):
-            d = pb2dict(pb)
-            if show_nulls:
-                fields = pb.DESCRIPTOR.fields
-                for field in fields:
-                    set_row(d,
-                            _row,
-                            field,
-                            getattr(pb, field.name),
-                            t,
-                            prefix,
-                            fields_to_omit,
-                            number)
-            else:
-                fields = pb.ListFields()
-                for (field, value) in fields:
-                    set_row(d,
-                            _row,
-                            field,
-                            value,
-                            t,
-                            prefix,
-                            fields_to_omit,
-                            number)
-        add(row, obj)
-
-    t.print_table(header, printfn, dividers)
-
-
-def print_pb_as_table(header, pb, fields_to_omit={}, printfn=_printfn,
-                      show_nulls=False):
-
-    from utils import pb2dict
-
-    def is_repeated_item(msg):
-        return hasattr(msg, "extend")
-
-    def set_cell(pb, field, value, t, prefix, fields_to_omit):
-        d = pb2dict(pb)
-        fname = prefix + field.name
-
-        if fname in fields_to_omit:
-            return
-        if isinstance(value, Message):
-            pr(value, fname + '.')
-        elif is_repeated_item(value): # handles any list
-            row = t.number_of_rows()
-            t.add_cell(row, 0, 'field', fname)
-            t.add_cell(row, 1, 'value',
-                       '{} item(s)'.format(len(d.get(field.name))))
-        else:
-            row = t.number_of_rows()
-            t.add_cell(row, 0, 'field', fname)
-            t.add_cell(row, 1, 'value', value)
-
-
-    t = TablePrinter()
-
-    def pr(_pb, prefix=''):
-        if show_nulls:
-            fields = _pb.DESCRIPTOR.fields
-            for field in sorted(fields, key=lambda f: f.number):
-                set_cell(_pb,
-                        field,
-                        getattr(_pb, field.name),
-                        t,
-                        prefix,
-                        fields_to_omit)
-        else:
-            fields = _pb.ListFields()
-            for (field, value) in sorted(fields, key=lambda (f, v): f.number):
-                set_cell(_pb,
-                        field,
-                        value,
-                        t,
-                        prefix,
-                        fields_to_omit)
-
-    pr(pb)
-
-    t.print_table(header, printfn)
-
-
-if __name__ == '__main__':
-    import random
-
-    t = TablePrinter()
-    for row in range(10):
-        t.add_cell(row, 0, 'id', row + 100)
-        t.add_cell(row, 1, 'name', 'Joe Somebody')
-        t.add_cell(row, 2, 'ows', '${}'.format(random.randint(10, 100000)))
-    t.print_table()
diff --git a/python/cli/utils.py b/python/cli/utils.py
deleted file mode 100644
index 7668b7c..0000000
--- a/python/cli/utils.py
+++ /dev/null
@@ -1,213 +0,0 @@
-#
-# Copyright 2016 the original author or authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-import sys
-
-from google.protobuf.json_format import MessageToDict
-from termcolor import cprint, colored
-
-from table import TablePrinter
-
-
-_printfn = lambda l: sys.stdout.write(l + '\n')
-
-
-def pb2dict(pb_msg):
-    d = MessageToDict(pb_msg, including_default_value_fields=1,
-                      preserving_proto_field_name=1)
-    return d
-
-
-def p_cookie(cookie):
-    cookie =  '%x' % int(cookie)
-    if len(cookie) > 8:
-        return '~' + cookie[len(cookie)-8:]
-    else:
-        return cookie
-
-'''
-    OFPP_NORMAL     = 0x7ffffffa;  /* Forward using non-OpenFlow pipeline. */
-    OFPP_FLOOD      = 0x7ffffffb;  /* Flood using non-OpenFlow pipeline. */
-    OFPP_ALL        = 0x7ffffffc;  /* All standard ports except input port. */
-    OFPP_CONTROLLER = 0x7ffffffd;  /* Send to controller. */
-    OFPP_LOCAL      = 0x7ffffffe;  /* Local openflow "port". */
-    OFPP_ANY        = 0x7fffffff;  /* Special value used in some requests when
-'''
-
-
-def p_port(port):
-    if port & 0x7fffffff == 0x7ffffffa:
-        return 'NORMAL'
-    elif port & 0x7fffffff == 0x7ffffffb:
-        return 'FLOOD'
-    elif port & 0x7fffffff == 0x7ffffffc:
-        return 'ALL'
-    elif port & 0x7fffffff == 0x7ffffffd:
-        return 'CONTROLLER'
-    elif port & 0x7fffffff == 0x7ffffffe:
-        return 'LOCAL'
-    elif port & 0x7fffffff == 0x7fffffff:
-        return 'ANY'
-    else:
-        return str(port)
-
-
-def p_vlan_vid(vlan_vid):
-    if vlan_vid == 0:
-        return 'untagged'
-    assert vlan_vid & 4096 == 4096
-    return str(vlan_vid - 4096)
-
-
-def p_ipv4(x):
-    return '.'.join(str(v) for v in [
-        (x >> 24) & 0xff, (x >> 16) & 0xff, (x >> 8) & 0xff, x & 0xff
-    ])
-
-
-field_printers = {
-    'IN_PORT': lambda f: (100, 'in_port', p_port(f['port'])),
-    'VLAN_VID': lambda f: (101, 'vlan_vid', p_vlan_vid(f['vlan_vid'])),
-    'VLAN_PCP': lambda f: (102, 'vlan_pcp', str(f['vlan_pcp'])),
-    'ETH_TYPE': lambda f: (103, 'eth_type', '%X' % f['eth_type']),
-    'IP_PROTO': lambda f: (104, 'ip_proto', str(f['ip_proto'])),
-    'IPV4_DST': lambda f: (105, 'ipv4_dst', p_ipv4(f['ipv4_dst'])),
-    'UDP_SRC': lambda f: (106, 'udp_src', str(f['udp_src'])),
-    'UDP_DST': lambda f: (107, 'udp_dst', str(f['udp_dst'])),
-    'TCP_SRC': lambda f: (108, 'tcp_src', str(f['tcp_src'])),
-    'TCP_DST': lambda f: (109, 'tcp_dst', str(f['tcp_dst'])),
-    'METADATA': lambda f: (110, 'metadata', str(f['table_metadata'])),
-    'TUNNEL_ID': lambda f: (111, 'tunnel_id', str(f['tunnel_id'])),
-}
-
-
-def p_field(field):
-    assert field['oxm_class'].endswith('OPENFLOW_BASIC')
-    ofb = field['ofb_field']
-    assert not ofb['has_mask']
-    type = ofb['type'][len('OFPXMT_OFB_'):]
-    weight, field_name, value = field_printers[type](ofb)
-    return 1000 + weight, 'set_' + field_name, value
-
-
-action_printers = {
-    'SET_FIELD': lambda a: p_field(a['set_field']['field']),
-    'POP_VLAN': lambda a: (2000, 'pop_vlan', 'Yes'),
-    'PUSH_VLAN': lambda a: (2001, 'push_vlan', '%x' % a['push']['ethertype']),
-    'GROUP': lambda a: (3000, 'group', p_port(a['group']['group_id'])),
-    'OUTPUT': lambda a: (4000, 'output', p_port(a['output']['port'])),
-}
-
-
-def print_flows(what, id, type, flows, groups, printfn=_printfn):
-
-    header = ''.join([
-        '{} '.format(what),
-        colored(id, color='green', attrs=['bold']),
-        ' (type: ',
-        colored(type, color='blue'),
-        ')'
-    ]) + '\nFlows ({}):'.format(len(flows))
-
-    table = TablePrinter()
-    for i, flow in enumerate(flows):
-
-        table.add_cell(i, 0, 'table_id', value=str(flow['table_id']))
-        table.add_cell(i, 1, 'priority', value=str(flow['priority']))
-        table.add_cell(i, 2, 'cookie', p_cookie(flow['cookie']))
-
-        assert flow['match']['type'] == 'OFPMT_OXM'
-        for field in flow['match']['oxm_fields']:
-            assert field['oxm_class'].endswith('OPENFLOW_BASIC')
-            ofb = field['ofb_field']
-            # see CORD-816 (https://jira.opencord.org/browse/CORD-816)
-            assert not ofb['has_mask'], 'masked match not handled yet'
-            type = ofb['type'][len('OFPXMT_OFB_'):]
-            table.add_cell(i, *field_printers[type](ofb))
-
-        for instruction in flow['instructions']:
-            itype = instruction['type']
-            if itype == 4 or itype == 3:
-                for action in instruction['actions']['actions']:
-                    atype = action['type'][len('OFPAT_'):]
-                    table.add_cell(i, *action_printers[atype](action))
-            elif itype == 1:
-                table.add_cell(i, 10000, 'goto-table',
-                               instruction['goto_table']['table_id'])
-            elif itype == 2:
-                table.add_cell(i, 10001, 'write-metadata',
-                               instruction['write_metadata']['metadata'])
-            elif itype == 5:
-                table.add_cell(i, 10002, 'clear-actions', [])
-            elif itype == 6:
-                table.add_cell(i, 10003, 'meter',
-                               instruction['meter']['meter_id'])
-            else:
-                raise NotImplementedError(
-                    'not handling instruction type {}'.format(itype))
-
-    table.print_table(header, printfn)
-
-
-def print_groups(what, id, type, groups, printfn=_printfn):
-    header = ''.join([
-        '{} '.format(what),
-        colored(id, color='green', attrs=['bold']),
-        ' (type: ',
-        colored(type, color='blue'),
-        ')'
-    ]) + '\nGroups ({}):'.format(len(groups))
-
-    table = TablePrinter()
-    for i, group in enumerate(groups):
-        output_ports = []
-        for bucket in group['desc']['buckets']:
-            for action in bucket['actions']:
-                if action['type'] == 'OFPAT_OUTPUT':
-                   output_ports.append(action['output']['port'])
-        table.add_cell(i, 0, 'group_id', value=str(group['desc']['group_id']))
-        table.add_cell(i, 1, 'buckets', value=str(dict(output=output_ports)))
-
-    table.print_table(header, printfn)
-
-def print_meters(what, id, type, meters, printfn=_printfn):
-    header = ''.join([
-        '{} '.format(what),
-        colored(id, color='green', attrs=['bold']),
-        ' (type: ',
-        colored(type, color='blue'),
-        ')'
-    ]) + '\nMeters ({}):'.format(len(meters))
-
-    table = TablePrinter()
-    for i, meter in enumerate(meters):
-        bands = []
-        for meter_band in meter['config']['bands']:
-            bands.append(meter_band)
-        table.add_cell(i, 0, 'meter_id', value=str(meter['config']['meter_id']))
-        table.add_cell(i, 1, 'meter_bands', value=str(dict(bands=bands)))
-
-    table.print_table(header, printfn)
-
-
-def dict2line(d):
-    assert isinstance(d, dict)
-    return ', '.join('{}: {}'.format(k, v) for k, v in sorted(d.items()))
-
-def enum2name(msg_obj, enum_type, enum_value):
-    descriptor = msg_obj.DESCRIPTOR.enum_types_by_name[enum_type]
-    name = descriptor.values_by_number[enum_value].name
-    return name
diff --git a/python/docker/Dockerfile.cli b/python/docker/Dockerfile.cli
deleted file mode 100644
index b00420a..0000000
--- a/python/docker/Dockerfile.cli
+++ /dev/null
@@ -1,80 +0,0 @@
-# Copyright 2016 the original author or authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-FROM voltha/voltha-python-base:1.0.0
-
-# Update to have latest images
-RUN apt-get update && \
-    apt-get install -y --no-install-recommends \
-	openssh-server=1:7.2p2-4ubuntu2.8 \
-        && apt-get clean && rm -rf /var/lib/apt/lists/*
-
-# Install adapter requirements.
-COPY requirements.txt /tmp/requirements.txt
-RUN pip install -r /tmp/requirements.txt
-
-ARG LOCAL_PYVOLTHA
-ARG LOCAL_PROTOS
-COPY local_imports/ /local_imports/
-RUN if [ -n "$LOCAL_PYVOLTHA" ] ; then \
-    PYVOLTHA_PATH=$(ls /local_imports/pyvoltha/dist/) ; \
-    printf "/local_imports/pyvoltha/dist/%s\npyvoltha" "$PYVOLTHA_PATH" > pyvoltha-install.txt ; \
-    pip install -r pyvoltha-install.txt ; \
-fi
-
-RUN if [ -n "$LOCAL_PROTOS" ] ; then \
-    PROTOS_PATH=$(ls /local_imports/voltha-protos/dist/) ; \
-    printf "/local_imports/voltha-protos/dist/%s\nvoltha-protos" "$PROTOS_PATH" > protos-install.txt ; \
-    pip install -r protos-install.txt ; \
- fi
-# Bundle app source
-RUN mkdir /voltha && touch /voltha/__init__.py
-ENV PYTHONPATH=/voltha
-COPY cli /voltha/python/cli
-RUN touch /voltha/python/__init__.py
-RUN touch /voltha/python/cli/__init__.py
-
-# Setup the voltha user
-SHELL ["/bin/bash", "-o", "pipefail", "-c"]
-RUN useradd -b /home -d /home/voltha voltha -s /bin/bash
-RUN mkdir /home/voltha
-RUN chown voltha.voltha /home/voltha
-RUN echo "voltha:admin" | chpasswd
-RUN mkdir /var/run/sshd
-RUN echo 'root:screencast' | chpasswd
-RUN sed -i 's/PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config
-
-# SSH login fix. Otherwise user is kicked off after login
-RUN sed 's@session\s*required\s*pam_loginuid.so@session optional pam_loginuid.so@g' -i /etc/pam.d/sshd
-
-ENV NOTVISIBLE "in users profile"
-RUN echo "export VISIBLE=now" >> /etc/profile
-
-EXPOSE 22
-
-CMD ["/voltha/python/cli/setup.sh"]
-
-# Label image
-ARG org_label_schema_version=unknown
-ARG org_label_schema_vcs_url=unknown
-ARG org_label_schema_vcs_ref=unknown
-ARG org_label_schema_build_date=unknown
-ARG org_opencord_vcs_commit_date=unknown
-
-LABEL org.label-schema.schema-version=1.0 \
-      org.label-schema.name=voltha-cli \
-      org.label-schema.version=$org_label_schema_version \
-      org.label-schema.vcs-url=$org_label_schema_vcs_url \
-      org.label-schema.vcs-ref=$org_label_schema_vcs_ref \
-      org.label-schema.build-date=$org_label_schema_build_date \
-      org.opencord.vcs-commit-date=$org_opencord_vcs_commit_date
diff --git a/python/docker/Dockerfile.ofagent b/python/docker/Dockerfile.ofagent
deleted file mode 100644
index 73e8789..0000000
--- a/python/docker/Dockerfile.ofagent
+++ /dev/null
@@ -1,56 +0,0 @@
-# Copyright 2016 the original author or authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-FROM voltha/voltha-python-base:1.0.0
-
-# Install adapter requirements.
-COPY requirements.txt /tmp/requirements.txt
-RUN pip install -r /tmp/requirements.txt
-
-ARG LOCAL_PYVOLTHA
-ARG LOCAL_PROTOS
-COPY local_imports/ /local_imports/
-RUN if [ -n "$LOCAL_PYVOLTHA" ] ; then \
-    PYVOLTHA_PATH=$(ls /local_imports/pyvoltha/dist/) ; \
-    printf "/local_imports/pyvoltha/dist/%s\npyvoltha" "$PYVOLTHA_PATH" > pyvoltha-install.txt ; \
-    pip install -r pyvoltha-install.txt ; \
-fi
-
-RUN if [ -n "$LOCAL_PROTOS" ] ; then \
-    PROTOS_PATH=$(ls /local_imports/voltha-protos/dist/) ; \
-    printf "/local_imports/voltha-protos/dist/%s\nvoltha-protos" "$PROTOS_PATH" > protos-install.txt ; \
-    pip install -r protos-install.txt ; \
- fi
-
-# Bundle app source
-RUN mkdir /ofagent  && \
-        touch   /ofagent/__init__.py
-
-ENV PYTHONPATH=/ofagent
-COPY ofagent /ofagent/ofagent
-COPY pki /ofagent/pki
-
-# Label image
-ARG org_label_schema_version=unknown
-ARG org_label_schema_vcs_url=unknown
-ARG org_label_schema_vcs_ref=unknown
-ARG org_label_schema_build_date=unknown
-ARG org_opencord_vcs_commit_date=unknown
-
-LABEL org.label-schema.schema-version=1.0 \
-      org.label-schema.name=voltha-ofagent \
-      org.label-schema.version=$org_label_schema_version \
-      org.label-schema.vcs-url=$org_label_schema_vcs_url \
-      org.label-schema.vcs-ref=$org_label_schema_vcs_ref \
-      org.label-schema.build-date=$org_label_schema_build_date \
-      org.opencord.vcs-commit-date=$org_opencord_vcs_commit_date
diff --git a/python/env.sh b/python/env.sh
deleted file mode 100644
index c9a6245..0000000
--- a/python/env.sh
+++ /dev/null
@@ -1,22 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# sourcing this file is needed to make local development and integration testing work
-
-# load local python virtualenv if exists
-VENVDIR="venv-volthago"
-if [ -e "$VENVDIR/bin/activate" ]; then
-    . $VENVDIR/bin/activate
-else
-   echo "Run 'make venv' to setup python development environment"
-fi
diff --git a/python/ofagent/__init__.py b/python/ofagent/__init__.py
deleted file mode 100755
index b0fb0b2..0000000
--- a/python/ofagent/__init__.py
+++ /dev/null
@@ -1,13 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
diff --git a/python/ofagent/agent.py b/python/ofagent/agent.py
deleted file mode 100755
index e4d415d..0000000
--- a/python/ofagent/agent.py
+++ /dev/null
@@ -1,205 +0,0 @@
-#
-# Copyright 2017 the original author or authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-import sys
-
-import structlog
-import os.path
-from twisted.internet import protocol, reactor, ssl
-from twisted.internet.defer import Deferred, inlineCallbacks
-
-import loxi.of13 as of13
-from pyvoltha.common.utils.asleep import asleep
-from of_connection import OpenFlowConnection
-from of_protocol_handler import OpenFlowProtocolHandler
-
-log = structlog.get_logger()
-
-
-class Agent(protocol.ClientFactory):
-
-    generation_is_defined = False
-    cached_generation_id = None
-
-    def __init__(self,
-                 connection_manager,
-                 controller_endpoint,
-                 datapath_id,
-                 device_id,
-                 enable_tls=False,
-                 key_file=None,
-                 cert_file=None,
-                 conn_retry_interval=1):
-
-        self.controller_endpoint = controller_endpoint
-        self.datapath_id = datapath_id
-        self.device_id = device_id
-        self.connection_manager = connection_manager
-        self.enable_tls = enable_tls
-        self.key_file = key_file
-        self.cert_file = cert_file
-        self.retry_interval = conn_retry_interval
-
-        self.running = False
-        self.connector = None # will be a Connector instance once connected
-        self.d_disconnected = None  # a deferred to signal reconnect loop when
-                                    # TCP connection is lost
-        self.connected = False
-        self.exiting = False
-        self.proto_handler = None
-
-    def get_device_id(self):
-        return self.device_id
-
-    def start(self):
-        log.debug('starting')
-        if self.running:
-            return
-        self.running = True
-        reactor.callLater(0, self.keep_connected)
-        log.info('started')
-        return self
-
-    def stop(self):
-        log.debug('stopping')
-        self.connected = False
-        self.exiting = True
-        self.connector.disconnect()
-        log.info('stopped')
-
-    def resolve_endpoint(self, endpoint):
-        # enable optional resolution via consul;
-        # see https://jira.opencord.org/browse/CORD-820
-        host, port = endpoint.split(':', 2)
-        return host, int(port)
-
-    @inlineCallbacks
-    def keep_connected(self):
-        """Keep reconnecting to the controller"""
-        while not self.exiting:
-            host, port = self.resolve_endpoint(self.controller_endpoint)
-            log.info('connecting', host=host, port=port)
-            if self.enable_tls:
-                try:
-                    # Check that key_file and cert_file is provided and
-                    # the files exist
-                    if self.key_file is None or             \
-                       self.cert_file is None or            \
-                       not os.path.isfile(self.key_file) or \
-                       not os.path.isfile(self.cert_file):
-                        raise Exception('key_file "{}" or cert_file "{}"'
-                                        ' is not found'.
-                                         format(self.key_file, self.cert_file))
-                    with open(self.key_file) as keyFile:
-                        with open(self.cert_file) as certFile:
-                            clientCert = ssl.PrivateCertificate.loadPEM(
-                                keyFile.read() + certFile.read())
-
-                    ctx = clientCert.options()
-                    self.connector = reactor.connectSSL(host, port, self, ctx)
-                    log.info('tls-enabled')
-
-                except Exception as e:
-                    log.exception('failed-to-connect', reason=e)
-            else:
-                self.connector = reactor.connectTCP(host, port, self)
-                log.info('tls-disabled')
-
-            self.d_disconnected = Deferred()
-            yield self.d_disconnected
-            log.debug('reconnect', after_delay=self.retry_interval)
-            yield asleep(self.retry_interval)
-
-    def enter_disconnected(self, event, reason):
-        """Internally signal entering disconnected state"""
-        self.connected = False
-        if not self.exiting:
-            log.error(event, reason=reason)
-            self.d_disconnected.callback(None)
-
-    def enter_connected(self):
-        """Handle transitioning from disconnected to connected state"""
-        log.info('connected')
-        self.connected = True
-        self.read_buffer = None
-        reactor.callLater(0, self.proto_handler.start)
-
-    # protocol.ClientFactory methods
-
-    def protocol(self):
-        cxn = OpenFlowConnection(self)  # Low level message handler
-        self.proto_handler = OpenFlowProtocolHandler(
-            self.datapath_id, self.device_id, self, cxn)
-        return cxn
-
-    def clientConnectionFailed(self, connector, reason):
-        self.enter_disconnected('connection-failed', reason)
-
-    def clientConnectionLost(self, connector, reason):
-        if not self.exiting:
-            log.error('client-connection-lost',
-                      reason=reason, connector=connector)
-
-    def forward_packet_in(self, ofp_packet_in):
-        if self.proto_handler is not None:
-            self.proto_handler.forward_packet_in(ofp_packet_in)
-
-    def forward_change_event(self, event):
-        # assert isinstance(event, ChangeEvent)
-        log.info('got-change-event', change_event=event)
-        if event.HasField("port_status"):
-            if self.proto_handler is not None:
-                self.proto_handler.forward_port_status(event.port_status)
-        else:
-            log.error('unknown-change-event', change_event=event)
-
-if __name__ == '__main__':
-    """Run this to test the agent for N concurrent sessions:
-       python agent [<number-of-desired-instances>]
-    """
-
-    n = 1 if len(sys.argv) < 2 else int(sys.argv[1])
-
-    from utils import mac_str_to_tuple
-
-    class MockRpc(object):
-        @staticmethod
-        def get_port_list(_):
-            ports = []
-            cap = of13.OFPPF_1GB_FD | of13.OFPPF_FIBER
-            for pno, mac, nam, cur, adv, sup, spe in (
-                    (1, '00:00:00:00:00:01', 'onu1', cap, cap, cap,
-                     of13.OFPPF_1GB_FD),
-                    (2, '00:00:00:00:00:02', 'onu2', cap, cap, cap,
-                     of13.OFPPF_1GB_FD),
-                    (129, '00:00:00:00:00:81', 'olt', cap, cap, cap,
-                     of13.OFPPF_1GB_FD)
-            ):
-                port = of13.common.port_desc(pno, mac_str_to_tuple(mac), nam,
-                                             curr=cur, advertised=adv,
-                                             supported=sup,
-                                             curr_speed=spe, max_speed=spe)
-                ports.append(port)
-            return ports
-
-    stub = MockRpc()
-    agents = [Agent('localhost:6653', 256 + i, stub).start() for i in range(n)]
-
-    def shutdown():
-        [a.stop() for a in agents]
-
-    reactor.addSystemEventTrigger('before', 'shutdown', shutdown)
-    reactor.run()
diff --git a/python/ofagent/connection_mgr.py b/python/ofagent/connection_mgr.py
deleted file mode 100755
index 9c64854..0000000
--- a/python/ofagent/connection_mgr.py
+++ /dev/null
@@ -1,349 +0,0 @@
-#
-# Copyright 2017 the original author or authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-import os
-
-import sys
-
-from twisted.internet import reactor
-from twisted.internet.defer import Deferred, inlineCallbacks, returnValue
-
-from pyvoltha.common.utils.asleep import asleep
-from pyvoltha.common.utils.consulhelpers import get_endpoint_from_consul
-from structlog import get_logger
-import grpc
-from grpc import StatusCode
-from grpc._channel import _Rendezvous
-from voltha_protos.voltha_pb2 import OfAgentSubscriber
-from grpc_client import GrpcClient
-
-from agent import Agent
-from pyvoltha.common.utils.dockerhelpers import get_my_containers_name
-
-
-log = get_logger()
-# _ = third_party
-
-class ConnectionManager(object):
-    def __init__(self, consul_endpoint,
-                 vcore_endpoint, vcore_grpc_timeout, vcore_binding_key,
-                 vcore_transaction_key, controller_endpoints, instance_id,
-                 enable_tls=False, key_file=None, cert_file=None,
-                 vcore_retry_interval=0.5, devices_refresh_interval=5,
-                 subscription_refresh_interval=5):
-
-        log.info('init-connection-manager')
-        log.info('list-of-controllers', controller_endpoints=controller_endpoints)
-        self.controller_endpoints = controller_endpoints
-        self.consul_endpoint = consul_endpoint
-        self.vcore_endpoint = vcore_endpoint
-        self.grpc_timeout = vcore_grpc_timeout
-        self.core_binding_key = vcore_binding_key
-        self.core_transaction_key = vcore_transaction_key
-        self.instance_id = instance_id
-        self.enable_tls = enable_tls
-        self.key_file = key_file
-        self.cert_file = cert_file
-
-        self.channel = None
-        self.grpc_client = None  # single, shared gRPC client to vcore
-
-        self.agent_map = {}  # (datapath_id, controller_endpoint) -> Agent()
-        self.device_id_to_datapath_id_map = {}
-
-        self.vcore_retry_interval = vcore_retry_interval
-        self.devices_refresh_interval = devices_refresh_interval
-        self.subscription_refresh_interval = subscription_refresh_interval
-        self.subscription = None
-        self.connecting = True
-        self.monitor = True
-
-        self.running = False
-
-    def start(self):
-
-        if self.running:
-            return
-
-        log.debug('starting')
-
-        self.running = True
-
-        # Get a subscription to vcore
-        reactor.callInThread(self.get_vcore_subscription)
-
-        # Start monitoring logical devices and manage agents accordingly
-        reactor.callLater(0, self.monitor_logical_devices)
-
-        log.info('started')
-
-        return self
-
-    def grpc_client_terminated(self):
-        if not self.connecting and self.grpc_client is not None:
-            self.connecting = True
-            self._reset_grpc_attributes()
-            self.delete_all_agents()
-            reactor.callInThread(self.get_vcore_subscription)
-
-    def liveness_probe(self):
-        return self.running
-
-    def readiness_probe(self):
-        # Pod is isolated when readiness condition fails
-        return bool(not self.connecting and self.channel and self.subscription and self.grpc_client)
-
-    def stop(self):
-        log.debug('stopping')
-        self.delete_all_agents()
-        self._reset_grpc_attributes()
-        self.running = False
-        log.info('stopped')
-
-    def resolve_endpoint(self, endpoint):
-        ip_port_endpoint = endpoint
-        if endpoint.startswith('@'):
-            try:
-                ip_port_endpoint = get_endpoint_from_consul(
-                    self.consul_endpoint, endpoint[1:])
-                log.info(
-                    '{}-service-endpoint-found'.format(endpoint), address=ip_port_endpoint)
-            except Exception as e:
-                log.error('{}-service-endpoint-not-found'.format(endpoint), exception=repr(e))
-                log.error('committing-suicide')
-                # Committing suicide in order to let docker restart ofagent
-                os.system("kill -15 {}".format(os.getpid()))
-        if ip_port_endpoint:
-            host, port = ip_port_endpoint.split(':', 2)
-            return host, int(port)
-
-    def _reset_grpc_attributes(self):
-        log.debug('start-reset-grpc-attributes')
-
-        if self.grpc_client is not None:
-            self.grpc_client.stop()
-
-        if self.channel is not None:
-            del self.channel
-
-        self.channel = None
-        self.subscription = None
-        self.grpc_client = None
-
-        log.debug('stop-reset-grpc-attributes')
-
-    def _assign_grpc_attributes(self):
-        log.debug('start-assign-grpc-attributes')
-
-        host, port = self.resolve_endpoint(self.vcore_endpoint)
-        log.info('revolved-vcore-endpoint', endpoint=self.vcore_endpoint, host=host, port=port)
-
-        assert host is not None
-        assert port is not None
-
-        # Establish a connection to the vcore GRPC server
-        self.channel = grpc.insecure_channel('{}:{}'.format(host, port))
-
-        log.debug('stop-assign-grpc-attributes')
-
-    @inlineCallbacks
-    def get_vcore_subscription(self):
-        log.debug('start-get-vcore-subscription')
-
-        self.connecting = True
-        while self.running and self.subscription is None:
-            try:
-                # If a subscription is not yet assigned then establish new GRPC connection
-                # ... otherwise keep using existing connection details
-                if self.subscription is None:
-                    self._assign_grpc_attributes()
-
-                # Send subscription request to register the current ofagent instance
-                container_name = self.instance_id
-                if self.grpc_client is None:
-                    self.grpc_client = GrpcClient(self, self.channel, self.grpc_timeout,
-                                                  self.core_binding_key, self.core_transaction_key)
-                subscription = yield self.grpc_client.subscribe(
-                    OfAgentSubscriber(ofagent_id=container_name))
-
-                # If the subscriber id matches the current instance
-                # ... then the subscription has succeeded
-                if subscription is not None and subscription.ofagent_id == container_name:
-                    if self.subscription is None:
-                        # Keep details on the current GRPC session and subscription
-                        log.debug('subscription-with-vcore-successful', subscription=subscription)
-                        self.subscription = subscription
-                        self.grpc_client.start()
-                        self.connecting = False
-
-                    # Sleep a bit in between each subscribe
-                    yield asleep(self.subscription_refresh_interval)
-
-                    # Move on to next subscribe request
-                    continue
-
-                # The subscription did not succeed, reset and move on
-                else:
-                    log.info('subscription-with-vcore-unavailable', subscription=subscription)
-
-            except _Rendezvous, e:
-                log.error('subscription-with-vcore-terminated',exception=e, status=e.code())
-
-            except Exception as e:
-                log.exception('unexpected-subscription-termination-with-vcore', e=e)
-
-            # Reset grpc details
-            # The vcore instance is either not available for subscription
-            # or a failure occurred with the existing communication.
-            self._reset_grpc_attributes()
-
-            # Sleep for a short period and retry
-            yield asleep(self.vcore_retry_interval)
-
-        log.debug('stop-get-vcore-subscription')
-
-    def get_rpc_client(self):
-        return self.grpc_client if not self.connecting else None
-
-    @inlineCallbacks
-    def get_list_of_logical_devices_from_voltha(self):
-        while self.running:
-            log.info('retrieve-logical-device-list')
-            rpc = self.get_rpc_client()
-            if rpc is not None:
-                try:
-                    devices = yield rpc.list_logical_devices()
-
-                    for device in devices:
-                        log.info("logical-device-entry", id=device.id,
-                                 datapath_id=device.datapath_id)
-
-                    returnValue(devices)
-
-                except _Rendezvous, e:
-                    rpc.stop()
-                    status = e.code()
-                    log.error('vcore-communication-failure', exception=e, status=status)
-
-                except Exception as e:
-                    rpc.stop()
-                    log.exception('logical-devices-retrieval-failure', exception=e)
-
-            log.info('reconnect', after_delay=self.vcore_retry_interval)
-            yield asleep(self.vcore_retry_interval)
-
-    def refresh_agent_connections(self, devices):
-        """
-        Based on the new device list, update the following state in the class:
-        * agent_map
-        * datapath_map
-        * device_id_map
-        :param devices: full device list freshly received from Voltha
-        :return: None
-        """
-
-        # Use datapath ids for deciding what's new and what's obsolete
-        desired_datapath_ids = set(d.datapath_id for d in devices)
-        current_datapath_ids = set(datapath_ids[0] for datapath_ids in self.agent_map.iterkeys())
-
-        # if identical, nothing to do
-        if desired_datapath_ids == current_datapath_ids:
-            return
-
-        # ... otherwise calculate differences
-        to_add = desired_datapath_ids.difference(current_datapath_ids)
-        to_del = current_datapath_ids.difference(desired_datapath_ids)
-
-        # remove what we don't need
-        for datapath_id in to_del:
-            self.delete_agent(datapath_id)
-
-        # start new agents as needed
-        for device in devices:
-            if device.datapath_id in to_add:
-                self.create_agent(device)
-
-        log.debug('updated-agent-list', count=len(self.agent_map))
-        log.debug('updated-device-id-to-datapath-id-map',
-                  map=str(self.device_id_to_datapath_id_map))
-
-    def create_agent(self, device):
-        datapath_id = device.datapath_id
-        device_id = device.id
-        for controller_endpoint in self.controller_endpoints:
-            agent = Agent(self, controller_endpoint, datapath_id,
-                          device_id, self.enable_tls,
-                          self.key_file, self.cert_file)
-            agent.start()
-            self.agent_map[(datapath_id,controller_endpoint)] = agent
-            self.device_id_to_datapath_id_map[device_id] = datapath_id
-
-    def delete_all_agents(self):
-        for agent in self.agent_map.itervalues(): agent.stop()
-        self.agent_map = {}
-        self.device_id_to_datapath_id_map = {}
-
-    def delete_agent(self, datapath_id):
-        for controller_endpoint in self.controller_endpoints:
-            agent = self.agent_map[(datapath_id,controller_endpoint)]
-            device_id = agent.get_device_id()
-            agent.stop()
-            del self.agent_map[(datapath_id,controller_endpoint)]
-            del self.device_id_to_datapath_id_map[device_id]
-
-    @inlineCallbacks
-    def monitor_logical_devices(self):
-        log.debug('start-monitor-logical-devices')
-
-        while self.running:
-            log.info('monitoring-logical-devices')
-
-            # should change to a gRPC streaming call
-            # see https://jira.opencord.org/browse/CORD-821
-
-            try:
-                if self.channel is not None and self.get_rpc_client() is not None and self.subscription is not None:
-                    # get current list from Voltha
-                    devices = yield  self.get_list_of_logical_devices_from_voltha()
-
-                    # update agent list and mapping tables as needed
-                    self.refresh_agent_connections(devices)
-                else:
-                    log.info('vcore-communication-unavailable')
-
-                # wait before next poll
-                yield asleep(self.devices_refresh_interval)
-
-            except _Rendezvous, e:
-                log.error('vcore-communication-failure', exception=repr(e), status=e.code())
-
-            except Exception as e:
-                log.exception('unexpected-vcore-communication-failure', exception=repr(e))
-
-        log.debug('stop-monitor-logical-devices')
-
-    def forward_packet_in(self, device_id, ofp_packet_in):
-        datapath_id = self.device_id_to_datapath_id_map.get(device_id, None)
-        if datapath_id:
-            for controller_endpoint in self.controller_endpoints:
-                agent = self.agent_map[(datapath_id, controller_endpoint)]
-                agent.forward_packet_in(ofp_packet_in)
-
-    def forward_change_event(self, device_id, event):
-        datapath_id = self.device_id_to_datapath_id_map.get(device_id, None)
-        if datapath_id:
-            for controller_endpoint in self.controller_endpoints:
-                agent = self.agent_map[(datapath_id, controller_endpoint)]
-                agent.forward_change_event(event)
diff --git a/python/ofagent/converter.py b/python/ofagent/converter.py
deleted file mode 100755
index 6280331..0000000
--- a/python/ofagent/converter.py
+++ /dev/null
@@ -1,598 +0,0 @@
-#
-# Copyright 2017 the original author or authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-"""
-Convert loxi objects to openflow_13 messages and back.
-"""
-from copy import copy
-
-from google.protobuf.descriptor import FieldDescriptor
-
-import loxi.of13 as of13
-from protobuf_to_dict import protobuf_to_dict, TYPE_CALLABLE_MAP
-from voltha_protos import openflow_13_pb2 as pb2
-
-
-type_callable_map = copy(TYPE_CALLABLE_MAP)
-type_callable_map.update({
-    FieldDescriptor.TYPE_STRING: str
-})
-
-def pb2dict(pb):
-    """
-    Convert protobuf to a dict of values good for instantiating
-    loxi objects (or any other objects). We specialize the protobuf_to_dict
-    library call with our modified decoders.
-    :param pb: protobuf as loaded into Python
-    :return: dict of values
-    """
-    return protobuf_to_dict(pb, type_callable_map)
-
-def to_loxi(grpc_object):
-    cls = grpc_object.__class__
-    converter = to_loxi_converters[cls.__name__]
-    return converter(grpc_object)
-
-def to_grpc(loxi_object):
-    cls = loxi_object.__class__
-    converter = to_grpc_converters[cls]
-    return converter(loxi_object)
-
-def ofp_port_to_loxi_port_desc(pb):
-    kw = pb2dict(pb)
-    return of13.common.port_desc(**kw)
-
-def ofp_port_status_to_loxi_port_status(pb):
-    return of13.message.port_status(
-        reason=pb.reason,
-        desc=ofp_port_to_loxi_port_desc(pb.desc)
-    )
-
-def ofp_port_stats_to_loxi_port_stats(pb):
-    kw = pb2dict(pb)
-    return of13.port_stats_entry(**kw)
-
-
-def ofp_meter_stats_to_loxi_meter_stats(pb):
-    return of13.meter_stats(
-        meter_id=pb.meter_id,
-        flow_count=pb.flow_count,
-        packet_in_count=pb.packet_in_count,
-        byte_in_count=pb.byte_in_count,
-        duration_sec=pb.duration_sec,
-        duration_nsec=pb.duration_nsec,
-        band_stats=[to_loxi(band_stat) for band_stat in pb.band_stats])
-
-
-def ofp_meter_band_stats_to_loxi_meter_stats(pb):
-    return of13.meter_band_stats(
-        packet_band_count=pb.packet_band_count,
-        byte_band_count=pb.byte_band_count
-    )
-
-def make_loxi_field(oxm_field):
-    assert oxm_field['oxm_class'] == pb2.OFPXMC_OPENFLOW_BASIC
-    ofb_field = oxm_field['ofb_field']
-    field_type = ofb_field.get('type', 0)
-
-    if field_type == pb2.OFPXMT_OFB_ETH_TYPE:
-        return (
-            of13.oxm.eth_type(value=ofb_field['eth_type']))
-
-    elif field_type == pb2.OFPXMT_OFB_IN_PORT:
-        return (
-            of13.oxm.in_port(value=ofb_field['port']))
-
-    elif field_type == pb2.OFPXMT_OFB_IP_PROTO:
-        return (
-            of13.oxm.ip_proto(value=ofb_field['ip_proto']))
-
-    elif field_type == pb2.OFPXMT_OFB_VLAN_VID:
-        return (
-            of13.oxm.vlan_vid(value=ofb_field['vlan_vid']))
-
-    elif field_type == pb2.OFPXMT_OFB_VLAN_PCP:
-        return (
-            of13.oxm.vlan_pcp(value=ofb_field['vlan_pcp']))
-
-    elif field_type == pb2.OFPXMT_OFB_IPV4_SRC:
-        return (
-            of13.oxm.ipv4_src(value=ofb_field['ipv4_src']))
-
-    elif field_type == pb2.OFPXMT_OFB_IPV4_DST:
-        return (
-            of13.oxm.ipv4_dst(value=ofb_field['ipv4_dst']))
-
-    elif field_type == pb2.OFPXMT_OFB_UDP_SRC:
-        return (
-            of13.oxm.udp_src(value=ofb_field['udp_src']))
-
-    elif field_type == pb2.OFPXMT_OFB_UDP_DST:
-        return (
-            of13.oxm.udp_dst(value=ofb_field['udp_dst']))
-
-    elif field_type == pb2.OFPXMT_OFB_METADATA:
-        return (
-            of13.oxm.metadata(value=ofb_field['table_metadata']))
-
-    else:
-        raise NotImplementedError(
-            'OXM match field for type %s' % field_type)
-
-def make_loxi_match(match):
-    assert match.get('type', pb2.OFPMT_STANDARD) == pb2.OFPMT_OXM
-    loxi_match_fields = []
-    for oxm_field in match.get('oxm_fields', []):
-        loxi_match_fields.append(make_loxi_field(oxm_field))
-    return of13.match_v3(oxm_list=loxi_match_fields)
-
-
-def make_loxi_action(a):
-    if type(a) is not dict:
-        a = pb2dict(a)
-
-    typ = a.get('type', 0)
-
-    if typ == pb2.OFPAT_OUTPUT:
-        output_kws = a['output']
-        return of13.action.output(**output_kws)
-
-    elif typ == pb2.OFPAT_POP_VLAN:
-        return of13.action.pop_vlan()
-
-    elif typ == pb2.OFPAT_PUSH_VLAN:
-        push_vlan_kws = a['push']
-        return of13.action.push_vlan(**push_vlan_kws)
-
-    elif typ == pb2.OFPAT_SET_FIELD:
-        loxi_field = make_loxi_field(a['set_field']['field'])
-        return of13.action.set_field(loxi_field)
-
-    elif typ == pb2.OFPAT_GROUP:
-        group_kws = a['group']
-        return of13.action.group(**group_kws)
-
-    else:
-        raise NotImplementedError(
-            'Action decoder for action OFPAT_* %d' % typ)
-
-
-def ofp_flow_stats_to_loxi_flow_stats(pb):
-    kw = pb2dict(pb)
-
-    def make_loxi_instruction(inst):
-        type = inst['type']
-        if type == pb2.OFPIT_APPLY_ACTIONS:
-            return of13.instruction.apply_actions(
-                actions=[make_loxi_action(a)
-                         for a in inst['actions']['actions']])
-        elif type == pb2.OFPIT_CLEAR_ACTIONS:
-            return of13.instruction.clear_actions()
-        elif type == pb2.OFPIT_GOTO_TABLE:
-            return of13.instruction.goto_table(
-                table_id=inst['goto_table']['table_id'])
-        elif type == pb2.OFPIT_WRITE_ACTIONS:
-            return of13.instruction.write_actions(
-                actions=[make_loxi_action(a)
-                         for a in inst['actions']['actions']])
-        elif type == pb2.OFPIT_WRITE_METADATA:
-            if 'metadata' in inst['write_metadata']:
-                return of13.instruction.write_metadata(
-                        metadata=inst['write_metadata']['metadata'])
-            else:
-                return of13.instruction.write_metadata(0)
-        elif type == pb2.OFPIT_METER:
-            return of13.instruction.meter(
-                meter_id=inst['meter']['meter_id'])
-
-        else:
-            raise NotImplementedError('Instruction type %d' % type)
-
-    kw['match'] = make_loxi_match(kw['match'])
-    # if the flow action is drop, then the instruction is not found in the dict
-    if 'instructions' in kw:
-        kw['instructions'] = [make_loxi_instruction(i) for i in kw['instructions']]
-    del kw['id']
-    return of13.flow_stats_entry(**kw)
-
-
-def ofp_packet_in_to_loxi_packet_in(pb):
-    packet_in = of13.message.packet_in(
-        buffer_id=pb.buffer_id,
-        reason=pb.reason,
-        table_id=pb.table_id,
-        cookie=pb.cookie,
-        match=make_loxi_match(pb2dict(pb.match)),
-        data=pb.data
-    )
-    return packet_in
-
-def ofp_group_desc_to_loxi_group_desc(pb):
-    return of13.group_desc_stats_entry(
-        group_type=pb.type,
-        group_id=pb.group_id,
-        buckets=[to_loxi(bucket) for bucket in pb.buckets])
-
-
-def ofp_group_stats_to_loxi_group_stats(pb):
-    return of13.group_stats_entry(
-        group_id=pb.group_id,
-        ref_count=pb.ref_count,
-        packet_count=pb.packet_count,
-        byte_count=pb.byte_count,
-        duration_sec=pb.duration_sec,
-        duration_nsec=pb.duration_nsec,
-        bucket_stats=[to_loxi(bstat) for bstat in pb.bucket_stats])
-
-
-def ofp_bucket_counter_to_loxy_bucket_counter(pb):
-    return of13.bucket_counter(
-        packet_count=pb.packet_count,
-        byte_count=pb.byte_count)
-
-
-def ofp_bucket_to_loxi_bucket(pb):
-    return of13.bucket(
-        weight=pb.weight,
-        watch_port=pb.watch_port,
-        watch_group=pb.watch_group,
-        actions=[to_loxi(action) for action in pb.actions]
-    )
-
-
-to_loxi_converters = {
-    'ofp_port': ofp_port_to_loxi_port_desc,
-    'ofp_port_status': ofp_port_status_to_loxi_port_status,
-    'ofp_flow_stats': ofp_flow_stats_to_loxi_flow_stats,
-    'ofp_packet_in': ofp_packet_in_to_loxi_packet_in,
-    'ofp_group_stats': ofp_group_stats_to_loxi_group_stats,
-    'ofp_group_desc': ofp_group_desc_to_loxi_group_desc,
-    'ofp_bucket_counter': ofp_bucket_counter_to_loxy_bucket_counter,
-    'ofp_bucket': ofp_bucket_to_loxi_bucket,
-    'ofp_action': make_loxi_action,
-    'ofp_port_stats': ofp_port_stats_to_loxi_port_stats,
-    'ofp_meter_stats': ofp_meter_stats_to_loxi_meter_stats,
-    'ofp_meter_band_stats': ofp_meter_band_stats_to_loxi_meter_stats
-}
-
-
-def loxi_flow_mod_to_ofp_flow_mod(lo):
-    return pb2.ofp_flow_mod(
-        cookie=lo.cookie,
-        cookie_mask=lo.cookie_mask,
-        table_id=lo.table_id,
-        command=lo._command,
-        idle_timeout=lo.idle_timeout,
-        hard_timeout=lo.hard_timeout,
-        priority=lo.priority,
-        buffer_id=lo.buffer_id,
-        out_port=lo.out_port,
-        out_group=lo.out_group,
-        flags=lo.flags,
-        match=to_grpc(lo.match),
-        instructions=[to_grpc(i) for i in lo.instructions])
-
-def loxi_meter_mod_to_ofp_meter_mod(lo):
-    return pb2.ofp_meter_mod(
-        command=lo.command,
-        flags=lo.flags,
-        meter_id=lo.meter_id,
-        bands=[to_grpc(i) for i in lo.meters])
-
-
-def loxi_meter_band_drop_to_ofp_meter_band_drop(lo):
-    return pb2.ofp_meter_band_header(
-        type=lo.type,
-        rate=lo.rate,
-        burst_size=lo.burst_size)
-
-
-def loxi_meter_band_dscp_remark_to_ofp_meter_band_dscp_remark(lo):
-    return pb2.ofp_meter_band_header(
-        type=lo.type,
-        rate=lo.rate,
-        burst_size=lo.burst_size,
-        dscp_remark=pb2.ofp_meter_band_dscp_remark(prec_level=lo.prec_level))
-
-
-def loxi_meter_band_experimenter_to_ofp_meter_band_experimenter(lo):
-    return pb2.ofp_meter_band_header(
-        type=lo.type,
-        rate=lo.rate,
-        burst_size=lo.burst_size,
-        experimenter=pb2.ofp_meter_band_experimenter(experimenter=lo.experimenter))
-
-
-def loxi_meter_multipart_request_to_ofp_meter_multipart_request(lo):
-    return pb2.ofp_meter_multipart_request(
-        meter_id=lo.meter_id)
-
-
-def loxi_meter_stats_to_ofp_meter_stats(lo):
-    return pb2.ofp_meter_stats(
-        meter_id=lo.meter_id,
-        flow_count=lo.flow_count,
-        packet_in_count =lo.packet_in_count,
-        byte_in_count=lo.byte_in_count,
-        duration_sec=lo.duration_sec,
-        duration_nsec=lo.duration_nsec,
-        band_stats=lo.band_stats)
-
-
-def loxi_meter_mod_to_ofp_meter_mod(lo):
-    return pb2.ofp_meter_mod(
-        command=lo.command,
-        flags=lo.flags,
-        meter_id=lo.meter_id,
-        bands=[to_grpc(i) for i in lo.meters])
-
-
-def loxi_meter_band_drop_to_ofp_meter_band_drop(lo):
-    return pb2.ofp_meter_band_header(
-        type=lo.type,
-        rate=lo.rate,
-        burst_size=lo.burst_size)
-
-
-def loxi_meter_band_dscp_remark_to_ofp_meter_band_dscp_remark(lo):
-    return pb2.ofp_meter_band_header(
-        type=lo.type,
-        rate=lo.rate,
-        burst_size=lo.burst_size,
-        dscp_remark=pb2.ofp_meter_band_dscp_remark(prec_level=lo.prec_level))
-
-
-def loxi_meter_band_experimenter_to_ofp_meter_band_experimenter(lo):
-    return pb2.ofp_meter_band_header(
-        type=lo.type,
-        rate=lo.rate,
-        burst_size=lo.burst_size,
-        experimenter=pb2.ofp_meter_band_experimenter(experimenter=lo.experimenter))
-
-
-def loxi_meter_multipart_request_to_ofp_meter_multipart_request(lo):
-    return pb2.ofp_meter_multipart_request(
-        meter_id=lo.meter_id)
-
-def loxi_meter_stats_to_ofp_meter_stats(lo):
-    return pb2.ofp_meter_stats(
-        meter_id=lo.meter_id,
-        flow_count=lo.flow_count,
-        packet_in_count =lo.packet_in_count,
-        byte_in_count=lo.byte_in_count,
-        duration_sec=lo.duration_sec,
-        duration_nsec=lo.duration_nsec,
-        band_stats=lo.band_stats)
-
-def loxi_group_mod_to_ofp_group_mod(lo):
-    return pb2.ofp_group_mod(
-        command=lo.command,
-        type=lo.group_type,
-        group_id=lo.group_id,
-        buckets=[to_grpc(b) for b in lo.buckets])
-
-
-def loxi_packet_out_to_ofp_packet_out(lo):
-    return pb2.ofp_packet_out(
-        buffer_id=lo.buffer_id,
-        in_port=lo.in_port,
-        actions=[to_grpc(a) for a in lo.actions],
-        data=lo.data)
-
-
-def loxi_match_v3_to_ofp_match(lo):
-    return pb2.ofp_match(
-        type=pb2.OFPMT_OXM,
-        oxm_fields=[to_grpc(f) for f in lo.oxm_list])
-
-
-def loxi_bucket_to_ofp_bucket(lo):
-    return pb2.ofp_bucket(
-        weight=lo.weight,
-        watch_port=lo.watch_port,
-        watch_group=lo.watch_group,
-        actions=[to_grpc(a) for a in lo.actions])
-
-
-def loxi_oxm_eth_type_to_ofp_oxm(lo):
-    return pb2.ofp_oxm_field(
-        oxm_class=pb2.OFPXMC_OPENFLOW_BASIC,
-        ofb_field=pb2.ofp_oxm_ofb_field(
-            type=pb2.OFPXMT_OFB_ETH_TYPE,
-            eth_type=lo.value))
-
-
-def loxi_oxm_in_port_to_ofp_oxm(lo):
-    return pb2.ofp_oxm_field(
-        oxm_class=pb2.OFPXMC_OPENFLOW_BASIC,
-        ofb_field=pb2.ofp_oxm_ofb_field(
-            type=pb2.OFPXMT_OFB_IN_PORT,
-            port=lo.value))
-
-
-def loxi_oxm_ip_proto_to_ofp_oxm(lo):
-    return pb2.ofp_oxm_field(
-        oxm_class=pb2.OFPXMC_OPENFLOW_BASIC,
-        ofb_field=pb2.ofp_oxm_ofb_field(
-            type=pb2.OFPXMT_OFB_IP_PROTO,
-            ip_proto=lo.value))
-
-
-def loxi_oxm_vlan_vid_to_ofp_oxm(lo):
-    return pb2.ofp_oxm_field(
-        oxm_class=pb2.OFPXMC_OPENFLOW_BASIC,
-        ofb_field=pb2.ofp_oxm_ofb_field(
-            type=pb2.OFPXMT_OFB_VLAN_VID,
-            vlan_vid=lo.value))
-
-
-def loxi_oxm_vlan_pcp_to_ofp_oxm(lo):
-    return pb2.ofp_oxm_field(
-        oxm_class=pb2.OFPXMC_OPENFLOW_BASIC,
-        ofb_field=pb2.ofp_oxm_ofb_field(
-            type=pb2.OFPXMT_OFB_VLAN_PCP,
-            vlan_pcp=lo.value))
-
-
-def loxi_oxm_ipv4_dst_to_ofp_oxm(lo):
-    return pb2.ofp_oxm_field(
-        oxm_class=pb2.OFPXMC_OPENFLOW_BASIC,
-        ofb_field=pb2.ofp_oxm_ofb_field(
-            type=pb2.OFPXMT_OFB_IPV4_DST,
-            ipv4_dst=lo.value))
-
-
-def loxi_oxm_udp_dst_to_ofp_oxm(lo):
-    return pb2.ofp_oxm_field(
-        oxm_class=pb2.OFPXMC_OPENFLOW_BASIC,
-        ofb_field=pb2.ofp_oxm_ofb_field(
-            type=pb2.OFPXMT_OFB_UDP_DST,
-            udp_dst=lo.value))
-
-
-def loxi_oxm_udp_src_to_ofp_oxm(lo):
-    return pb2.ofp_oxm_field(
-        oxm_class=pb2.OFPXMC_OPENFLOW_BASIC,
-        ofb_field=pb2.ofp_oxm_ofb_field(
-            type=pb2.OFPXMT_OFB_UDP_SRC,
-            udp_src=lo.value))
-
-
-def loxi_oxm_metadata_to_ofp_oxm(lo):
-    return pb2.ofp_oxm_field(
-        oxm_class=pb2.OFPXMC_OPENFLOW_BASIC,
-        ofb_field=pb2.ofp_oxm_ofb_field(
-            type=pb2.OFPXMT_OFB_METADATA,
-            table_metadata=lo.value))
-
-
-def loxi_apply_actions_to_ofp_instruction(lo):
-    return pb2.ofp_instruction(
-        type=pb2.OFPIT_APPLY_ACTIONS,
-        actions=pb2.ofp_instruction_actions(
-            actions=[to_grpc(a) for a in lo.actions]))
-
-def loxi_clear_actions_to_ofp_instruction(lo):
-    return pb2.ofp_instruction(
-        type=pb2.OFPIT_CLEAR_ACTIONS)
-
-
-def loxi_goto_table_to_ofp_instruction(lo):
-    return pb2.ofp_instruction(
-        type=pb2.OFPIT_GOTO_TABLE,
-        goto_table=pb2.ofp_instruction_goto_table(table_id=lo.table_id))
-
-
-def loxi_write_metadata_to_ofp_instruction(lo):
-    return pb2.ofp_instruction(
-        type=pb2.OFPIT_WRITE_METADATA,
-        write_metadata=pb2.ofp_instruction_write_metadata(
-            metadata=lo.metadata,
-            metadata_mask=lo.metadata_mask))
-
-
-def loxi_meter_to_ofp_instruction(lo):
-    return pb2.ofp_instruction(
-        type=pb2.OFPIT_METER,
-        meter=pb2.ofp_instruction_meter(meter_id=lo.meter_id))
-
-
-def loxi_output_action_to_ofp_action(lo):
-    return pb2.ofp_action(
-        type=pb2.OFPAT_OUTPUT,
-        output=pb2.ofp_action_output(port=lo.port, max_len=lo.max_len))
-
-
-def loxi_write_actions_to_ofp_instruction(lo):
-    return pb2.ofp_instruction(
-        type=pb2.OFPIT_WRITE_ACTIONS,
-        actions=pb2.ofp_instruction_actions(
-            actions=[to_grpc(a) for a in lo.actions]))
-
-
-def loxi_meter_to_ofp_instruction(lo):
-    return pb2.ofp_instruction(
-        type=pb2.OFPIT_METER,
-        meter=pb2.ofp_instruction_meter(meter_id=lo.meter_id))
-
-
-def loxi_group_action_to_ofp_action(lo):
-    return pb2.ofp_action(
-        type=pb2.OFPAT_GROUP,
-        group=pb2.ofp_action_group(group_id=lo.group_id))
-
-
-def loxi_set_field_action_to_ofp_action(lo):
-    return pb2.ofp_action(
-        type=pb2.OFPAT_SET_FIELD,
-        set_field=pb2.ofp_action_set_field(field=to_grpc(lo.field)))
-
-
-def loxi_pop_vlan_action_to_ofp_action(lo):
-    return pb2.ofp_action(type=pb2.OFPAT_POP_VLAN)
-
-
-def loxi_push_vlan_action_to_ofp_action(lo):
-    return pb2.ofp_action(
-        type=pb2.OFPAT_PUSH_VLAN,
-        push=pb2.ofp_action_push(ethertype=lo.ethertype))
-
-
-to_grpc_converters = {
-
-    of13.message.flow_add: loxi_flow_mod_to_ofp_flow_mod,
-    of13.message.flow_delete: loxi_flow_mod_to_ofp_flow_mod,
-    of13.message.flow_delete_strict: loxi_flow_mod_to_ofp_flow_mod,
-    of13.message.flow_modify: loxi_flow_mod_to_ofp_flow_mod,
-    of13.message.flow_modify_strict: loxi_flow_mod_to_ofp_flow_mod,
-    of13.message.meter_mod: loxi_meter_mod_to_ofp_meter_mod,
-    of13.message.meter_stats_request: loxi_meter_stats_to_ofp_meter_stats,
-
-    of13.message.group_add: loxi_group_mod_to_ofp_group_mod,
-    of13.message.group_delete: loxi_group_mod_to_ofp_group_mod,
-    of13.message.group_modify: loxi_group_mod_to_ofp_group_mod,
-    of13.message.packet_out: loxi_packet_out_to_ofp_packet_out,
-
-    of13.meter_band.drop: loxi_meter_band_drop_to_ofp_meter_band_drop,
-    of13.meter_band.dscp_remark: loxi_meter_band_dscp_remark_to_ofp_meter_band_dscp_remark,
-    of13.meter_band.experimenter: loxi_meter_band_experimenter_to_ofp_meter_band_experimenter,
-
-    of13.common.match_v3: loxi_match_v3_to_ofp_match,
-    of13.common.bucket: loxi_bucket_to_ofp_bucket,
-
-    of13.oxm.eth_type: loxi_oxm_eth_type_to_ofp_oxm,
-    of13.oxm.in_port: loxi_oxm_in_port_to_ofp_oxm,
-    of13.oxm.ip_proto: loxi_oxm_ip_proto_to_ofp_oxm,
-    of13.oxm.vlan_vid: loxi_oxm_vlan_vid_to_ofp_oxm,
-    of13.oxm.vlan_pcp: loxi_oxm_vlan_pcp_to_ofp_oxm,
-    of13.oxm.ipv4_dst: loxi_oxm_ipv4_dst_to_ofp_oxm,
-    of13.oxm.udp_src: loxi_oxm_udp_src_to_ofp_oxm,
-    of13.oxm.udp_dst: loxi_oxm_udp_dst_to_ofp_oxm,
-    of13.oxm.metadata: loxi_oxm_metadata_to_ofp_oxm,
-
-    of13.instruction.apply_actions: loxi_apply_actions_to_ofp_instruction,
-    of13.instruction.clear_actions: loxi_clear_actions_to_ofp_instruction,
-    of13.instruction.write_actions: loxi_write_actions_to_ofp_instruction,
-    of13.instruction.goto_table: loxi_goto_table_to_ofp_instruction,
-    of13.instruction.write_metadata: loxi_write_metadata_to_ofp_instruction,
-    of13.instruction.meter: loxi_meter_to_ofp_instruction,
-
-    of13.action.output: loxi_output_action_to_ofp_action,
-    of13.action.group: loxi_group_action_to_ofp_action,
-    of13.action.set_field: loxi_set_field_action_to_ofp_action,
-    of13.action.pop_vlan: loxi_pop_vlan_action_to_ofp_action,
-    of13.action.push_vlan: loxi_push_vlan_action_to_ofp_action,
-}
diff --git a/python/ofagent/grpc_client.py b/python/ofagent/grpc_client.py
deleted file mode 100755
index 8e7b393..0000000
--- a/python/ofagent/grpc_client.py
+++ /dev/null
@@ -1,344 +0,0 @@
-#
-# Copyright 2017 the original author or authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-"""
-The gRPC client layer for the OpenFlow agent
-"""
-from Queue import Queue, Empty
-import os
-import uuid
-
-from grpc import StatusCode
-from grpc._channel import _Rendezvous
-from structlog import get_logger
-from twisted.internet import reactor
-from twisted.internet import threads
-from twisted.internet.defer import inlineCallbacks, returnValue, DeferredQueue
-
-from voltha_protos.voltha_pb2_grpc import VolthaServiceStub
-from voltha_protos.voltha_pb2 import ID, FlowTableUpdate, MeterModUpdate, \
-    FlowGroupTableUpdate, PacketOut
-from voltha_protos.logical_device_pb2 import LogicalPortId
-from google.protobuf import empty_pb2
-from binascii import hexlify
-
-
-log = get_logger()
-
-
-class GrpcClient(object):
-
-    def __init__(self, connection_manager, channel, grpc_timeout, core_binding_key, core_transaction_key):
-
-        self.connection_manager = connection_manager
-        self.channel = channel
-        self.grpc_timeout = grpc_timeout
-        self.grpc_stub = VolthaServiceStub(channel)
-
-        # This is the rw-core cluster to which an OFAgent is bound.
-        # It is the affinity router that forwards all OFAgent
-        # requests to a specific rw-core in this back-end cluster.
-        self.core_group_id = ''
-        self.core_group_id_key = core_binding_key
-
-        # Since the api-router binds an OFAgent to two RW Cores in a pair and
-        # transparently forward requests between the two then the onus is on
-        # the OFAgent to fulfill part of the function of the api-server which
-        # involves sending a transaction key to both RW Cores for the latter
-        # to figure out which Core will handle the transaction. To prevent
-        # collision between the api-server ID and the one from OFAgent then the
-        # OFAgent ID will be prefixed with "O-".
-        self.core_transaction_key = core_transaction_key
-
-        self.stopped = False
-
-        self.packet_out_queue = Queue()  # queue to send out PacketOut msgs
-        self.packet_in_queue = DeferredQueue()  # queue to receive PacketIn
-        self.change_event_queue = DeferredQueue()  # queue change events
-
-    def start(self):
-        log.debug('starting', grpc_timeout=self.grpc_timeout,
-                  core_binding_key=self.core_group_id_key,
-                  core_transaction_key=self.core_transaction_key)
-        self.start_packet_out_stream()
-        self.start_packet_in_stream()
-        self.start_change_event_in_stream()
-        reactor.callLater(0, self.packet_in_forwarder_loop)
-        reactor.callLater(0, self.change_event_processing_loop)
-        log.info('started')
-        return self
-
-    def stop(self):
-        log.debug('stop requested')
-        if self.stopped:
-            log.debug('already stopped, no action taken')
-            return
-        log.debug('stopping')
-        self.stopped = True
-        self.connection_manager.grpc_client_terminated()
-        log.info('stopped')
-
-    def get_core_transaction_metadata(self):
-        return (self.core_transaction_key, "O-" + uuid.uuid4().hex)
-
-    def start_packet_out_stream(self):
-
-        def packet_generator():
-            while True:
-                try:
-                    packet = self.packet_out_queue.get(block=True, timeout=1.0)
-                except Empty:
-                    if self.stopped:
-                        return
-                else:
-                    yield packet
-
-        def stream_packets_out():
-            generator = packet_generator()
-            try:
-                self.grpc_stub.StreamPacketsOut(generator,
-                                                metadata=((self.core_group_id_key, self.core_group_id),
-                                                           self.get_core_transaction_metadata(),))
-            except _Rendezvous, e:
-                log.error('grpc-exception', status=e.code())
-                if e.code() == StatusCode.UNAVAILABLE:
-                    self.stop()
-
-        reactor.callInThread(stream_packets_out)
-
-    def start_packet_in_stream(self):
-
-        def receive_packet_in_stream():
-            streaming_rpc_method = self.grpc_stub.ReceivePacketsIn
-            iterator = streaming_rpc_method(empty_pb2.Empty(),
-                                            metadata=((self.core_group_id_key, self.core_group_id),
-                                                      self.get_core_transaction_metadata(),))
-            try:
-                for packet_in in iterator:
-                    reactor.callFromThread(self.packet_in_queue.put,
-                                           packet_in)
-                    log.debug('enqueued-packet-in',
-                              packet_in=packet_in,
-                              queue_len=len(self.packet_in_queue.pending),
-                              packet=hexlify(packet_in.packet_in.data))
-            except _Rendezvous, e:
-                log.error('grpc-exception', status=e.code())
-                if e.code() == StatusCode.UNAVAILABLE:
-                    self.stop()
-
-        reactor.callInThread(receive_packet_in_stream)
-
-    def start_change_event_in_stream(self):
-
-        def receive_change_events():
-            streaming_rpc_method = self.grpc_stub.ReceiveChangeEvents
-            iterator = streaming_rpc_method(empty_pb2.Empty(),
-                                            metadata=((self.core_group_id_key, self.core_group_id),
-                                                      self.get_core_transaction_metadata(),))
-            try:
-                for event in iterator:
-                    reactor.callFromThread(self.change_event_queue.put, event)
-                    log.debug('enqueued-change-event',
-                              change_event=event,
-                              queue_len=len(self.change_event_queue.pending))
-            except _Rendezvous, e:
-                log.error('grpc-exception', status=e.code())
-                if e.code() == StatusCode.UNAVAILABLE:
-                    self.stop()
-
-        reactor.callInThread(receive_change_events)
-
-    @inlineCallbacks
-    def change_event_processing_loop(self):
-        while True:
-            try:
-                event = yield self.change_event_queue.get()
-                device_id = event.id
-                self.connection_manager.forward_change_event(device_id, event)
-            except Exception, e:
-                log.exception('failed-in-packet-in-handler', e=e)
-            if self.stopped:
-                break
-
-    @inlineCallbacks
-    def packet_in_forwarder_loop(self):
-        while True:
-            packet_in = yield self.packet_in_queue.get()
-            device_id = packet_in.id
-            ofp_packet_in = packet_in.packet_in
-            log.debug('grpc client to send packet-in', packet=hexlify(packet_in.packet_in.data))
-            self.connection_manager.forward_packet_in(device_id, ofp_packet_in)
-            if self.stopped:
-                break
-
-    def send_packet_out(self, device_id, packet_out):
-        log.debug('grpc client to send packet-out', packet=hexlify(packet_out.data))
-        packet_out = PacketOut(id=device_id, packet_out=packet_out)
-        self.packet_out_queue.put(packet_out)
-
-    @inlineCallbacks
-    def get_port(self, device_id, port_id):
-        req = LogicalPortId(id=device_id, port_id=port_id)
-        res = yield threads.deferToThread(
-            self.grpc_stub.GetLogicalDevicePort, req, timeout=self.grpc_timeout,
-            metadata=((self.core_group_id_key, self.core_group_id),
-                      self.get_core_transaction_metadata(),))
-        returnValue(res)
-
-    @inlineCallbacks
-    def get_port_list(self, device_id):
-        req = ID(id=device_id)
-        res = yield threads.deferToThread(
-            self.grpc_stub.ListLogicalDevicePorts, req, timeout=self.grpc_timeout,
-            metadata=((self.core_group_id_key, self.core_group_id),
-                      self.get_core_transaction_metadata(),))
-        returnValue(res.items)
-
-    @inlineCallbacks
-    def enable_port(self, device_id, port_id):
-        req = LogicalPortId(
-            id=device_id,
-            port_id=port_id
-        )
-        res = yield threads.deferToThread(
-            self.grpc_stub.EnableLogicalDevicePort, req, timeout=self.grpc_timeout,
-            metadata=((self.core_group_id_key, self.core_group_id),
-                      self.get_core_transaction_metadata(),))
-        returnValue(res)
-
-    @inlineCallbacks
-    def disable_port(self, device_id, port_id):
-        req = LogicalPortId(
-            id=device_id,
-            port_id=port_id
-        )
-        res = yield threads.deferToThread(
-            self.grpc_stub.DisableLogicalDevicePort, req, timeout=self.grpc_timeout,
-            metadata=((self.core_group_id_key, self.core_group_id),
-                      self.get_core_transaction_metadata(),))
-        returnValue(res)
-
-    @inlineCallbacks
-    def get_device_info(self, device_id):
-        req = ID(id=device_id)
-        res = yield threads.deferToThread(
-            self.grpc_stub.GetLogicalDevice, req, timeout=self.grpc_timeout,
-            metadata=((self.core_group_id_key, self.core_group_id),
-                      self.get_core_transaction_metadata(),))
-        returnValue(res)
-
-    @inlineCallbacks
-    def update_flow_table(self, device_id, flow_mod):
-        req = FlowTableUpdate(
-            id=device_id,
-            flow_mod=flow_mod
-        )
-        res = yield threads.deferToThread(
-            self.grpc_stub.UpdateLogicalDeviceFlowTable, req, timeout=self.grpc_timeout,
-            metadata=((self.core_group_id_key, self.core_group_id),
-                      self.get_core_transaction_metadata(),))
-        returnValue(res)
-
-    @inlineCallbacks
-    def update_meter_mod_table(self, device_id, meter_mod):
-        log.debug('In update_meter_mod_table grpc')
-        req = MeterModUpdate(
-            id=device_id,
-            meter_mod=meter_mod
-        )
-        res = yield threads.deferToThread(
-            self.grpc_stub.UpdateLogicalDeviceMeterTable, req, timeout=self.grpc_timeout,
-            metadata=((self.core_group_id_key, self.core_group_id),
-                      self.get_core_transaction_metadata(),))
-        log.debug('update_meter_mod_table grpc done')
-        returnValue(res)
-
-    @inlineCallbacks
-    def update_group_table(self, device_id, group_mod):
-        req = FlowGroupTableUpdate(
-            id=device_id,
-            group_mod=group_mod
-        )
-        res = yield threads.deferToThread(
-            self.grpc_stub.UpdateLogicalDeviceFlowGroupTable, req, timeout=self.grpc_timeout,
-            metadata=((self.core_group_id_key, self.core_group_id),
-                      self.get_core_transaction_metadata(),))
-        returnValue(res)
-
-    @inlineCallbacks
-    def list_flows(self, device_id):
-        req = ID(id=device_id)
-        res = yield threads.deferToThread(
-            self.grpc_stub.ListLogicalDeviceFlows, req, timeout=self.grpc_timeout,
-            metadata=((self.core_group_id_key, self.core_group_id),
-                      self.get_core_transaction_metadata(),))
-        returnValue(res.items)
-
-    @inlineCallbacks
-    def list_groups(self, device_id):
-        req = ID(id=device_id)
-        res = yield threads.deferToThread(
-            self.grpc_stub.ListLogicalDeviceFlowGroups, req, timeout=self.grpc_timeout,
-            metadata=((self.core_group_id_key, self.core_group_id),
-                      self.get_core_transaction_metadata(),))
-        returnValue(res.items)
-
-    @inlineCallbacks
-    def list_ports(self, device_id):
-        req = ID(id=device_id)
-        res = yield threads.deferToThread(
-            self.grpc_stub.ListLogicalDevicePorts, req, timeout=self.grpc_timeout,
-            metadata=((self.core_group_id_key, self.core_group_id),
-                      self.get_core_transaction_metadata(),))
-        returnValue(res.items)
-
-    @inlineCallbacks
-    def list_logical_devices(self):
-        res = yield threads.deferToThread(
-            self.grpc_stub.ListLogicalDevices, empty_pb2.Empty(), timeout=self.grpc_timeout,
-            metadata=((self.core_group_id_key, self.core_group_id),
-                      self.get_core_transaction_metadata(),))
-        returnValue(res.items)
-
-    @inlineCallbacks
-    def subscribe(self, subscriber):
-        res, call = yield threads.deferToThread(
-            self.grpc_stub.Subscribe.with_call, subscriber, timeout=self.grpc_timeout,
-            metadata=((self.core_group_id_key, self.core_group_id),
-                      self.get_core_transaction_metadata(),))
-        returned_metadata = call.initial_metadata()
-
-        # Update the core_group_id if present in the returned metadata
-        if returned_metadata is None:
-            log.debug('header-metadata-missing')
-        else:
-            log.debug('metadata-returned', metadata=returned_metadata)
-            for pair in returned_metadata:
-                if pair[0] == self.core_group_id_key:
-                    self.core_group_id = pair[1]
-                    log.debug('core-binding', core_group=self.core_group_id)
-        returnValue(res)
-
-    @inlineCallbacks
-    def list_meters(self, device_id):
-        log.debug('list_meters')
-        req = ID(id=device_id)
-        res = yield threads.deferToThread(
-            self.grpc_stub.ListLogicalDeviceMeters, req, timeout=self.grpc_timeout,
-            metadata=((self.core_group_id_key, self.core_group_id),
-                      self.get_core_transaction_metadata(),))
-        log.debug('done stat query', resp=res)
-        returnValue(res.items)
diff --git a/python/ofagent/loxi/__init__.py b/python/ofagent/loxi/__init__.py
deleted file mode 100644
index adb067b..0000000
--- a/python/ofagent/loxi/__init__.py
+++ /dev/null
@@ -1,82 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-# Automatically generated by LOXI from template toplevel_init.py
-# Do not modify
-
-version_names = {
-    1: "1.0",
-    2: "1.1",
-    3: "1.2",
-    4: "1.3",
-    5: "1.4",
-}
-
-def protocol(ver):
-    """
-    Import and return the protocol module for the given wire version.
-    """
-    if ver == 1:
-        import of10
-        return of10
-
-    if ver == 2:
-        import of11
-        return of11
-
-    if ver == 3:
-        import of12
-        return of12
-
-    if ver == 4:
-        import of13
-        return of13
-
-    if ver == 5:
-        import of14
-        return of14
-
-    raise ValueError
-
-class ProtocolError(Exception):
-    """
-    Raised when failing to deserialize an invalid OpenFlow message.
-    """
-    pass
-
-class Unimplemented(Exception):
-    """
-    Raised when an OpenFlow feature is not yet implemented in PyLoxi.
-    """
-    pass
-
-def unimplemented(msg):
-    raise Unimplemented(msg)
-
-class OFObject(object):
-    """
-    Superclass of all OpenFlow classes
-    """
-    def __init__(self, *args):
-        raise NotImplementedError("cannot instantiate abstract class")
-
-    def __ne__(self, other):
-        return not self.__eq__(other)
-
-    def show(self):
-        import loxi.pp
-        return loxi.pp.pp(self)
diff --git a/python/ofagent/loxi/connection.py b/python/ofagent/loxi/connection.py
deleted file mode 100644
index fc61161..0000000
--- a/python/ofagent/loxi/connection.py
+++ /dev/null
@@ -1,263 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright 2015, Big Switch Networks, Inc.
-
-"""
-OpenFlow connection class
-
-This class creates a thread which continually parses OpenFlow messages off the
-supplied socket and places them in a queue. The class has methods for reading messages
-from the RX queue, sending messages, and higher level operations like request-response
-and multipart transactions.
-"""
-
-import loxi
-import loxi.of14
-import logging
-import time
-import socket
-import errno
-import os
-import select
-from threading import Condition, Lock, Thread
-
-DEFAULT_TIMEOUT = 1
-
-class TransactionError(Exception):
-    def __str__(self):
-        return self.args[0]
-
-    @property
-    def msg(self):
-        return self.args[1]
-
-class ConnectionClosed(Exception):
-    pass
-
-class Connection(Thread):
-    def __init__(self, sock):
-        Thread.__init__(self)
-        self.sock = sock
-        self.logger = logging.getLogger("connection")
-        self.rx = []
-        self.rx_cv = Condition()
-        self.tx_lock = Lock()
-        self.next_xid = 1
-        self.wakeup_rd, self.wakeup_wr = os.pipe()
-        self.finished = False
-        self.read_buffer = None
-
-    def start(self):
-        while not self.finished:
-            try:
-                rd, wr, err = select.select([self.sock, self.wakeup_rd], [], [])
-            except select.error:
-                print 'SELECT ERROR!!!'
-            if self.sock in rd:
-                try:
-                    self.process_read()
-                except ConnectionClosed:
-                    self.logger.info("Connection to controller was dropped")
-                    self.finished = True
-            if self.wakeup_rd in rd:
-                os.read(self.wakeup_rd, 1)
-        self.logger.debug("Exited event loop")
-
-    def process_read(self):
-        recvd = self.sock.recv(4096)
-        if (len(recvd)) == 0:
-            # this indicates that the other end hang up
-            raise ConnectionClosed()
-
-        self.logger.debug("Received %d bytes", len(recvd))
-
-        buf = self.read_buffer
-        if buf:
-            buf += recvd
-        else:
-            buf = recvd
-
-        offset = 0
-        while offset < len(buf):
-            if offset + 8 > len(buf):
-                # Not enough data for the OpenFlow header
-                break
-
-            # Parse the header to get type
-            hdr_version, hdr_type, hdr_msglen, hdr_xid = loxi.of14.message.parse_header(buf[offset:])
-
-            # Use loxi to resolve ofp of matching version
-            ofp = loxi.protocol(hdr_version)
-
-            # Extract the raw message bytes
-            if (offset + hdr_msglen) > len(buf):
-                # Not enough data for the body
-                break
-            rawmsg = buf[offset : offset + hdr_msglen]
-            offset += hdr_msglen
-
-            msg = ofp.message.parse_message(rawmsg)
-            if not msg:
-                self.logger.warn("Could not parse message")
-                continue
-
-            self.logger.debug("Received message %s.%s xid %d length %d",
-                              type(msg).__module__, type(msg).__name__, hdr_xid, hdr_msglen)
-
-            with self.rx_cv:
-                self.rx.append(msg)
-                self.rx_cv.notify_all()
-
-        if offset == len(buf):
-            self.read_buffer = None
-        else:
-            self.read_buffer = buf[offset:]
-            self.logger.debug("%d bytes remaining", len(self.read_buffer))
-
-    def recv(self, predicate, timeout=DEFAULT_TIMEOUT):
-        """
-        Remove and return the first message in the RX queue for
-        which 'predicate' returns true
-        """
-        assert self.is_alive()
-
-        deadline = time.time() + timeout
-        while True:
-            with self.rx_cv:
-                for i, msg in enumerate(self.rx):
-                    if predicate(msg):
-                        return self.rx.pop(i)
-
-                now = time.time()
-                if now > deadline:
-                    return None
-                else:
-                    self.rx_cv.wait(deadline - now)
-
-    def recv_any(self, timeout=DEFAULT_TIMEOUT):
-        """
-        Return the first message in the RX queue
-        """
-        return self.recv(lambda msg: True, timeout)
-
-    def recv_xid(self, xid, timeout=DEFAULT_TIMEOUT):
-        """
-        Return the first message in the RX queue with XID 'xid'
-        """
-        return self.recv(lambda msg: msg.xid == xid, timeout)
-
-    def recv_class(self, klass, timeout=DEFAULT_TIMEOUT):
-        """
-        Return the first message in the RX queue which is an instance of 'klass'
-        """
-        return self.recv(lambda msg: isinstance(msg, klass), timeout)
-
-    def send_raw(self, buf):
-        """
-        Send raw bytes on the socket
-        """
-        assert self.is_alive()
-        self.logger.debug("Sending raw message length %d", len(buf))
-        with self.tx_lock:
-            if self.sock.sendall(buf) is not None:
-                raise RuntimeError("failed to send message to switch")
-
-    def send(self, msg):
-        """
-        Send a message
-        """
-        assert self.is_alive()
-
-        if msg.xid is None:
-            msg.xid = self._gen_xid()
-        buf = msg.pack()
-        self.logger.debug("Sending message %s.%s xid %d length %d",
-                          type(msg).__module__, type(msg).__name__, msg.xid, len(buf))
-        with self.tx_lock:
-            if self.sock.sendall(buf) is not None:
-                raise RuntimeError("failed to send message to switch")
-
-    def transact(self, msg, timeout=DEFAULT_TIMEOUT):
-        """
-        Send a message and return the reply
-        """
-        self.send(msg)
-        reply = self.recv_xid(msg.xid, timeout)
-        if reply is None:
-            raise TransactionError("no reply for %s" % type(msg).__name__, None)
-        elif isinstance(reply, loxi.protocol(reply.version).message.error_msg):
-            raise TransactionError("received %s in response to %s" % (type(reply).__name__, type(msg).__name__), reply)
-        return reply
-
-    def transact_multipart_generator(self, msg, timeout=DEFAULT_TIMEOUT):
-        """
-        Send a multipart request and yield each entry from the replies
-        """
-        self.send(msg)
-        finished = False
-        while not finished:
-            reply = self.recv_xid(msg.xid, timeout)
-            if reply is None:
-                raise TransactionError("no reply for %s" % type(msg).__name__, None)
-            elif not isinstance(reply, loxi.protocol(reply.version).message.stats_reply):
-                raise TransactionError("received %s in response to %s" % (type(reply).__name__, type(msg).__name__), reply)
-            for entry in reply.entries:
-                yield entry
-            finished = reply.flags & loxi.protocol(reply.version).OFPSF_REPLY_MORE == 0
-
-    def transact_multipart(self, msg, timeout=DEFAULT_TIMEOUT):
-        """
-        Send a multipart request and return all entries from the replies
-        """
-        entries = []
-        for entry in self.transact_multipart_generator(msg, timeout):
-            entries.append(entry)
-        return entries
-
-    def stop(self):
-        """
-        Signal the thread to exit and wait for it
-        """
-        assert not self.finished
-        self.logger.debug("Stopping connection")
-        self.finished = True
-        os.write(self.wakeup_wr, "x")
-        self.join()
-        self.sock.close()
-        os.close(self.wakeup_rd)
-        os.close(self.wakeup_wr)
-        self.logger.debug("Stopped connection")
-
-    def _gen_xid(self):
-        xid = self.next_xid
-        self.next_xid += 1
-        return xid
-
-def connect(ip, port=6653, daemon=True, ofp=loxi.of14):
-    """
-    Actively connect to a switch
-    """
-    soc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-    soc.connect((ip, port))
-    soc.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, True)
-    cxn = Connection(soc)
-    cxn.daemon = daemon
-    cxn.logger.debug("Connected to %s:%d", ip, port)
-    cxn.start()
-
-    cxn.send(ofp.message.hello())
-    if not cxn.recv(lambda msg: msg.type == ofp.OFPT_HELLO):
-        raise Exception("Did not receive HELLO")
-
-    return cxn
diff --git a/python/ofagent/loxi/generic_util.py b/python/ofagent/loxi/generic_util.py
deleted file mode 100644
index 7cbf32e..0000000
--- a/python/ofagent/loxi/generic_util.py
+++ /dev/null
@@ -1,113 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-"""
-Utility functions independent of the protocol version
-"""
-
-# Automatically generated by LOXI from template generic_util.py
-# Do not modify
-
-import loxi
-import struct
-
-def pack_list(values):
-    return "".join([x.pack() for x in values])
-
-def unpack_list(reader, deserializer):
-    """
-    The deserializer function should take an OFReader and return the new object.
-    """
-    entries = []
-    while not reader.is_empty():
-        entries.append(deserializer(reader))
-    return entries
-
-def pad_to(alignment, length):
-    """
-    Return a string of zero bytes that will pad a string of length 'length' to
-    a multiple of 'alignment'.
-    """
-    return "\x00" * ((length + alignment - 1)/alignment*alignment - length)
-
-class OFReader(object):
-    """
-    Cursor over a read-only buffer
-
-    OpenFlow messages are best thought of as a sequence of elements of
-    variable size, rather than a C-style struct with fixed offsets and
-    known field lengths. This class supports efficiently reading
-    fields sequentially and is intended to be used recursively by the
-    parsers of child objects which will implicitly update the offset.
-
-    buf: buffer object
-    start: initial position in the buffer
-    length: number of bytes after start
-    offset: distance from start
-    """
-    def __init__(self, buf, start=0, length=None):
-        self.buf = buf
-        self.start = start
-        if length is None:
-            self.length = len(buf) - start
-        else:
-            self.length = length
-        self.offset = 0
-
-    def read(self, fmt):
-        st = struct.Struct(fmt)
-        if self.offset + st.size > self.length:
-            raise loxi.ProtocolError("Buffer too short")
-        result = st.unpack_from(self.buf, self.start+self.offset)
-        self.offset += st.size
-        return result
-
-    def read_all(self):
-        s = self.buf[(self.start+self.offset):(self.start+self.length)]
-        assert(len(s) == self.length - self.offset)
-        self.offset = self.length
-        return s
-
-    def peek(self, fmt, offset=0):
-        st = struct.Struct(fmt)
-        if self.offset + offset + st.size > self.length:
-            raise loxi.ProtocolError("Buffer too short")
-        result = st.unpack_from(self.buf, self.start + self.offset + offset)
-        return result
-
-    def skip(self, length):
-        if self.offset + length > self.length:
-            raise loxi.ProtocolError("Buffer too short")
-        self.offset += length
-
-    def skip_align(self):
-        new_offset = (self.offset + 7) / 8 * 8
-        if new_offset > self.length:
-            raise loxi.ProtocolError("Buffer too short")
-        self.offset = new_offset
-
-    def is_empty(self):
-        return self.offset == self.length
-
-    # Used when parsing objects that have their own length fields
-    def slice(self, length, rewind=0):
-        if self.offset + length - rewind > self.length:
-            raise loxi.ProtocolError("Buffer too short")
-        reader = OFReader(self.buf, self.start + self.offset - rewind, length)
-        reader.skip(rewind)
-        self.offset += length - rewind
-        return reader
diff --git a/python/ofagent/loxi/of10/__init__.py b/python/ofagent/loxi/of10/__init__.py
deleted file mode 100644
index d4457f5..0000000
--- a/python/ofagent/loxi/of10/__init__.py
+++ /dev/null
@@ -1,28 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template init.py
-# Do not modify
-
-import const
-import action
-import message
-import common
-from const import *
-from common import *
-from loxi import ProtocolError
diff --git a/python/ofagent/loxi/of10/action.py b/python/ofagent/loxi/of10/action.py
deleted file mode 100644
index 43702f0..0000000
--- a/python/ofagent/loxi/of10/action.py
+++ /dev/null
@@ -1,1088 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template module.py
-# Do not modify
-
-import struct
-import loxi
-import util
-import loxi.generic_util
-
-import sys
-ofp = sys.modules['loxi.of10']
-
-class action(loxi.OFObject):
-    subtypes = {}
-
-
-    def __init__(self, type=None):
-        if type != None:
-            self.type = type
-        else:
-            self.type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 0)
-        subclass = action.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = action()
-        obj.type = reader.read("!H")[0]
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type != other.type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("action {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-
-class experimenter(action):
-    subtypes = {}
-
-    type = 65535
-
-    def __init__(self, experimenter=None, data=None):
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 4)
-        subclass = experimenter.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = experimenter()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.experimenter = reader.read("!L")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.experimenter != other.experimenter: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("experimenter {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[65535] = experimenter
-
-class bsn(experimenter):
-    subtypes = {}
-
-    type = 65535
-    experimenter = 6035143
-
-    def __init__(self, subtype=None):
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 8)
-        subclass = bsn.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = bsn()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        obj.subtype = reader.read("!L")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.subtype != other.subtype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-experimenter.subtypes[6035143] = bsn
-
-class bsn_checksum(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 4
-
-    def __init__(self, checksum=None):
-        if checksum != None:
-            self.checksum = checksum
-        else:
-            self.checksum = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(util.pack_checksum_128(self.checksum))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_checksum()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 4)
-        obj.checksum = util.unpack_checksum_128(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.checksum != other.checksum: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_checksum {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("checksum = ");
-                q.pp(self.checksum)
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[4] = bsn_checksum
-
-class bsn_mirror(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 1
-
-    def __init__(self, dest_port=None, vlan_tag=None, copy_stage=None):
-        if dest_port != None:
-            self.dest_port = dest_port
-        else:
-            self.dest_port = 0
-        if vlan_tag != None:
-            self.vlan_tag = vlan_tag
-        else:
-            self.vlan_tag = 0
-        if copy_stage != None:
-            self.copy_stage = copy_stage
-        else:
-            self.copy_stage = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.dest_port))
-        packed.append(struct.pack("!L", self.vlan_tag))
-        packed.append(struct.pack("!B", self.copy_stage))
-        packed.append('\x00' * 3)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_mirror()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 1)
-        obj.dest_port = reader.read("!L")[0]
-        obj.vlan_tag = reader.read("!L")[0]
-        obj.copy_stage = reader.read("!B")[0]
-        reader.skip(3)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.dest_port != other.dest_port: return False
-        if self.vlan_tag != other.vlan_tag: return False
-        if self.copy_stage != other.copy_stage: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_mirror {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("dest_port = ");
-                q.text("%#x" % self.dest_port)
-                q.text(","); q.breakable()
-                q.text("vlan_tag = ");
-                q.text("%#x" % self.vlan_tag)
-                q.text(","); q.breakable()
-                q.text("copy_stage = ");
-                q.text("%#x" % self.copy_stage)
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[1] = bsn_mirror
-
-class bsn_set_tunnel_dst(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 2
-
-    def __init__(self, dst=None):
-        if dst != None:
-            self.dst = dst
-        else:
-            self.dst = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.dst))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_set_tunnel_dst()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 2)
-        obj.dst = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.dst != other.dst: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_set_tunnel_dst {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("dst = ");
-                q.text("%#x" % self.dst)
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[2] = bsn_set_tunnel_dst
-
-class enqueue(action):
-    type = 11
-
-    def __init__(self, port=None, queue_id=None):
-        if port != None:
-            self.port = port
-        else:
-            self.port = 0
-        if queue_id != None:
-            self.queue_id = queue_id
-        else:
-            self.queue_id = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(util.pack_port_no(self.port))
-        packed.append('\x00' * 6)
-        packed.append(struct.pack("!L", self.queue_id))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = enqueue()
-        _type = reader.read("!H")[0]
-        assert(_type == 11)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.port = util.unpack_port_no(reader)
-        reader.skip(6)
-        obj.queue_id = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.port != other.port: return False
-        if self.queue_id != other.queue_id: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("enqueue {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("port = ");
-                q.text(util.pretty_port(self.port))
-                q.text(","); q.breakable()
-                q.text("queue_id = ");
-                q.text("%#x" % self.queue_id)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[11] = enqueue
-
-class nicira(experimenter):
-    subtypes = {}
-
-    type = 65535
-    experimenter = 8992
-
-    def __init__(self, subtype=None):
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!H", self.subtype))
-        packed.append('\x00' * 2)
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 8)
-        subclass = nicira.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = nicira()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 8992)
-        obj.subtype = reader.read("!H")[0]
-        reader.skip(2)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.subtype != other.subtype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("nicira {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-experimenter.subtypes[8992] = nicira
-
-class nicira_dec_ttl(nicira):
-    type = 65535
-    experimenter = 8992
-    subtype = 18
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!H", self.subtype))
-        packed.append('\x00' * 2)
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = nicira_dec_ttl()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 8992)
-        _subtype = reader.read("!H")[0]
-        assert(_subtype == 18)
-        reader.skip(2)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("nicira_dec_ttl {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-nicira.subtypes[18] = nicira_dec_ttl
-
-class output(action):
-    type = 0
-
-    def __init__(self, port=None, max_len=None):
-        if port != None:
-            self.port = port
-        else:
-            self.port = 0
-        if max_len != None:
-            self.max_len = max_len
-        else:
-            self.max_len = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(util.pack_port_no(self.port))
-        packed.append(struct.pack("!H", self.max_len))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = output()
-        _type = reader.read("!H")[0]
-        assert(_type == 0)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.port = util.unpack_port_no(reader)
-        obj.max_len = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.port != other.port: return False
-        if self.max_len != other.max_len: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("output {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("port = ");
-                q.text(util.pretty_port(self.port))
-                q.text(","); q.breakable()
-                q.text("max_len = ");
-                q.text("%#x" % self.max_len)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[0] = output
-
-class set_dl_dst(action):
-    type = 5
-
-    def __init__(self, dl_addr=None):
-        if dl_addr != None:
-            self.dl_addr = dl_addr
-        else:
-            self.dl_addr = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!6B", *self.dl_addr))
-        packed.append('\x00' * 6)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_dl_dst()
-        _type = reader.read("!H")[0]
-        assert(_type == 5)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.dl_addr = list(reader.read('!6B'))
-        reader.skip(6)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.dl_addr != other.dl_addr: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_dl_dst {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("dl_addr = ");
-                q.text(util.pretty_mac(self.dl_addr))
-            q.breakable()
-        q.text('}')
-
-action.subtypes[5] = set_dl_dst
-
-class set_dl_src(action):
-    type = 4
-
-    def __init__(self, dl_addr=None):
-        if dl_addr != None:
-            self.dl_addr = dl_addr
-        else:
-            self.dl_addr = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!6B", *self.dl_addr))
-        packed.append('\x00' * 6)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_dl_src()
-        _type = reader.read("!H")[0]
-        assert(_type == 4)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.dl_addr = list(reader.read('!6B'))
-        reader.skip(6)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.dl_addr != other.dl_addr: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_dl_src {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("dl_addr = ");
-                q.text(util.pretty_mac(self.dl_addr))
-            q.breakable()
-        q.text('}')
-
-action.subtypes[4] = set_dl_src
-
-class set_nw_dst(action):
-    type = 7
-
-    def __init__(self, nw_addr=None):
-        if nw_addr != None:
-            self.nw_addr = nw_addr
-        else:
-            self.nw_addr = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.nw_addr))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_nw_dst()
-        _type = reader.read("!H")[0]
-        assert(_type == 7)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.nw_addr = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.nw_addr != other.nw_addr: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_nw_dst {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("nw_addr = ");
-                q.text("%#x" % self.nw_addr)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[7] = set_nw_dst
-
-class set_nw_src(action):
-    type = 6
-
-    def __init__(self, nw_addr=None):
-        if nw_addr != None:
-            self.nw_addr = nw_addr
-        else:
-            self.nw_addr = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.nw_addr))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_nw_src()
-        _type = reader.read("!H")[0]
-        assert(_type == 6)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.nw_addr = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.nw_addr != other.nw_addr: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_nw_src {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("nw_addr = ");
-                q.text("%#x" % self.nw_addr)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[6] = set_nw_src
-
-class set_nw_tos(action):
-    type = 8
-
-    def __init__(self, nw_tos=None):
-        if nw_tos != None:
-            self.nw_tos = nw_tos
-        else:
-            self.nw_tos = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!B", self.nw_tos))
-        packed.append('\x00' * 3)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_nw_tos()
-        _type = reader.read("!H")[0]
-        assert(_type == 8)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.nw_tos = reader.read("!B")[0]
-        reader.skip(3)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.nw_tos != other.nw_tos: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_nw_tos {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("nw_tos = ");
-                q.text("%#x" % self.nw_tos)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[8] = set_nw_tos
-
-class set_tp_dst(action):
-    type = 10
-
-    def __init__(self, tp_port=None):
-        if tp_port != None:
-            self.tp_port = tp_port
-        else:
-            self.tp_port = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!H", self.tp_port))
-        packed.append('\x00' * 2)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_tp_dst()
-        _type = reader.read("!H")[0]
-        assert(_type == 10)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.tp_port = reader.read("!H")[0]
-        reader.skip(2)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.tp_port != other.tp_port: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_tp_dst {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("tp_port = ");
-                q.text("%#x" % self.tp_port)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[10] = set_tp_dst
-
-class set_tp_src(action):
-    type = 9
-
-    def __init__(self, tp_port=None):
-        if tp_port != None:
-            self.tp_port = tp_port
-        else:
-            self.tp_port = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!H", self.tp_port))
-        packed.append('\x00' * 2)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_tp_src()
-        _type = reader.read("!H")[0]
-        assert(_type == 9)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.tp_port = reader.read("!H")[0]
-        reader.skip(2)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.tp_port != other.tp_port: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_tp_src {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("tp_port = ");
-                q.text("%#x" % self.tp_port)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[9] = set_tp_src
-
-class set_vlan_pcp(action):
-    type = 2
-
-    def __init__(self, vlan_pcp=None):
-        if vlan_pcp != None:
-            self.vlan_pcp = vlan_pcp
-        else:
-            self.vlan_pcp = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!B", self.vlan_pcp))
-        packed.append('\x00' * 3)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_vlan_pcp()
-        _type = reader.read("!H")[0]
-        assert(_type == 2)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.vlan_pcp = reader.read("!B")[0]
-        reader.skip(3)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.vlan_pcp != other.vlan_pcp: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_vlan_pcp {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("vlan_pcp = ");
-                q.text("%#x" % self.vlan_pcp)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[2] = set_vlan_pcp
-
-class set_vlan_vid(action):
-    type = 1
-
-    def __init__(self, vlan_vid=None):
-        if vlan_vid != None:
-            self.vlan_vid = vlan_vid
-        else:
-            self.vlan_vid = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!H", self.vlan_vid))
-        packed.append('\x00' * 2)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_vlan_vid()
-        _type = reader.read("!H")[0]
-        assert(_type == 1)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.vlan_vid = reader.read("!H")[0]
-        reader.skip(2)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.vlan_vid != other.vlan_vid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_vlan_vid {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("vlan_vid = ");
-                q.text("%#x" % self.vlan_vid)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[1] = set_vlan_vid
-
-class strip_vlan(action):
-    type = 3
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = strip_vlan()
-        _type = reader.read("!H")[0]
-        assert(_type == 3)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("strip_vlan {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action.subtypes[3] = strip_vlan
-
-
diff --git a/python/ofagent/loxi/of10/common.py b/python/ofagent/loxi/of10/common.py
deleted file mode 100644
index e7bd77d..0000000
--- a/python/ofagent/loxi/of10/common.py
+++ /dev/null
@@ -1,1312 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template module.py
-# Do not modify
-
-import struct
-import loxi
-import util
-import loxi.generic_util
-
-import sys
-ofp = sys.modules['loxi.of10']
-
-class bsn_interface(loxi.OFObject):
-
-    def __init__(self, hw_addr=None, name=None, ipv4_addr=None, ipv4_netmask=None):
-        if hw_addr != None:
-            self.hw_addr = hw_addr
-        else:
-            self.hw_addr = [0,0,0,0,0,0]
-        if name != None:
-            self.name = name
-        else:
-            self.name = ""
-        if ipv4_addr != None:
-            self.ipv4_addr = ipv4_addr
-        else:
-            self.ipv4_addr = 0
-        if ipv4_netmask != None:
-            self.ipv4_netmask = ipv4_netmask
-        else:
-            self.ipv4_netmask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!6B", *self.hw_addr))
-        packed.append('\x00' * 2)
-        packed.append(struct.pack("!16s", self.name))
-        packed.append(struct.pack("!L", self.ipv4_addr))
-        packed.append(struct.pack("!L", self.ipv4_netmask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_interface()
-        obj.hw_addr = list(reader.read('!6B'))
-        reader.skip(2)
-        obj.name = reader.read("!16s")[0].rstrip("\x00")
-        obj.ipv4_addr = reader.read("!L")[0]
-        obj.ipv4_netmask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.hw_addr != other.hw_addr: return False
-        if self.name != other.name: return False
-        if self.ipv4_addr != other.ipv4_addr: return False
-        if self.ipv4_netmask != other.ipv4_netmask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_interface {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("hw_addr = ");
-                q.text(util.pretty_mac(self.hw_addr))
-                q.text(","); q.breakable()
-                q.text("name = ");
-                q.pp(self.name)
-                q.text(","); q.breakable()
-                q.text("ipv4_addr = ");
-                q.text(util.pretty_ipv4(self.ipv4_addr))
-                q.text(","); q.breakable()
-                q.text("ipv4_netmask = ");
-                q.text(util.pretty_ipv4(self.ipv4_netmask))
-            q.breakable()
-        q.text('}')
-
-
-class bsn_vport(loxi.OFObject):
-    subtypes = {}
-
-
-    def __init__(self, type=None):
-        if type != None:
-            self.type = type
-        else:
-            self.type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 0)
-        subclass = bsn_vport.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = bsn_vport()
-        obj.type = reader.read("!H")[0]
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type != other.type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vport {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-
-class bsn_vport_l2gre(bsn_vport):
-    type = 1
-
-    def __init__(self, flags=None, port_no=None, loopback_port_no=None, local_mac=None, nh_mac=None, src_ip=None, dst_ip=None, dscp=None, ttl=None, vpn=None, rate_limit=None, if_name=None):
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if loopback_port_no != None:
-            self.loopback_port_no = loopback_port_no
-        else:
-            self.loopback_port_no = 0
-        if local_mac != None:
-            self.local_mac = local_mac
-        else:
-            self.local_mac = [0,0,0,0,0,0]
-        if nh_mac != None:
-            self.nh_mac = nh_mac
-        else:
-            self.nh_mac = [0,0,0,0,0,0]
-        if src_ip != None:
-            self.src_ip = src_ip
-        else:
-            self.src_ip = 0
-        if dst_ip != None:
-            self.dst_ip = dst_ip
-        else:
-            self.dst_ip = 0
-        if dscp != None:
-            self.dscp = dscp
-        else:
-            self.dscp = 0
-        if ttl != None:
-            self.ttl = ttl
-        else:
-            self.ttl = 0
-        if vpn != None:
-            self.vpn = vpn
-        else:
-            self.vpn = 0
-        if rate_limit != None:
-            self.rate_limit = rate_limit
-        else:
-            self.rate_limit = 0
-        if if_name != None:
-            self.if_name = if_name
-        else:
-            self.if_name = ""
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.flags))
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(util.pack_port_no(self.loopback_port_no))
-        packed.append(struct.pack("!6B", *self.local_mac))
-        packed.append(struct.pack("!6B", *self.nh_mac))
-        packed.append(struct.pack("!L", self.src_ip))
-        packed.append(struct.pack("!L", self.dst_ip))
-        packed.append(struct.pack("!B", self.dscp))
-        packed.append(struct.pack("!B", self.ttl))
-        packed.append('\x00' * 2)
-        packed.append(struct.pack("!L", self.vpn))
-        packed.append(struct.pack("!L", self.rate_limit))
-        packed.append(struct.pack("!16s", self.if_name))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_vport_l2gre()
-        _type = reader.read("!H")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.flags = reader.read("!L")[0]
-        obj.port_no = util.unpack_port_no(reader)
-        obj.loopback_port_no = util.unpack_port_no(reader)
-        obj.local_mac = list(reader.read('!6B'))
-        obj.nh_mac = list(reader.read('!6B'))
-        obj.src_ip = reader.read("!L")[0]
-        obj.dst_ip = reader.read("!L")[0]
-        obj.dscp = reader.read("!B")[0]
-        obj.ttl = reader.read("!B")[0]
-        reader.skip(2)
-        obj.vpn = reader.read("!L")[0]
-        obj.rate_limit = reader.read("!L")[0]
-        obj.if_name = reader.read("!16s")[0].rstrip("\x00")
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.flags != other.flags: return False
-        if self.port_no != other.port_no: return False
-        if self.loopback_port_no != other.loopback_port_no: return False
-        if self.local_mac != other.local_mac: return False
-        if self.nh_mac != other.nh_mac: return False
-        if self.src_ip != other.src_ip: return False
-        if self.dst_ip != other.dst_ip: return False
-        if self.dscp != other.dscp: return False
-        if self.ttl != other.ttl: return False
-        if self.vpn != other.vpn: return False
-        if self.rate_limit != other.rate_limit: return False
-        if self.if_name != other.if_name: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vport_l2gre {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("loopback_port_no = ");
-                q.text(util.pretty_port(self.loopback_port_no))
-                q.text(","); q.breakable()
-                q.text("local_mac = ");
-                q.text(util.pretty_mac(self.local_mac))
-                q.text(","); q.breakable()
-                q.text("nh_mac = ");
-                q.text(util.pretty_mac(self.nh_mac))
-                q.text(","); q.breakable()
-                q.text("src_ip = ");
-                q.text(util.pretty_ipv4(self.src_ip))
-                q.text(","); q.breakable()
-                q.text("dst_ip = ");
-                q.text(util.pretty_ipv4(self.dst_ip))
-                q.text(","); q.breakable()
-                q.text("dscp = ");
-                q.text("%#x" % self.dscp)
-                q.text(","); q.breakable()
-                q.text("ttl = ");
-                q.text("%#x" % self.ttl)
-                q.text(","); q.breakable()
-                q.text("vpn = ");
-                q.text("%#x" % self.vpn)
-                q.text(","); q.breakable()
-                q.text("rate_limit = ");
-                q.text("%#x" % self.rate_limit)
-                q.text(","); q.breakable()
-                q.text("if_name = ");
-                q.pp(self.if_name)
-            q.breakable()
-        q.text('}')
-
-bsn_vport.subtypes[1] = bsn_vport_l2gre
-
-class bsn_vport_q_in_q(bsn_vport):
-    type = 0
-
-    def __init__(self, port_no=None, ingress_tpid=None, ingress_vlan_id=None, egress_tpid=None, egress_vlan_id=None, if_name=None):
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if ingress_tpid != None:
-            self.ingress_tpid = ingress_tpid
-        else:
-            self.ingress_tpid = 0
-        if ingress_vlan_id != None:
-            self.ingress_vlan_id = ingress_vlan_id
-        else:
-            self.ingress_vlan_id = 0
-        if egress_tpid != None:
-            self.egress_tpid = egress_tpid
-        else:
-            self.egress_tpid = 0
-        if egress_vlan_id != None:
-            self.egress_vlan_id = egress_vlan_id
-        else:
-            self.egress_vlan_id = 0
-        if if_name != None:
-            self.if_name = if_name
-        else:
-            self.if_name = ""
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.port_no))
-        packed.append(struct.pack("!H", self.ingress_tpid))
-        packed.append(struct.pack("!H", self.ingress_vlan_id))
-        packed.append(struct.pack("!H", self.egress_tpid))
-        packed.append(struct.pack("!H", self.egress_vlan_id))
-        packed.append(struct.pack("!16s", self.if_name))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_vport_q_in_q()
-        _type = reader.read("!H")[0]
-        assert(_type == 0)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.port_no = reader.read("!L")[0]
-        obj.ingress_tpid = reader.read("!H")[0]
-        obj.ingress_vlan_id = reader.read("!H")[0]
-        obj.egress_tpid = reader.read("!H")[0]
-        obj.egress_vlan_id = reader.read("!H")[0]
-        obj.if_name = reader.read("!16s")[0].rstrip("\x00")
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.port_no != other.port_no: return False
-        if self.ingress_tpid != other.ingress_tpid: return False
-        if self.ingress_vlan_id != other.ingress_vlan_id: return False
-        if self.egress_tpid != other.egress_tpid: return False
-        if self.egress_vlan_id != other.egress_vlan_id: return False
-        if self.if_name != other.if_name: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vport_q_in_q {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("port_no = ");
-                q.text("%#x" % self.port_no)
-                q.text(","); q.breakable()
-                q.text("ingress_tpid = ");
-                q.text("%#x" % self.ingress_tpid)
-                q.text(","); q.breakable()
-                q.text("ingress_vlan_id = ");
-                q.text("%#x" % self.ingress_vlan_id)
-                q.text(","); q.breakable()
-                q.text("egress_tpid = ");
-                q.text("%#x" % self.egress_tpid)
-                q.text(","); q.breakable()
-                q.text("egress_vlan_id = ");
-                q.text("%#x" % self.egress_vlan_id)
-                q.text(","); q.breakable()
-                q.text("if_name = ");
-                q.pp(self.if_name)
-            q.breakable()
-        q.text('}')
-
-bsn_vport.subtypes[0] = bsn_vport_q_in_q
-
-class flow_stats_entry(loxi.OFObject):
-
-    def __init__(self, table_id=None, match=None, duration_sec=None, duration_nsec=None, priority=None, idle_timeout=None, hard_timeout=None, cookie=None, packet_count=None, byte_count=None, actions=None):
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        if duration_sec != None:
-            self.duration_sec = duration_sec
-        else:
-            self.duration_sec = 0
-        if duration_nsec != None:
-            self.duration_nsec = duration_nsec
-        else:
-            self.duration_nsec = 0
-        if priority != None:
-            self.priority = priority
-        else:
-            self.priority = 0
-        if idle_timeout != None:
-            self.idle_timeout = idle_timeout
-        else:
-            self.idle_timeout = 0
-        if hard_timeout != None:
-            self.hard_timeout = hard_timeout
-        else:
-            self.hard_timeout = 0
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if packet_count != None:
-            self.packet_count = packet_count
-        else:
-            self.packet_count = 0
-        if byte_count != None:
-            self.byte_count = byte_count
-        else:
-            self.byte_count = 0
-        if actions != None:
-            self.actions = actions
-        else:
-            self.actions = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 0
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append('\x00' * 1)
-        packed.append(self.match.pack())
-        packed.append(struct.pack("!L", self.duration_sec))
-        packed.append(struct.pack("!L", self.duration_nsec))
-        packed.append(struct.pack("!H", self.priority))
-        packed.append(struct.pack("!H", self.idle_timeout))
-        packed.append(struct.pack("!H", self.hard_timeout))
-        packed.append('\x00' * 6)
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(struct.pack("!Q", self.packet_count))
-        packed.append(struct.pack("!Q", self.byte_count))
-        packed.append(loxi.generic_util.pack_list(self.actions))
-        length = sum([len(x) for x in packed])
-        packed[0] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_stats_entry()
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 2)
-        obj.table_id = reader.read("!B")[0]
-        reader.skip(1)
-        obj.match = ofp.match.unpack(reader)
-        obj.duration_sec = reader.read("!L")[0]
-        obj.duration_nsec = reader.read("!L")[0]
-        obj.priority = reader.read("!H")[0]
-        obj.idle_timeout = reader.read("!H")[0]
-        obj.hard_timeout = reader.read("!H")[0]
-        reader.skip(6)
-        obj.cookie = reader.read("!Q")[0]
-        obj.packet_count = reader.read("!Q")[0]
-        obj.byte_count = reader.read("!Q")[0]
-        obj.actions = loxi.generic_util.unpack_list(reader, ofp.action.action.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.table_id != other.table_id: return False
-        if self.match != other.match: return False
-        if self.duration_sec != other.duration_sec: return False
-        if self.duration_nsec != other.duration_nsec: return False
-        if self.priority != other.priority: return False
-        if self.idle_timeout != other.idle_timeout: return False
-        if self.hard_timeout != other.hard_timeout: return False
-        if self.cookie != other.cookie: return False
-        if self.packet_count != other.packet_count: return False
-        if self.byte_count != other.byte_count: return False
-        if self.actions != other.actions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-                q.text(","); q.breakable()
-                q.text("duration_sec = ");
-                q.text("%#x" % self.duration_sec)
-                q.text(","); q.breakable()
-                q.text("duration_nsec = ");
-                q.text("%#x" % self.duration_nsec)
-                q.text(","); q.breakable()
-                q.text("priority = ");
-                q.text("%#x" % self.priority)
-                q.text(","); q.breakable()
-                q.text("idle_timeout = ");
-                q.text("%#x" % self.idle_timeout)
-                q.text(","); q.breakable()
-                q.text("hard_timeout = ");
-                q.text("%#x" % self.hard_timeout)
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("packet_count = ");
-                q.text("%#x" % self.packet_count)
-                q.text(","); q.breakable()
-                q.text("byte_count = ");
-                q.text("%#x" % self.byte_count)
-                q.text(","); q.breakable()
-                q.text("actions = ");
-                q.pp(self.actions)
-            q.breakable()
-        q.text('}')
-
-
-class match_v1(loxi.OFObject):
-
-    def __init__(self, wildcards=None, in_port=None, eth_src=None, eth_dst=None, vlan_vid=None, vlan_pcp=None, eth_type=None, ip_dscp=None, ip_proto=None, ipv4_src=None, ipv4_dst=None, tcp_src=None, tcp_dst=None):
-        if wildcards != None:
-            self.wildcards = wildcards
-        else:
-            self.wildcards = util.init_wc_bmap()
-        if in_port != None:
-            self.in_port = in_port
-        else:
-            self.in_port = 0
-        if eth_src != None:
-            self.eth_src = eth_src
-        else:
-            self.eth_src = [0,0,0,0,0,0]
-        if eth_dst != None:
-            self.eth_dst = eth_dst
-        else:
-            self.eth_dst = [0,0,0,0,0,0]
-        if vlan_vid != None:
-            self.vlan_vid = vlan_vid
-        else:
-            self.vlan_vid = 0
-        if vlan_pcp != None:
-            self.vlan_pcp = vlan_pcp
-        else:
-            self.vlan_pcp = 0
-        if eth_type != None:
-            self.eth_type = eth_type
-        else:
-            self.eth_type = 0
-        if ip_dscp != None:
-            self.ip_dscp = ip_dscp
-        else:
-            self.ip_dscp = 0
-        if ip_proto != None:
-            self.ip_proto = ip_proto
-        else:
-            self.ip_proto = 0
-        if ipv4_src != None:
-            self.ipv4_src = ipv4_src
-        else:
-            self.ipv4_src = 0
-        if ipv4_dst != None:
-            self.ipv4_dst = ipv4_dst
-        else:
-            self.ipv4_dst = 0
-        if tcp_src != None:
-            self.tcp_src = tcp_src
-        else:
-            self.tcp_src = 0
-        if tcp_dst != None:
-            self.tcp_dst = tcp_dst
-        else:
-            self.tcp_dst = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(util.pack_wc_bmap(self.wildcards))
-        packed.append(util.pack_port_no(self.in_port))
-        packed.append(struct.pack("!6B", *self.eth_src))
-        packed.append(struct.pack("!6B", *self.eth_dst))
-        packed.append(struct.pack("!H", self.vlan_vid))
-        packed.append(struct.pack("!B", self.vlan_pcp))
-        packed.append('\x00' * 1)
-        packed.append(struct.pack("!H", self.eth_type))
-        packed.append(struct.pack("!B", self.ip_dscp))
-        packed.append(struct.pack("!B", self.ip_proto))
-        packed.append('\x00' * 2)
-        packed.append(struct.pack("!L", self.ipv4_src))
-        packed.append(struct.pack("!L", self.ipv4_dst))
-        packed.append(struct.pack("!H", self.tcp_src))
-        packed.append(struct.pack("!H", self.tcp_dst))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = match_v1()
-        obj.wildcards = util.unpack_wc_bmap(reader)
-        obj.in_port = util.unpack_port_no(reader)
-        obj.eth_src = list(reader.read('!6B'))
-        obj.eth_dst = list(reader.read('!6B'))
-        obj.vlan_vid = reader.read("!H")[0]
-        obj.vlan_pcp = reader.read("!B")[0]
-        reader.skip(1)
-        obj.eth_type = reader.read("!H")[0]
-        obj.ip_dscp = reader.read("!B")[0]
-        obj.ip_proto = reader.read("!B")[0]
-        reader.skip(2)
-        obj.ipv4_src = reader.read("!L")[0]
-        obj.ipv4_dst = reader.read("!L")[0]
-        obj.tcp_src = reader.read("!H")[0]
-        obj.tcp_dst = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.wildcards != other.wildcards: return False
-        if self.in_port != other.in_port: return False
-        if self.eth_src != other.eth_src: return False
-        if self.eth_dst != other.eth_dst: return False
-        if self.vlan_vid != other.vlan_vid: return False
-        if self.vlan_pcp != other.vlan_pcp: return False
-        if self.eth_type != other.eth_type: return False
-        if self.ip_dscp != other.ip_dscp: return False
-        if self.ip_proto != other.ip_proto: return False
-        if self.ipv4_src != other.ipv4_src: return False
-        if self.ipv4_dst != other.ipv4_dst: return False
-        if self.tcp_src != other.tcp_src: return False
-        if self.tcp_dst != other.tcp_dst: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("match_v1 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("wildcards = ");
-                q.text(util.pretty_wildcards(self.wildcards))
-                q.text(","); q.breakable()
-                q.text("in_port = ");
-                q.text(util.pretty_port(self.in_port))
-                q.text(","); q.breakable()
-                q.text("eth_src = ");
-                q.text(util.pretty_mac(self.eth_src))
-                q.text(","); q.breakable()
-                q.text("eth_dst = ");
-                q.text(util.pretty_mac(self.eth_dst))
-                q.text(","); q.breakable()
-                q.text("vlan_vid = ");
-                q.text("%#x" % self.vlan_vid)
-                q.text(","); q.breakable()
-                q.text("vlan_pcp = ");
-                q.text("%#x" % self.vlan_pcp)
-                q.text(","); q.breakable()
-                q.text("eth_type = ");
-                q.text("%#x" % self.eth_type)
-                q.text(","); q.breakable()
-                q.text("ip_dscp = ");
-                q.text("%#x" % self.ip_dscp)
-                q.text(","); q.breakable()
-                q.text("ip_proto = ");
-                q.text("%#x" % self.ip_proto)
-                q.text(","); q.breakable()
-                q.text("ipv4_src = ");
-                q.text(util.pretty_ipv4(self.ipv4_src))
-                q.text(","); q.breakable()
-                q.text("ipv4_dst = ");
-                q.text(util.pretty_ipv4(self.ipv4_dst))
-                q.text(","); q.breakable()
-                q.text("tcp_src = ");
-                q.text("%#x" % self.tcp_src)
-                q.text(","); q.breakable()
-                q.text("tcp_dst = ");
-                q.text("%#x" % self.tcp_dst)
-            q.breakable()
-        q.text('}')
-
-
-class packet_queue(loxi.OFObject):
-
-    def __init__(self, queue_id=None, properties=None):
-        if queue_id != None:
-            self.queue_id = queue_id
-        else:
-            self.queue_id = 0
-        if properties != None:
-            self.properties = properties
-        else:
-            self.properties = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.queue_id))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 2)
-        packed.append(loxi.generic_util.pack_list(self.properties))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = packet_queue()
-        obj.queue_id = reader.read("!L")[0]
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 6)
-        reader.skip(2)
-        obj.properties = loxi.generic_util.unpack_list(reader, ofp.common.queue_prop.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.queue_id != other.queue_id: return False
-        if self.properties != other.properties: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("packet_queue {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("queue_id = ");
-                q.text("%#x" % self.queue_id)
-                q.text(","); q.breakable()
-                q.text("properties = ");
-                q.pp(self.properties)
-            q.breakable()
-        q.text('}')
-
-
-class port_desc(loxi.OFObject):
-
-    def __init__(self, port_no=None, hw_addr=None, name=None, config=None, state=None, curr=None, advertised=None, supported=None, peer=None):
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if hw_addr != None:
-            self.hw_addr = hw_addr
-        else:
-            self.hw_addr = [0,0,0,0,0,0]
-        if name != None:
-            self.name = name
-        else:
-            self.name = ""
-        if config != None:
-            self.config = config
-        else:
-            self.config = 0
-        if state != None:
-            self.state = state
-        else:
-            self.state = 0
-        if curr != None:
-            self.curr = curr
-        else:
-            self.curr = 0
-        if advertised != None:
-            self.advertised = advertised
-        else:
-            self.advertised = 0
-        if supported != None:
-            self.supported = supported
-        else:
-            self.supported = 0
-        if peer != None:
-            self.peer = peer
-        else:
-            self.peer = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(struct.pack("!6B", *self.hw_addr))
-        packed.append(struct.pack("!16s", self.name))
-        packed.append(struct.pack("!L", self.config))
-        packed.append(struct.pack("!L", self.state))
-        packed.append(struct.pack("!L", self.curr))
-        packed.append(struct.pack("!L", self.advertised))
-        packed.append(struct.pack("!L", self.supported))
-        packed.append(struct.pack("!L", self.peer))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = port_desc()
-        obj.port_no = util.unpack_port_no(reader)
-        obj.hw_addr = list(reader.read('!6B'))
-        obj.name = reader.read("!16s")[0].rstrip("\x00")
-        obj.config = reader.read("!L")[0]
-        obj.state = reader.read("!L")[0]
-        obj.curr = reader.read("!L")[0]
-        obj.advertised = reader.read("!L")[0]
-        obj.supported = reader.read("!L")[0]
-        obj.peer = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.port_no != other.port_no: return False
-        if self.hw_addr != other.hw_addr: return False
-        if self.name != other.name: return False
-        if self.config != other.config: return False
-        if self.state != other.state: return False
-        if self.curr != other.curr: return False
-        if self.advertised != other.advertised: return False
-        if self.supported != other.supported: return False
-        if self.peer != other.peer: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port_desc {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("hw_addr = ");
-                q.text(util.pretty_mac(self.hw_addr))
-                q.text(","); q.breakable()
-                q.text("name = ");
-                q.pp(self.name)
-                q.text(","); q.breakable()
-                q.text("config = ");
-                q.text("%#x" % self.config)
-                q.text(","); q.breakable()
-                q.text("state = ");
-                q.text("%#x" % self.state)
-                q.text(","); q.breakable()
-                q.text("curr = ");
-                q.text("%#x" % self.curr)
-                q.text(","); q.breakable()
-                q.text("advertised = ");
-                q.text("%#x" % self.advertised)
-                q.text(","); q.breakable()
-                q.text("supported = ");
-                q.text("%#x" % self.supported)
-                q.text(","); q.breakable()
-                q.text("peer = ");
-                q.text("%#x" % self.peer)
-            q.breakable()
-        q.text('}')
-
-
-class port_stats_entry(loxi.OFObject):
-
-    def __init__(self, port_no=None, rx_packets=None, tx_packets=None, rx_bytes=None, tx_bytes=None, rx_dropped=None, tx_dropped=None, rx_errors=None, tx_errors=None, rx_frame_err=None, rx_over_err=None, rx_crc_err=None, collisions=None):
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if rx_packets != None:
-            self.rx_packets = rx_packets
-        else:
-            self.rx_packets = 0
-        if tx_packets != None:
-            self.tx_packets = tx_packets
-        else:
-            self.tx_packets = 0
-        if rx_bytes != None:
-            self.rx_bytes = rx_bytes
-        else:
-            self.rx_bytes = 0
-        if tx_bytes != None:
-            self.tx_bytes = tx_bytes
-        else:
-            self.tx_bytes = 0
-        if rx_dropped != None:
-            self.rx_dropped = rx_dropped
-        else:
-            self.rx_dropped = 0
-        if tx_dropped != None:
-            self.tx_dropped = tx_dropped
-        else:
-            self.tx_dropped = 0
-        if rx_errors != None:
-            self.rx_errors = rx_errors
-        else:
-            self.rx_errors = 0
-        if tx_errors != None:
-            self.tx_errors = tx_errors
-        else:
-            self.tx_errors = 0
-        if rx_frame_err != None:
-            self.rx_frame_err = rx_frame_err
-        else:
-            self.rx_frame_err = 0
-        if rx_over_err != None:
-            self.rx_over_err = rx_over_err
-        else:
-            self.rx_over_err = 0
-        if rx_crc_err != None:
-            self.rx_crc_err = rx_crc_err
-        else:
-            self.rx_crc_err = 0
-        if collisions != None:
-            self.collisions = collisions
-        else:
-            self.collisions = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append('\x00' * 6)
-        packed.append(struct.pack("!Q", self.rx_packets))
-        packed.append(struct.pack("!Q", self.tx_packets))
-        packed.append(struct.pack("!Q", self.rx_bytes))
-        packed.append(struct.pack("!Q", self.tx_bytes))
-        packed.append(struct.pack("!Q", self.rx_dropped))
-        packed.append(struct.pack("!Q", self.tx_dropped))
-        packed.append(struct.pack("!Q", self.rx_errors))
-        packed.append(struct.pack("!Q", self.tx_errors))
-        packed.append(struct.pack("!Q", self.rx_frame_err))
-        packed.append(struct.pack("!Q", self.rx_over_err))
-        packed.append(struct.pack("!Q", self.rx_crc_err))
-        packed.append(struct.pack("!Q", self.collisions))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = port_stats_entry()
-        obj.port_no = util.unpack_port_no(reader)
-        reader.skip(6)
-        obj.rx_packets = reader.read("!Q")[0]
-        obj.tx_packets = reader.read("!Q")[0]
-        obj.rx_bytes = reader.read("!Q")[0]
-        obj.tx_bytes = reader.read("!Q")[0]
-        obj.rx_dropped = reader.read("!Q")[0]
-        obj.tx_dropped = reader.read("!Q")[0]
-        obj.rx_errors = reader.read("!Q")[0]
-        obj.tx_errors = reader.read("!Q")[0]
-        obj.rx_frame_err = reader.read("!Q")[0]
-        obj.rx_over_err = reader.read("!Q")[0]
-        obj.rx_crc_err = reader.read("!Q")[0]
-        obj.collisions = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.port_no != other.port_no: return False
-        if self.rx_packets != other.rx_packets: return False
-        if self.tx_packets != other.tx_packets: return False
-        if self.rx_bytes != other.rx_bytes: return False
-        if self.tx_bytes != other.tx_bytes: return False
-        if self.rx_dropped != other.rx_dropped: return False
-        if self.tx_dropped != other.tx_dropped: return False
-        if self.rx_errors != other.rx_errors: return False
-        if self.tx_errors != other.tx_errors: return False
-        if self.rx_frame_err != other.rx_frame_err: return False
-        if self.rx_over_err != other.rx_over_err: return False
-        if self.rx_crc_err != other.rx_crc_err: return False
-        if self.collisions != other.collisions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("rx_packets = ");
-                q.text("%#x" % self.rx_packets)
-                q.text(","); q.breakable()
-                q.text("tx_packets = ");
-                q.text("%#x" % self.tx_packets)
-                q.text(","); q.breakable()
-                q.text("rx_bytes = ");
-                q.text("%#x" % self.rx_bytes)
-                q.text(","); q.breakable()
-                q.text("tx_bytes = ");
-                q.text("%#x" % self.tx_bytes)
-                q.text(","); q.breakable()
-                q.text("rx_dropped = ");
-                q.text("%#x" % self.rx_dropped)
-                q.text(","); q.breakable()
-                q.text("tx_dropped = ");
-                q.text("%#x" % self.tx_dropped)
-                q.text(","); q.breakable()
-                q.text("rx_errors = ");
-                q.text("%#x" % self.rx_errors)
-                q.text(","); q.breakable()
-                q.text("tx_errors = ");
-                q.text("%#x" % self.tx_errors)
-                q.text(","); q.breakable()
-                q.text("rx_frame_err = ");
-                q.text("%#x" % self.rx_frame_err)
-                q.text(","); q.breakable()
-                q.text("rx_over_err = ");
-                q.text("%#x" % self.rx_over_err)
-                q.text(","); q.breakable()
-                q.text("rx_crc_err = ");
-                q.text("%#x" % self.rx_crc_err)
-                q.text(","); q.breakable()
-                q.text("collisions = ");
-                q.text("%#x" % self.collisions)
-            q.breakable()
-        q.text('}')
-
-
-class queue_prop(loxi.OFObject):
-    subtypes = {}
-
-
-    def __init__(self, type=None):
-        if type != None:
-            self.type = type
-        else:
-            self.type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 0)
-        subclass = queue_prop.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = queue_prop()
-        obj.type = reader.read("!H")[0]
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type != other.type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_prop {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-
-class queue_prop_min_rate(queue_prop):
-    type = 1
-
-    def __init__(self, rate=None):
-        if rate != None:
-            self.rate = rate
-        else:
-            self.rate = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!H", self.rate))
-        packed.append('\x00' * 6)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = queue_prop_min_rate()
-        _type = reader.read("!H")[0]
-        assert(_type == 1)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        obj.rate = reader.read("!H")[0]
-        reader.skip(6)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.rate != other.rate: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_prop_min_rate {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("rate = ");
-                q.text("%#x" % self.rate)
-            q.breakable()
-        q.text('}')
-
-queue_prop.subtypes[1] = queue_prop_min_rate
-
-class queue_stats_entry(loxi.OFObject):
-
-    def __init__(self, port_no=None, queue_id=None, tx_bytes=None, tx_packets=None, tx_errors=None):
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if queue_id != None:
-            self.queue_id = queue_id
-        else:
-            self.queue_id = 0
-        if tx_bytes != None:
-            self.tx_bytes = tx_bytes
-        else:
-            self.tx_bytes = 0
-        if tx_packets != None:
-            self.tx_packets = tx_packets
-        else:
-            self.tx_packets = 0
-        if tx_errors != None:
-            self.tx_errors = tx_errors
-        else:
-            self.tx_errors = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append('\x00' * 2)
-        packed.append(struct.pack("!L", self.queue_id))
-        packed.append(struct.pack("!Q", self.tx_bytes))
-        packed.append(struct.pack("!Q", self.tx_packets))
-        packed.append(struct.pack("!Q", self.tx_errors))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = queue_stats_entry()
-        obj.port_no = util.unpack_port_no(reader)
-        reader.skip(2)
-        obj.queue_id = reader.read("!L")[0]
-        obj.tx_bytes = reader.read("!Q")[0]
-        obj.tx_packets = reader.read("!Q")[0]
-        obj.tx_errors = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.port_no != other.port_no: return False
-        if self.queue_id != other.queue_id: return False
-        if self.tx_bytes != other.tx_bytes: return False
-        if self.tx_packets != other.tx_packets: return False
-        if self.tx_errors != other.tx_errors: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("queue_id = ");
-                q.text("%#x" % self.queue_id)
-                q.text(","); q.breakable()
-                q.text("tx_bytes = ");
-                q.text("%#x" % self.tx_bytes)
-                q.text(","); q.breakable()
-                q.text("tx_packets = ");
-                q.text("%#x" % self.tx_packets)
-                q.text(","); q.breakable()
-                q.text("tx_errors = ");
-                q.text("%#x" % self.tx_errors)
-            q.breakable()
-        q.text('}')
-
-
-class table_stats_entry(loxi.OFObject):
-
-    def __init__(self, table_id=None, name=None, wildcards=None, max_entries=None, active_count=None, lookup_count=None, matched_count=None):
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if name != None:
-            self.name = name
-        else:
-            self.name = ""
-        if wildcards != None:
-            self.wildcards = wildcards
-        else:
-            self.wildcards = util.init_wc_bmap()
-        if max_entries != None:
-            self.max_entries = max_entries
-        else:
-            self.max_entries = 0
-        if active_count != None:
-            self.active_count = active_count
-        else:
-            self.active_count = 0
-        if lookup_count != None:
-            self.lookup_count = lookup_count
-        else:
-            self.lookup_count = 0
-        if matched_count != None:
-            self.matched_count = matched_count
-        else:
-            self.matched_count = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append('\x00' * 3)
-        packed.append(struct.pack("!32s", self.name))
-        packed.append(util.pack_wc_bmap(self.wildcards))
-        packed.append(struct.pack("!L", self.max_entries))
-        packed.append(struct.pack("!L", self.active_count))
-        packed.append(struct.pack("!Q", self.lookup_count))
-        packed.append(struct.pack("!Q", self.matched_count))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_stats_entry()
-        obj.table_id = reader.read("!B")[0]
-        reader.skip(3)
-        obj.name = reader.read("!32s")[0].rstrip("\x00")
-        obj.wildcards = util.unpack_wc_bmap(reader)
-        obj.max_entries = reader.read("!L")[0]
-        obj.active_count = reader.read("!L")[0]
-        obj.lookup_count = reader.read("!Q")[0]
-        obj.matched_count = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.table_id != other.table_id: return False
-        if self.name != other.name: return False
-        if self.wildcards != other.wildcards: return False
-        if self.max_entries != other.max_entries: return False
-        if self.active_count != other.active_count: return False
-        if self.lookup_count != other.lookup_count: return False
-        if self.matched_count != other.matched_count: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("name = ");
-                q.pp(self.name)
-                q.text(","); q.breakable()
-                q.text("wildcards = ");
-                q.text(util.pretty_wildcards(self.wildcards))
-                q.text(","); q.breakable()
-                q.text("max_entries = ");
-                q.text("%#x" % self.max_entries)
-                q.text(","); q.breakable()
-                q.text("active_count = ");
-                q.text("%#x" % self.active_count)
-                q.text(","); q.breakable()
-                q.text("lookup_count = ");
-                q.text("%#x" % self.lookup_count)
-                q.text(","); q.breakable()
-                q.text("matched_count = ");
-                q.text("%#x" % self.matched_count)
-            q.breakable()
-        q.text('}')
-
-
-
-match = match_v1
diff --git a/python/ofagent/loxi/of10/const.py b/python/ofagent/loxi/of10/const.py
deleted file mode 100644
index 01404ee..0000000
--- a/python/ofagent/loxi/of10/const.py
+++ /dev/null
@@ -1,535 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template const.py
-# Do not modify
-
-OFP_VERSION = 1
-
-# Identifiers from group macro_definitions
-OFP_MAX_TABLE_NAME_LEN = 32
-OFP_MAX_PORT_NAME_LEN = 16
-OFP_TCP_PORT = 6653
-OFP_SSL_PORT = 6653
-OFP_ETH_ALEN = 6
-OFP_DEFAULT_MISS_SEND_LEN = 128
-OFP_VLAN_NONE = 65535
-OFPFW_ICMP_TYPE = 64
-OFPFW_ICMP_CODE = 128
-OFP_DL_TYPE_ETH2_CUTOFF = 1536
-OFP_DL_TYPE_NOT_ETH_TYPE = 1535
-OFP_FLOW_PERMANENT = 0
-OFP_DEFAULT_PRIORITY = 32768
-DESC_STR_LEN = 256
-SERIAL_NUM_LEN = 32
-OFPQ_ALL = 4294967295
-OFPQ_MIN_RATE_UNCFG = 65535
-
-# Identifiers from group of_bsn_pdu_slot_num
-BSN_PDU_SLOT_NUM_ANY = 255
-
-of_bsn_pdu_slot_num_map = {
-    255: 'BSN_PDU_SLOT_NUM_ANY',
-}
-
-# Identifiers from group ofp_action_type
-OFPAT_OUTPUT = 0
-OFPAT_SET_VLAN_VID = 1
-OFPAT_SET_VLAN_PCP = 2
-OFPAT_STRIP_VLAN = 3
-OFPAT_SET_DL_SRC = 4
-OFPAT_SET_DL_DST = 5
-OFPAT_SET_NW_SRC = 6
-OFPAT_SET_NW_DST = 7
-OFPAT_SET_NW_TOS = 8
-OFPAT_SET_TP_SRC = 9
-OFPAT_SET_TP_DST = 10
-OFPAT_ENQUEUE = 11
-OFPAT_EXPERIMENTER = 65535
-
-ofp_action_type_map = {
-    0: 'OFPAT_OUTPUT',
-    1: 'OFPAT_SET_VLAN_VID',
-    2: 'OFPAT_SET_VLAN_PCP',
-    3: 'OFPAT_STRIP_VLAN',
-    4: 'OFPAT_SET_DL_SRC',
-    5: 'OFPAT_SET_DL_DST',
-    6: 'OFPAT_SET_NW_SRC',
-    7: 'OFPAT_SET_NW_DST',
-    8: 'OFPAT_SET_NW_TOS',
-    9: 'OFPAT_SET_TP_SRC',
-    10: 'OFPAT_SET_TP_DST',
-    11: 'OFPAT_ENQUEUE',
-    65535: 'OFPAT_EXPERIMENTER',
-}
-
-# Identifiers from group ofp_bad_action_code
-OFPBAC_BAD_TYPE = 0
-OFPBAC_BAD_LEN = 1
-OFPBAC_BAD_EXPERIMENTER = 2
-OFPBAC_BAD_EXPERIMENTER_TYPE = 3
-OFPBAC_BAD_OUT_PORT = 4
-OFPBAC_BAD_ARGUMENT = 5
-OFPBAC_EPERM = 6
-OFPBAC_TOO_MANY = 7
-OFPBAC_BAD_QUEUE = 8
-
-ofp_bad_action_code_map = {
-    0: 'OFPBAC_BAD_TYPE',
-    1: 'OFPBAC_BAD_LEN',
-    2: 'OFPBAC_BAD_EXPERIMENTER',
-    3: 'OFPBAC_BAD_EXPERIMENTER_TYPE',
-    4: 'OFPBAC_BAD_OUT_PORT',
-    5: 'OFPBAC_BAD_ARGUMENT',
-    6: 'OFPBAC_EPERM',
-    7: 'OFPBAC_TOO_MANY',
-    8: 'OFPBAC_BAD_QUEUE',
-}
-
-# Identifiers from group ofp_bad_request_code
-OFPBRC_BAD_VERSION = 0
-OFPBRC_BAD_TYPE = 1
-OFPBRC_BAD_STAT = 2
-OFPBRC_BAD_EXPERIMENTER = 3
-OFPBRC_BAD_SUBTYPE = 4
-OFPBRC_EPERM = 5
-OFPBRC_BAD_LEN = 6
-OFPBRC_BUFFER_EMPTY = 7
-OFPBRC_BUFFER_UNKNOWN = 8
-
-ofp_bad_request_code_map = {
-    0: 'OFPBRC_BAD_VERSION',
-    1: 'OFPBRC_BAD_TYPE',
-    2: 'OFPBRC_BAD_STAT',
-    3: 'OFPBRC_BAD_EXPERIMENTER',
-    4: 'OFPBRC_BAD_SUBTYPE',
-    5: 'OFPBRC_EPERM',
-    6: 'OFPBRC_BAD_LEN',
-    7: 'OFPBRC_BUFFER_EMPTY',
-    8: 'OFPBRC_BUFFER_UNKNOWN',
-}
-
-# Identifiers from group ofp_bsn_vport_l2gre_flags
-OF_BSN_VPORT_L2GRE_LOCAL_MAC_IS_VALID = 1
-OF_BSN_VPORT_L2GRE_DSCP_ASSIGN = 2
-OF_BSN_VPORT_L2GRE_DSCP_COPY = 4
-OF_BSN_VPORT_L2GRE_LOOPBACK_IS_VALID = 8
-OF_BSN_VPORT_L2GRE_RATE_LIMIT_IS_VALID = 16
-
-ofp_bsn_vport_l2gre_flags_map = {
-    1: 'OF_BSN_VPORT_L2GRE_LOCAL_MAC_IS_VALID',
-    2: 'OF_BSN_VPORT_L2GRE_DSCP_ASSIGN',
-    4: 'OF_BSN_VPORT_L2GRE_DSCP_COPY',
-    8: 'OF_BSN_VPORT_L2GRE_LOOPBACK_IS_VALID',
-    16: 'OF_BSN_VPORT_L2GRE_RATE_LIMIT_IS_VALID',
-}
-
-# Identifiers from group ofp_bsn_vport_q_in_q_untagged
-OF_BSN_VPORT_Q_IN_Q_UNTAGGED = 65535
-
-ofp_bsn_vport_q_in_q_untagged_map = {
-    65535: 'OF_BSN_VPORT_Q_IN_Q_UNTAGGED',
-}
-
-# Identifiers from group ofp_bsn_vport_status
-OF_BSN_VPORT_STATUS_OK = 0
-OF_BSN_VPORT_STATUS_FAILED = 1
-
-ofp_bsn_vport_status_map = {
-    0: 'OF_BSN_VPORT_STATUS_OK',
-    1: 'OF_BSN_VPORT_STATUS_FAILED',
-}
-
-# Identifiers from group ofp_capabilities
-OFPC_FLOW_STATS = 1
-OFPC_TABLE_STATS = 2
-OFPC_PORT_STATS = 4
-OFPC_STP = 8
-OFPC_RESERVED = 16
-OFPC_IP_REASM = 32
-OFPC_QUEUE_STATS = 64
-OFPC_ARP_MATCH_IP = 128
-
-ofp_capabilities_map = {
-    1: 'OFPC_FLOW_STATS',
-    2: 'OFPC_TABLE_STATS',
-    4: 'OFPC_PORT_STATS',
-    8: 'OFPC_STP',
-    16: 'OFPC_RESERVED',
-    32: 'OFPC_IP_REASM',
-    64: 'OFPC_QUEUE_STATS',
-    128: 'OFPC_ARP_MATCH_IP',
-}
-
-# Identifiers from group ofp_config_flags
-OFPC_FRAG_NORMAL = 0
-OFPC_FRAG_DROP = 1
-OFPC_FRAG_REASM = 2
-OFPC_FRAG_MASK = 3
-
-ofp_config_flags_map = {
-    0: 'OFPC_FRAG_NORMAL',
-    1: 'OFPC_FRAG_DROP',
-    2: 'OFPC_FRAG_REASM',
-    3: 'OFPC_FRAG_MASK',
-}
-
-# Identifiers from group ofp_error_type
-OFPET_HELLO_FAILED = 0
-OFPET_BAD_REQUEST = 1
-OFPET_BAD_ACTION = 2
-OFPET_FLOW_MOD_FAILED = 3
-OFPET_PORT_MOD_FAILED = 4
-OFPET_QUEUE_OP_FAILED = 5
-
-ofp_error_type_map = {
-    0: 'OFPET_HELLO_FAILED',
-    1: 'OFPET_BAD_REQUEST',
-    2: 'OFPET_BAD_ACTION',
-    3: 'OFPET_FLOW_MOD_FAILED',
-    4: 'OFPET_PORT_MOD_FAILED',
-    5: 'OFPET_QUEUE_OP_FAILED',
-}
-
-# Identifiers from group ofp_flow_mod_command
-OFPFC_ADD = 0
-OFPFC_MODIFY = 1
-OFPFC_MODIFY_STRICT = 2
-OFPFC_DELETE = 3
-OFPFC_DELETE_STRICT = 4
-
-ofp_flow_mod_command_map = {
-    0: 'OFPFC_ADD',
-    1: 'OFPFC_MODIFY',
-    2: 'OFPFC_MODIFY_STRICT',
-    3: 'OFPFC_DELETE',
-    4: 'OFPFC_DELETE_STRICT',
-}
-
-# Identifiers from group ofp_flow_mod_failed_code
-OFPFMFC_ALL_TABLES_FULL = 0
-OFPFMFC_OVERLAP = 1
-OFPFMFC_EPERM = 2
-OFPFMFC_BAD_EMERG_TIMEOUT = 3
-OFPFMFC_BAD_COMMAND = 4
-OFPFMFC_UNSUPPORTED = 5
-
-ofp_flow_mod_failed_code_map = {
-    0: 'OFPFMFC_ALL_TABLES_FULL',
-    1: 'OFPFMFC_OVERLAP',
-    2: 'OFPFMFC_EPERM',
-    3: 'OFPFMFC_BAD_EMERG_TIMEOUT',
-    4: 'OFPFMFC_BAD_COMMAND',
-    5: 'OFPFMFC_UNSUPPORTED',
-}
-
-# Identifiers from group ofp_flow_mod_flags
-OFPFF_SEND_FLOW_REM = 1
-OFPFF_CHECK_OVERLAP = 2
-OFPFF_EMERG = 4
-
-ofp_flow_mod_flags_map = {
-    1: 'OFPFF_SEND_FLOW_REM',
-    2: 'OFPFF_CHECK_OVERLAP',
-    4: 'OFPFF_EMERG',
-}
-
-# Identifiers from group ofp_flow_removed_reason
-OFPRR_IDLE_TIMEOUT = 0
-OFPRR_HARD_TIMEOUT = 1
-OFPRR_DELETE = 2
-
-ofp_flow_removed_reason_map = {
-    0: 'OFPRR_IDLE_TIMEOUT',
-    1: 'OFPRR_HARD_TIMEOUT',
-    2: 'OFPRR_DELETE',
-}
-
-# Identifiers from group ofp_flow_wildcards
-OFPFW_IN_PORT = 1
-OFPFW_DL_VLAN = 2
-OFPFW_DL_SRC = 4
-OFPFW_NW_DST_BITS = 6
-OFPFW_NW_SRC_BITS = 6
-OFPFW_NW_SRC_SHIFT = 8
-OFPFW_DL_DST = 8
-OFPFW_NW_DST_SHIFT = 14
-OFPFW_DL_TYPE = 16
-OFPFW_NW_PROTO = 32
-OFPFW_TP_SRC = 64
-OFPFW_TP_DST = 128
-OFPFW_NW_SRC_ALL = 8192
-OFPFW_NW_SRC_MASK = 16128
-OFPFW_NW_DST_ALL = 524288
-OFPFW_NW_DST_MASK = 1032192
-OFPFW_DL_VLAN_PCP = 1048576
-OFPFW_NW_TOS = 2097152
-OFPFW_ALL = 4194303
-
-ofp_flow_wildcards_map = {
-    1: 'OFPFW_IN_PORT',
-    2: 'OFPFW_DL_VLAN',
-    4: 'OFPFW_DL_SRC',
-    8: 'OFPFW_DL_DST',
-    16: 'OFPFW_DL_TYPE',
-    32: 'OFPFW_NW_PROTO',
-    64: 'OFPFW_TP_SRC',
-    128: 'OFPFW_TP_DST',
-    1048576: 'OFPFW_DL_VLAN_PCP',
-    2097152: 'OFPFW_NW_TOS',
-}
-
-# Identifiers from group ofp_hello_failed_code
-OFPHFC_INCOMPATIBLE = 0
-OFPHFC_EPERM = 1
-
-ofp_hello_failed_code_map = {
-    0: 'OFPHFC_INCOMPATIBLE',
-    1: 'OFPHFC_EPERM',
-}
-
-# Identifiers from group ofp_nicira_controller_role
-NX_ROLE_OTHER = 0
-NX_ROLE_MASTER = 1
-NX_ROLE_SLAVE = 2
-
-ofp_nicira_controller_role_map = {
-    0: 'NX_ROLE_OTHER',
-    1: 'NX_ROLE_MASTER',
-    2: 'NX_ROLE_SLAVE',
-}
-
-# Identifiers from group ofp_packet_in_reason
-OFPR_NO_MATCH = 0
-OFPR_ACTION = 1
-
-ofp_packet_in_reason_map = {
-    0: 'OFPR_NO_MATCH',
-    1: 'OFPR_ACTION',
-}
-
-# Identifiers from group ofp_port
-OFPP_MAX = 0xff00
-OFPP_IN_PORT = 0xfff8
-OFPP_TABLE = 0xfff9
-OFPP_NORMAL = 0xfffa
-OFPP_FLOOD = 0xfffb
-OFPP_ALL = 0xfffc
-OFPP_CONTROLLER = 0xfffd
-OFPP_LOCAL = 0xfffe
-OFPP_NONE = 0xffff
-
-ofp_port_map = {
-    0xff00: 'OFPP_MAX',
-    0xfff8: 'OFPP_IN_PORT',
-    0xfff9: 'OFPP_TABLE',
-    0xfffa: 'OFPP_NORMAL',
-    0xfffb: 'OFPP_FLOOD',
-    0xfffc: 'OFPP_ALL',
-    0xfffd: 'OFPP_CONTROLLER',
-    0xfffe: 'OFPP_LOCAL',
-    0xffff: 'OFPP_NONE',
-}
-
-# Identifiers from group ofp_port_config
-OFPPC_PORT_DOWN = 1
-OFPPC_NO_STP = 2
-OFPPC_NO_RECV = 4
-OFPPC_NO_RECV_STP = 8
-OFPPC_NO_FLOOD = 16
-OFPPC_NO_FWD = 32
-OFPPC_NO_PACKET_IN = 64
-OFPPC_BSN_MIRROR_DEST = 2147483648
-
-ofp_port_config_map = {
-    1: 'OFPPC_PORT_DOWN',
-    2: 'OFPPC_NO_STP',
-    4: 'OFPPC_NO_RECV',
-    8: 'OFPPC_NO_RECV_STP',
-    16: 'OFPPC_NO_FLOOD',
-    32: 'OFPPC_NO_FWD',
-    64: 'OFPPC_NO_PACKET_IN',
-    2147483648: 'OFPPC_BSN_MIRROR_DEST',
-}
-
-# Identifiers from group ofp_port_features
-OFPPF_10MB_HD = 1
-OFPPF_10MB_FD = 2
-OFPPF_100MB_HD = 4
-OFPPF_100MB_FD = 8
-OFPPF_1GB_HD = 16
-OFPPF_1GB_FD = 32
-OFPPF_10GB_FD = 64
-OFPPF_COPPER = 128
-OFPPF_FIBER = 256
-OFPPF_AUTONEG = 512
-OFPPF_PAUSE = 1024
-OFPPF_PAUSE_ASYM = 2048
-
-ofp_port_features_map = {
-    1: 'OFPPF_10MB_HD',
-    2: 'OFPPF_10MB_FD',
-    4: 'OFPPF_100MB_HD',
-    8: 'OFPPF_100MB_FD',
-    16: 'OFPPF_1GB_HD',
-    32: 'OFPPF_1GB_FD',
-    64: 'OFPPF_10GB_FD',
-    128: 'OFPPF_COPPER',
-    256: 'OFPPF_FIBER',
-    512: 'OFPPF_AUTONEG',
-    1024: 'OFPPF_PAUSE',
-    2048: 'OFPPF_PAUSE_ASYM',
-}
-
-# Identifiers from group ofp_port_mod_failed_code
-OFPPMFC_BAD_PORT = 0
-OFPPMFC_BAD_HW_ADDR = 1
-
-ofp_port_mod_failed_code_map = {
-    0: 'OFPPMFC_BAD_PORT',
-    1: 'OFPPMFC_BAD_HW_ADDR',
-}
-
-# Identifiers from group ofp_port_reason
-OFPPR_ADD = 0
-OFPPR_DELETE = 1
-OFPPR_MODIFY = 2
-
-ofp_port_reason_map = {
-    0: 'OFPPR_ADD',
-    1: 'OFPPR_DELETE',
-    2: 'OFPPR_MODIFY',
-}
-
-# Identifiers from group ofp_port_state
-OFPPS_LINK_DOWN = 1
-OFPPS_STP_LISTEN = 0
-OFPPS_STP_LEARN = 256
-OFPPS_STP_FORWARD = 512
-OFPPS_STP_BLOCK = 768
-OFPPS_STP_MASK = 768
-
-ofp_port_state_map = {
-    1: 'OFPPS_LINK_DOWN',
-    0: 'OFPPS_STP_LISTEN',
-    256: 'OFPPS_STP_LEARN',
-    512: 'OFPPS_STP_FORWARD',
-    768: 'OFPPS_STP_BLOCK',
-    768: 'OFPPS_STP_MASK',
-}
-
-# Identifiers from group ofp_queue_op_failed_code
-OFPQOFC_BAD_PORT = 0
-OFPQOFC_BAD_QUEUE = 1
-OFPQOFC_EPERM = 2
-
-ofp_queue_op_failed_code_map = {
-    0: 'OFPQOFC_BAD_PORT',
-    1: 'OFPQOFC_BAD_QUEUE',
-    2: 'OFPQOFC_EPERM',
-}
-
-# Identifiers from group ofp_queue_properties
-OFPQT_NONE = 0
-OFPQT_MIN_RATE = 1
-
-ofp_queue_properties_map = {
-    0: 'OFPQT_NONE',
-    1: 'OFPQT_MIN_RATE',
-}
-
-# Identifiers from group ofp_stats_reply_flags
-OFPSF_REPLY_MORE = 1
-
-ofp_stats_reply_flags_map = {
-    1: 'OFPSF_REPLY_MORE',
-}
-
-# Identifiers from group ofp_stats_request_flags
-
-ofp_stats_request_flags_map = {
-}
-
-# Identifiers from group ofp_stats_type
-OFPST_DESC = 0
-OFPST_FLOW = 1
-OFPST_AGGREGATE = 2
-OFPST_TABLE = 3
-OFPST_PORT = 4
-OFPST_QUEUE = 5
-OFPST_EXPERIMENTER = 65535
-
-ofp_stats_type_map = {
-    0: 'OFPST_DESC',
-    1: 'OFPST_FLOW',
-    2: 'OFPST_AGGREGATE',
-    3: 'OFPST_TABLE',
-    4: 'OFPST_PORT',
-    5: 'OFPST_QUEUE',
-    65535: 'OFPST_EXPERIMENTER',
-}
-
-# Identifiers from group ofp_type
-OFPT_HELLO = 0
-OFPT_ERROR = 1
-OFPT_ECHO_REQUEST = 2
-OFPT_ECHO_REPLY = 3
-OFPT_EXPERIMENTER = 4
-OFPT_FEATURES_REQUEST = 5
-OFPT_FEATURES_REPLY = 6
-OFPT_GET_CONFIG_REQUEST = 7
-OFPT_GET_CONFIG_REPLY = 8
-OFPT_SET_CONFIG = 9
-OFPT_PACKET_IN = 10
-OFPT_FLOW_REMOVED = 11
-OFPT_PORT_STATUS = 12
-OFPT_PACKET_OUT = 13
-OFPT_FLOW_MOD = 14
-OFPT_PORT_MOD = 15
-OFPT_STATS_REQUEST = 16
-OFPT_STATS_REPLY = 17
-OFPT_BARRIER_REQUEST = 18
-OFPT_BARRIER_REPLY = 19
-OFPT_QUEUE_GET_CONFIG_REQUEST = 20
-OFPT_QUEUE_GET_CONFIG_REPLY = 21
-
-ofp_type_map = {
-    0: 'OFPT_HELLO',
-    1: 'OFPT_ERROR',
-    2: 'OFPT_ECHO_REQUEST',
-    3: 'OFPT_ECHO_REPLY',
-    4: 'OFPT_EXPERIMENTER',
-    5: 'OFPT_FEATURES_REQUEST',
-    6: 'OFPT_FEATURES_REPLY',
-    7: 'OFPT_GET_CONFIG_REQUEST',
-    8: 'OFPT_GET_CONFIG_REPLY',
-    9: 'OFPT_SET_CONFIG',
-    10: 'OFPT_PACKET_IN',
-    11: 'OFPT_FLOW_REMOVED',
-    12: 'OFPT_PORT_STATUS',
-    13: 'OFPT_PACKET_OUT',
-    14: 'OFPT_FLOW_MOD',
-    15: 'OFPT_PORT_MOD',
-    16: 'OFPT_STATS_REQUEST',
-    17: 'OFPT_STATS_REPLY',
-    18: 'OFPT_BARRIER_REQUEST',
-    19: 'OFPT_BARRIER_REPLY',
-    20: 'OFPT_QUEUE_GET_CONFIG_REQUEST',
-    21: 'OFPT_QUEUE_GET_CONFIG_REPLY',
-}
-
diff --git a/python/ofagent/loxi/of10/message.py b/python/ofagent/loxi/of10/message.py
deleted file mode 100644
index 8c3d46c..0000000
--- a/python/ofagent/loxi/of10/message.py
+++ /dev/null
@@ -1,7550 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template module.py
-# Do not modify
-
-import struct
-import loxi
-import util
-import loxi.generic_util
-
-import sys
-ofp = sys.modules['loxi.of10']
-
-class message(loxi.OFObject):
-    subtypes = {}
-
-    version = 1
-
-    def __init__(self, type=None, xid=None):
-        if type != None:
-            self.type = type
-        else:
-            self.type = 0
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('B', 1)
-        subclass = message.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = message()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        obj.type = reader.read("!B")[0]
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type != other.type: return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("message {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-
-class stats_reply(message):
-    subtypes = {}
-
-    version = 1
-    type = 17
-
-    def __init__(self, xid=None, stats_type=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if stats_type != None:
-            self.stats_type = stats_type
-        else:
-            self.stats_type = 0
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 8)
-        subclass = stats_reply.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 17)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.stats_type = reader.read("!H")[0]
-        obj.flags = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.stats_type != other.stats_type: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[17] = stats_reply
-
-class aggregate_stats_reply(stats_reply):
-    version = 1
-    type = 17
-    stats_type = 2
-
-    def __init__(self, xid=None, flags=None, packet_count=None, byte_count=None, flow_count=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if packet_count != None:
-            self.packet_count = packet_count
-        else:
-            self.packet_count = 0
-        if byte_count != None:
-            self.byte_count = byte_count
-        else:
-            self.byte_count = 0
-        if flow_count != None:
-            self.flow_count = flow_count
-        else:
-            self.flow_count = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append(struct.pack("!Q", self.packet_count))
-        packed.append(struct.pack("!Q", self.byte_count))
-        packed.append(struct.pack("!L", self.flow_count))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = aggregate_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 17)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 2)
-        obj.flags = reader.read("!H")[0]
-        obj.packet_count = reader.read("!Q")[0]
-        obj.byte_count = reader.read("!Q")[0]
-        obj.flow_count = reader.read("!L")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.packet_count != other.packet_count: return False
-        if self.byte_count != other.byte_count: return False
-        if self.flow_count != other.flow_count: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("aggregate_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("packet_count = ");
-                q.text("%#x" % self.packet_count)
-                q.text(","); q.breakable()
-                q.text("byte_count = ");
-                q.text("%#x" % self.byte_count)
-                q.text(","); q.breakable()
-                q.text("flow_count = ");
-                q.text("%#x" % self.flow_count)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[2] = aggregate_stats_reply
-
-class stats_request(message):
-    subtypes = {}
-
-    version = 1
-    type = 16
-
-    def __init__(self, xid=None, stats_type=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if stats_type != None:
-            self.stats_type = stats_type
-        else:
-            self.stats_type = 0
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 8)
-        subclass = stats_request.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 16)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.stats_type = reader.read("!H")[0]
-        obj.flags = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.stats_type != other.stats_type: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[16] = stats_request
-
-class aggregate_stats_request(stats_request):
-    version = 1
-    type = 16
-    stats_type = 2
-
-    def __init__(self, xid=None, flags=None, match=None, table_id=None, out_port=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if out_port != None:
-            self.out_port = out_port
-        else:
-            self.out_port = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append(self.match.pack())
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append('\x00' * 1)
-        packed.append(util.pack_port_no(self.out_port))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = aggregate_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 16)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 2)
-        obj.flags = reader.read("!H")[0]
-        obj.match = ofp.match.unpack(reader)
-        obj.table_id = reader.read("!B")[0]
-        reader.skip(1)
-        obj.out_port = util.unpack_port_no(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.match != other.match: return False
-        if self.table_id != other.table_id: return False
-        if self.out_port != other.out_port: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("aggregate_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("out_port = ");
-                q.text(util.pretty_port(self.out_port))
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[2] = aggregate_stats_request
-
-class error_msg(message):
-    subtypes = {}
-
-    version = 1
-    type = 1
-
-    def __init__(self, xid=None, err_type=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if err_type != None:
-            self.err_type = err_type
-        else:
-            self.err_type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 8)
-        subclass = error_msg.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.err_type = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.err_type != other.err_type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-message.subtypes[1] = error_msg
-
-class bad_action_error_msg(error_msg):
-    version = 1
-    type = 1
-    err_type = 2
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bad_action_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 2)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bad_action_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[2] = bad_action_error_msg
-
-class bad_request_error_msg(error_msg):
-    version = 1
-    type = 1
-    err_type = 1
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bad_request_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 1)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bad_request_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[1] = bad_request_error_msg
-
-class barrier_reply(message):
-    version = 1
-    type = 19
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = barrier_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("barrier_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-message.subtypes[19] = barrier_reply
-
-class barrier_request(message):
-    version = 1
-    type = 18
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = barrier_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("barrier_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-message.subtypes[18] = barrier_request
-
-class experimenter(message):
-    subtypes = {}
-
-    version = 1
-    type = 4
-
-    def __init__(self, xid=None, experimenter=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 8)
-        subclass = experimenter.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = experimenter()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.experimenter = reader.read("!L")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.experimenter != other.experimenter: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("experimenter {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[4] = experimenter
-
-class bsn_header(experimenter):
-    subtypes = {}
-
-    version = 1
-    type = 4
-    experimenter = 6035143
-
-    def __init__(self, xid=None, subtype=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 12)
-        subclass = bsn_header.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = bsn_header()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        obj.subtype = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.subtype != other.subtype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_header {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-experimenter.subtypes[6035143] = bsn_header
-
-class bsn_bw_clear_data_reply(bsn_header):
-    version = 1
-    type = 4
-    experimenter = 6035143
-    subtype = 22
-
-    def __init__(self, xid=None, status=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if status != None:
-            self.status = status
-        else:
-            self.status = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.status))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_bw_clear_data_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 22)
-        obj.status = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.status != other.status: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_bw_clear_data_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("status = ");
-                q.text("%#x" % self.status)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[22] = bsn_bw_clear_data_reply
-
-class bsn_bw_clear_data_request(bsn_header):
-    version = 1
-    type = 4
-    experimenter = 6035143
-    subtype = 21
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_bw_clear_data_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 21)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_bw_clear_data_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[21] = bsn_bw_clear_data_request
-
-class bsn_bw_enable_get_reply(bsn_header):
-    version = 1
-    type = 4
-    experimenter = 6035143
-    subtype = 20
-
-    def __init__(self, xid=None, enabled=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if enabled != None:
-            self.enabled = enabled
-        else:
-            self.enabled = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.enabled))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_bw_enable_get_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 20)
-        obj.enabled = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.enabled != other.enabled: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_bw_enable_get_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("enabled = ");
-                q.text("%#x" % self.enabled)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[20] = bsn_bw_enable_get_reply
-
-class bsn_bw_enable_get_request(bsn_header):
-    version = 1
-    type = 4
-    experimenter = 6035143
-    subtype = 19
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_bw_enable_get_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 19)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_bw_enable_get_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[19] = bsn_bw_enable_get_request
-
-class bsn_bw_enable_set_reply(bsn_header):
-    version = 1
-    type = 4
-    experimenter = 6035143
-    subtype = 23
-
-    def __init__(self, xid=None, enable=None, status=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if enable != None:
-            self.enable = enable
-        else:
-            self.enable = 0
-        if status != None:
-            self.status = status
-        else:
-            self.status = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.enable))
-        packed.append(struct.pack("!L", self.status))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_bw_enable_set_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 23)
-        obj.enable = reader.read("!L")[0]
-        obj.status = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.enable != other.enable: return False
-        if self.status != other.status: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_bw_enable_set_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("enable = ");
-                q.text("%#x" % self.enable)
-                q.text(","); q.breakable()
-                q.text("status = ");
-                q.text("%#x" % self.status)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[23] = bsn_bw_enable_set_reply
-
-class bsn_bw_enable_set_request(bsn_header):
-    version = 1
-    type = 4
-    experimenter = 6035143
-    subtype = 18
-
-    def __init__(self, xid=None, enable=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if enable != None:
-            self.enable = enable
-        else:
-            self.enable = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.enable))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_bw_enable_set_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 18)
-        obj.enable = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.enable != other.enable: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_bw_enable_set_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("enable = ");
-                q.text("%#x" % self.enable)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[18] = bsn_bw_enable_set_request
-
-class bsn_get_interfaces_reply(bsn_header):
-    version = 1
-    type = 4
-    experimenter = 6035143
-    subtype = 10
-
-    def __init__(self, xid=None, interfaces=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if interfaces != None:
-            self.interfaces = interfaces
-        else:
-            self.interfaces = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(loxi.generic_util.pack_list(self.interfaces))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_get_interfaces_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 10)
-        obj.interfaces = loxi.generic_util.unpack_list(reader, ofp.common.bsn_interface.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.interfaces != other.interfaces: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_get_interfaces_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("interfaces = ");
-                q.pp(self.interfaces)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[10] = bsn_get_interfaces_reply
-
-class bsn_get_interfaces_request(bsn_header):
-    version = 1
-    type = 4
-    experimenter = 6035143
-    subtype = 9
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_get_interfaces_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 9)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_get_interfaces_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[9] = bsn_get_interfaces_request
-
-class bsn_get_ip_mask_reply(bsn_header):
-    version = 1
-    type = 4
-    experimenter = 6035143
-    subtype = 2
-
-    def __init__(self, xid=None, index=None, mask=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if index != None:
-            self.index = index
-        else:
-            self.index = 0
-        if mask != None:
-            self.mask = mask
-        else:
-            self.mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!B", self.index))
-        packed.append('\x00' * 3)
-        packed.append(struct.pack("!L", self.mask))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_get_ip_mask_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 2)
-        obj.index = reader.read("!B")[0]
-        reader.skip(3)
-        obj.mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.index != other.index: return False
-        if self.mask != other.mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_get_ip_mask_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("index = ");
-                q.text("%#x" % self.index)
-                q.text(","); q.breakable()
-                q.text("mask = ");
-                q.text("%#x" % self.mask)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[2] = bsn_get_ip_mask_reply
-
-class bsn_get_ip_mask_request(bsn_header):
-    version = 1
-    type = 4
-    experimenter = 6035143
-    subtype = 1
-
-    def __init__(self, xid=None, index=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if index != None:
-            self.index = index
-        else:
-            self.index = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!B", self.index))
-        packed.append('\x00' * 7)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_get_ip_mask_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 1)
-        obj.index = reader.read("!B")[0]
-        reader.skip(7)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.index != other.index: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_get_ip_mask_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("index = ");
-                q.text("%#x" % self.index)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[1] = bsn_get_ip_mask_request
-
-class bsn_get_l2_table_reply(bsn_header):
-    version = 1
-    type = 4
-    experimenter = 6035143
-    subtype = 14
-
-    def __init__(self, xid=None, l2_table_enable=None, l2_table_priority=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if l2_table_enable != None:
-            self.l2_table_enable = l2_table_enable
-        else:
-            self.l2_table_enable = 0
-        if l2_table_priority != None:
-            self.l2_table_priority = l2_table_priority
-        else:
-            self.l2_table_priority = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!B", self.l2_table_enable))
-        packed.append('\x00' * 1)
-        packed.append(struct.pack("!H", self.l2_table_priority))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_get_l2_table_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 14)
-        obj.l2_table_enable = reader.read("!B")[0]
-        reader.skip(1)
-        obj.l2_table_priority = reader.read("!H")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.l2_table_enable != other.l2_table_enable: return False
-        if self.l2_table_priority != other.l2_table_priority: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_get_l2_table_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("l2_table_enable = ");
-                q.text("%#x" % self.l2_table_enable)
-                q.text(","); q.breakable()
-                q.text("l2_table_priority = ");
-                q.text("%#x" % self.l2_table_priority)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[14] = bsn_get_l2_table_reply
-
-class bsn_get_l2_table_request(bsn_header):
-    version = 1
-    type = 4
-    experimenter = 6035143
-    subtype = 13
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_get_l2_table_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 13)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_get_l2_table_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[13] = bsn_get_l2_table_request
-
-class bsn_get_mirroring_reply(bsn_header):
-    version = 1
-    type = 4
-    experimenter = 6035143
-    subtype = 5
-
-    def __init__(self, xid=None, report_mirror_ports=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if report_mirror_ports != None:
-            self.report_mirror_ports = report_mirror_ports
-        else:
-            self.report_mirror_ports = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!B", self.report_mirror_ports))
-        packed.append('\x00' * 3)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_get_mirroring_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 5)
-        obj.report_mirror_ports = reader.read("!B")[0]
-        reader.skip(3)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.report_mirror_ports != other.report_mirror_ports: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_get_mirroring_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("report_mirror_ports = ");
-                q.text("%#x" % self.report_mirror_ports)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[5] = bsn_get_mirroring_reply
-
-class bsn_get_mirroring_request(bsn_header):
-    version = 1
-    type = 4
-    experimenter = 6035143
-    subtype = 4
-
-    def __init__(self, xid=None, report_mirror_ports=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if report_mirror_ports != None:
-            self.report_mirror_ports = report_mirror_ports
-        else:
-            self.report_mirror_ports = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!B", self.report_mirror_ports))
-        packed.append('\x00' * 3)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_get_mirroring_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 4)
-        obj.report_mirror_ports = reader.read("!B")[0]
-        reader.skip(3)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.report_mirror_ports != other.report_mirror_ports: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_get_mirroring_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("report_mirror_ports = ");
-                q.text("%#x" % self.report_mirror_ports)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[4] = bsn_get_mirroring_request
-
-class bsn_hybrid_get_reply(bsn_header):
-    version = 1
-    type = 4
-    experimenter = 6035143
-    subtype = 28
-
-    def __init__(self, xid=None, hybrid_enable=None, hybrid_version=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if hybrid_enable != None:
-            self.hybrid_enable = hybrid_enable
-        else:
-            self.hybrid_enable = 0
-        if hybrid_version != None:
-            self.hybrid_version = hybrid_version
-        else:
-            self.hybrid_version = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!B", self.hybrid_enable))
-        packed.append('\x00' * 1)
-        packed.append(struct.pack("!H", self.hybrid_version))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_hybrid_get_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 28)
-        obj.hybrid_enable = reader.read("!B")[0]
-        reader.skip(1)
-        obj.hybrid_version = reader.read("!H")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.hybrid_enable != other.hybrid_enable: return False
-        if self.hybrid_version != other.hybrid_version: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_hybrid_get_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("hybrid_enable = ");
-                q.text("%#x" % self.hybrid_enable)
-                q.text(","); q.breakable()
-                q.text("hybrid_version = ");
-                q.text("%#x" % self.hybrid_version)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[28] = bsn_hybrid_get_reply
-
-class bsn_hybrid_get_request(bsn_header):
-    version = 1
-    type = 4
-    experimenter = 6035143
-    subtype = 27
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_hybrid_get_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 27)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_hybrid_get_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[27] = bsn_hybrid_get_request
-
-class bsn_pdu_rx_reply(bsn_header):
-    version = 1
-    type = 4
-    experimenter = 6035143
-    subtype = 34
-
-    def __init__(self, xid=None, status=None, port_no=None, slot_num=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if status != None:
-            self.status = status
-        else:
-            self.status = 0
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if slot_num != None:
-            self.slot_num = slot_num
-        else:
-            self.slot_num = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.status))
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(struct.pack("!B", self.slot_num))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_pdu_rx_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 34)
-        obj.status = reader.read("!L")[0]
-        obj.port_no = util.unpack_port_no(reader)
-        obj.slot_num = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.status != other.status: return False
-        if self.port_no != other.port_no: return False
-        if self.slot_num != other.slot_num: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_pdu_rx_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("status = ");
-                q.text("%#x" % self.status)
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("slot_num = ");
-                q.text("%#x" % self.slot_num)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[34] = bsn_pdu_rx_reply
-
-class bsn_pdu_rx_request(bsn_header):
-    version = 1
-    type = 4
-    experimenter = 6035143
-    subtype = 33
-
-    def __init__(self, xid=None, timeout_ms=None, port_no=None, slot_num=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if timeout_ms != None:
-            self.timeout_ms = timeout_ms
-        else:
-            self.timeout_ms = 0
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if slot_num != None:
-            self.slot_num = slot_num
-        else:
-            self.slot_num = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.timeout_ms))
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(struct.pack("!B", self.slot_num))
-        packed.append('\x00' * 3)
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_pdu_rx_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 33)
-        obj.timeout_ms = reader.read("!L")[0]
-        obj.port_no = util.unpack_port_no(reader)
-        obj.slot_num = reader.read("!B")[0]
-        reader.skip(3)
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.timeout_ms != other.timeout_ms: return False
-        if self.port_no != other.port_no: return False
-        if self.slot_num != other.slot_num: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_pdu_rx_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("timeout_ms = ");
-                q.text("%#x" % self.timeout_ms)
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("slot_num = ");
-                q.text("%#x" % self.slot_num)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[33] = bsn_pdu_rx_request
-
-class bsn_pdu_rx_timeout(bsn_header):
-    version = 1
-    type = 4
-    experimenter = 6035143
-    subtype = 35
-
-    def __init__(self, xid=None, port_no=None, slot_num=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if slot_num != None:
-            self.slot_num = slot_num
-        else:
-            self.slot_num = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(struct.pack("!B", self.slot_num))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_pdu_rx_timeout()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 35)
-        obj.port_no = util.unpack_port_no(reader)
-        obj.slot_num = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.port_no != other.port_no: return False
-        if self.slot_num != other.slot_num: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_pdu_rx_timeout {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("slot_num = ");
-                q.text("%#x" % self.slot_num)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[35] = bsn_pdu_rx_timeout
-
-class bsn_pdu_tx_reply(bsn_header):
-    version = 1
-    type = 4
-    experimenter = 6035143
-    subtype = 32
-
-    def __init__(self, xid=None, status=None, port_no=None, slot_num=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if status != None:
-            self.status = status
-        else:
-            self.status = 0
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if slot_num != None:
-            self.slot_num = slot_num
-        else:
-            self.slot_num = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.status))
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(struct.pack("!B", self.slot_num))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_pdu_tx_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 32)
-        obj.status = reader.read("!L")[0]
-        obj.port_no = util.unpack_port_no(reader)
-        obj.slot_num = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.status != other.status: return False
-        if self.port_no != other.port_no: return False
-        if self.slot_num != other.slot_num: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_pdu_tx_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("status = ");
-                q.text("%#x" % self.status)
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("slot_num = ");
-                q.text("%#x" % self.slot_num)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[32] = bsn_pdu_tx_reply
-
-class bsn_pdu_tx_request(bsn_header):
-    version = 1
-    type = 4
-    experimenter = 6035143
-    subtype = 31
-
-    def __init__(self, xid=None, tx_interval_ms=None, port_no=None, slot_num=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if tx_interval_ms != None:
-            self.tx_interval_ms = tx_interval_ms
-        else:
-            self.tx_interval_ms = 0
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if slot_num != None:
-            self.slot_num = slot_num
-        else:
-            self.slot_num = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.tx_interval_ms))
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(struct.pack("!B", self.slot_num))
-        packed.append('\x00' * 3)
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_pdu_tx_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 31)
-        obj.tx_interval_ms = reader.read("!L")[0]
-        obj.port_no = util.unpack_port_no(reader)
-        obj.slot_num = reader.read("!B")[0]
-        reader.skip(3)
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.tx_interval_ms != other.tx_interval_ms: return False
-        if self.port_no != other.port_no: return False
-        if self.slot_num != other.slot_num: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_pdu_tx_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("tx_interval_ms = ");
-                q.text("%#x" % self.tx_interval_ms)
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("slot_num = ");
-                q.text("%#x" % self.slot_num)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[31] = bsn_pdu_tx_request
-
-class bsn_set_ip_mask(bsn_header):
-    version = 1
-    type = 4
-    experimenter = 6035143
-    subtype = 0
-
-    def __init__(self, xid=None, index=None, mask=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if index != None:
-            self.index = index
-        else:
-            self.index = 0
-        if mask != None:
-            self.mask = mask
-        else:
-            self.mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!B", self.index))
-        packed.append('\x00' * 3)
-        packed.append(struct.pack("!L", self.mask))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_set_ip_mask()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 0)
-        obj.index = reader.read("!B")[0]
-        reader.skip(3)
-        obj.mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.index != other.index: return False
-        if self.mask != other.mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_set_ip_mask {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("index = ");
-                q.text("%#x" % self.index)
-                q.text(","); q.breakable()
-                q.text("mask = ");
-                q.text("%#x" % self.mask)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[0] = bsn_set_ip_mask
-
-class bsn_set_l2_table_reply(bsn_header):
-    version = 1
-    type = 4
-    experimenter = 6035143
-    subtype = 24
-
-    def __init__(self, xid=None, l2_table_enable=None, l2_table_priority=None, status=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if l2_table_enable != None:
-            self.l2_table_enable = l2_table_enable
-        else:
-            self.l2_table_enable = 0
-        if l2_table_priority != None:
-            self.l2_table_priority = l2_table_priority
-        else:
-            self.l2_table_priority = 0
-        if status != None:
-            self.status = status
-        else:
-            self.status = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!B", self.l2_table_enable))
-        packed.append('\x00' * 1)
-        packed.append(struct.pack("!H", self.l2_table_priority))
-        packed.append(struct.pack("!L", self.status))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_set_l2_table_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 24)
-        obj.l2_table_enable = reader.read("!B")[0]
-        reader.skip(1)
-        obj.l2_table_priority = reader.read("!H")[0]
-        obj.status = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.l2_table_enable != other.l2_table_enable: return False
-        if self.l2_table_priority != other.l2_table_priority: return False
-        if self.status != other.status: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_set_l2_table_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("l2_table_enable = ");
-                q.text("%#x" % self.l2_table_enable)
-                q.text(","); q.breakable()
-                q.text("l2_table_priority = ");
-                q.text("%#x" % self.l2_table_priority)
-                q.text(","); q.breakable()
-                q.text("status = ");
-                q.text("%#x" % self.status)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[24] = bsn_set_l2_table_reply
-
-class bsn_set_l2_table_request(bsn_header):
-    version = 1
-    type = 4
-    experimenter = 6035143
-    subtype = 12
-
-    def __init__(self, xid=None, l2_table_enable=None, l2_table_priority=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if l2_table_enable != None:
-            self.l2_table_enable = l2_table_enable
-        else:
-            self.l2_table_enable = 0
-        if l2_table_priority != None:
-            self.l2_table_priority = l2_table_priority
-        else:
-            self.l2_table_priority = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!B", self.l2_table_enable))
-        packed.append('\x00' * 1)
-        packed.append(struct.pack("!H", self.l2_table_priority))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_set_l2_table_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 12)
-        obj.l2_table_enable = reader.read("!B")[0]
-        reader.skip(1)
-        obj.l2_table_priority = reader.read("!H")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.l2_table_enable != other.l2_table_enable: return False
-        if self.l2_table_priority != other.l2_table_priority: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_set_l2_table_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("l2_table_enable = ");
-                q.text("%#x" % self.l2_table_enable)
-                q.text(","); q.breakable()
-                q.text("l2_table_priority = ");
-                q.text("%#x" % self.l2_table_priority)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[12] = bsn_set_l2_table_request
-
-class bsn_set_mirroring(bsn_header):
-    version = 1
-    type = 4
-    experimenter = 6035143
-    subtype = 3
-
-    def __init__(self, xid=None, report_mirror_ports=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if report_mirror_ports != None:
-            self.report_mirror_ports = report_mirror_ports
-        else:
-            self.report_mirror_ports = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!B", self.report_mirror_ports))
-        packed.append('\x00' * 3)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_set_mirroring()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 3)
-        obj.report_mirror_ports = reader.read("!B")[0]
-        reader.skip(3)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.report_mirror_ports != other.report_mirror_ports: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_set_mirroring {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("report_mirror_ports = ");
-                q.text("%#x" % self.report_mirror_ports)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[3] = bsn_set_mirroring
-
-class bsn_set_pktin_suppression_reply(bsn_header):
-    version = 1
-    type = 4
-    experimenter = 6035143
-    subtype = 25
-
-    def __init__(self, xid=None, status=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if status != None:
-            self.status = status
-        else:
-            self.status = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.status))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_set_pktin_suppression_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 25)
-        obj.status = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.status != other.status: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_set_pktin_suppression_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("status = ");
-                q.text("%#x" % self.status)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[25] = bsn_set_pktin_suppression_reply
-
-class bsn_set_pktin_suppression_request(bsn_header):
-    version = 1
-    type = 4
-    experimenter = 6035143
-    subtype = 11
-
-    def __init__(self, xid=None, enabled=None, idle_timeout=None, hard_timeout=None, priority=None, cookie=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if enabled != None:
-            self.enabled = enabled
-        else:
-            self.enabled = 0
-        if idle_timeout != None:
-            self.idle_timeout = idle_timeout
-        else:
-            self.idle_timeout = 0
-        if hard_timeout != None:
-            self.hard_timeout = hard_timeout
-        else:
-            self.hard_timeout = 0
-        if priority != None:
-            self.priority = priority
-        else:
-            self.priority = 0
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!B", self.enabled))
-        packed.append('\x00' * 1)
-        packed.append(struct.pack("!H", self.idle_timeout))
-        packed.append(struct.pack("!H", self.hard_timeout))
-        packed.append(struct.pack("!H", self.priority))
-        packed.append(struct.pack("!Q", self.cookie))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_set_pktin_suppression_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 11)
-        obj.enabled = reader.read("!B")[0]
-        reader.skip(1)
-        obj.idle_timeout = reader.read("!H")[0]
-        obj.hard_timeout = reader.read("!H")[0]
-        obj.priority = reader.read("!H")[0]
-        obj.cookie = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.enabled != other.enabled: return False
-        if self.idle_timeout != other.idle_timeout: return False
-        if self.hard_timeout != other.hard_timeout: return False
-        if self.priority != other.priority: return False
-        if self.cookie != other.cookie: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_set_pktin_suppression_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("enabled = ");
-                q.text("%#x" % self.enabled)
-                q.text(","); q.breakable()
-                q.text("idle_timeout = ");
-                q.text("%#x" % self.idle_timeout)
-                q.text(","); q.breakable()
-                q.text("hard_timeout = ");
-                q.text("%#x" % self.hard_timeout)
-                q.text(","); q.breakable()
-                q.text("priority = ");
-                q.text("%#x" % self.priority)
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[11] = bsn_set_pktin_suppression_request
-
-class bsn_shell_command(bsn_header):
-    version = 1
-    type = 4
-    experimenter = 6035143
-    subtype = 6
-
-    def __init__(self, xid=None, service=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if service != None:
-            self.service = service
-        else:
-            self.service = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.service))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_shell_command()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 6)
-        obj.service = reader.read("!L")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.service != other.service: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_shell_command {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("service = ");
-                q.text("%#x" % self.service)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[6] = bsn_shell_command
-
-class bsn_shell_output(bsn_header):
-    version = 1
-    type = 4
-    experimenter = 6035143
-    subtype = 7
-
-    def __init__(self, xid=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_shell_output()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 7)
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_shell_output {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[7] = bsn_shell_output
-
-class bsn_shell_status(bsn_header):
-    version = 1
-    type = 4
-    experimenter = 6035143
-    subtype = 8
-
-    def __init__(self, xid=None, status=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if status != None:
-            self.status = status
-        else:
-            self.status = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.status))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_shell_status()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 8)
-        obj.status = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.status != other.status: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_shell_status {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("status = ");
-                q.text("%#x" % self.status)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[8] = bsn_shell_status
-
-class experimenter_stats_reply(stats_reply):
-    subtypes = {}
-
-    version = 1
-    type = 17
-    stats_type = 65535
-
-    def __init__(self, xid=None, flags=None, experimenter=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 12)
-        subclass = experimenter_stats_reply.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = experimenter_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 17)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        obj.experimenter = reader.read("!L")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.experimenter != other.experimenter: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("experimenter_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[65535] = experimenter_stats_reply
-
-class bsn_stats_reply(experimenter_stats_reply):
-    subtypes = {}
-
-    version = 1
-    type = 19
-    stats_type = 65535
-    experimenter = 6035143
-
-    def __init__(self, xid=None, flags=None, subtype=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 20)
-        subclass = bsn_stats_reply.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = bsn_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        obj.subtype = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.subtype != other.subtype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-experimenter_stats_reply.subtypes[6035143] = bsn_stats_reply
-
-class experimenter_stats_request(stats_request):
-    subtypes = {}
-
-    version = 1
-    type = 16
-    stats_type = 65535
-
-    def __init__(self, xid=None, flags=None, experimenter=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 12)
-        subclass = experimenter_stats_request.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = experimenter_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 16)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        obj.experimenter = reader.read("!L")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.experimenter != other.experimenter: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("experimenter_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[65535] = experimenter_stats_request
-
-class bsn_stats_request(experimenter_stats_request):
-    subtypes = {}
-
-    version = 1
-    type = 18
-    stats_type = 65535
-    experimenter = 6035143
-
-    def __init__(self, xid=None, flags=None, subtype=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 20)
-        subclass = bsn_stats_request.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = bsn_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        obj.subtype = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.subtype != other.subtype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-experimenter_stats_request.subtypes[6035143] = bsn_stats_request
-
-class bsn_virtual_port_create_reply(bsn_header):
-    version = 1
-    type = 4
-    experimenter = 6035143
-    subtype = 16
-
-    def __init__(self, xid=None, status=None, vport_no=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if status != None:
-            self.status = status
-        else:
-            self.status = 0
-        if vport_no != None:
-            self.vport_no = vport_no
-        else:
-            self.vport_no = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.status))
-        packed.append(struct.pack("!L", self.vport_no))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_virtual_port_create_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 16)
-        obj.status = reader.read("!L")[0]
-        obj.vport_no = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.status != other.status: return False
-        if self.vport_no != other.vport_no: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_virtual_port_create_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("status = ");
-                q.text("%#x" % self.status)
-                q.text(","); q.breakable()
-                q.text("vport_no = ");
-                q.text("%#x" % self.vport_no)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[16] = bsn_virtual_port_create_reply
-
-class bsn_virtual_port_create_request(bsn_header):
-    version = 1
-    type = 4
-    experimenter = 6035143
-    subtype = 15
-
-    def __init__(self, xid=None, vport=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if vport != None:
-            self.vport = vport
-        else:
-            self.vport = ofp.bsn_vport()
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(self.vport.pack())
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_virtual_port_create_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 15)
-        obj.vport = ofp.bsn_vport.unpack(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.vport != other.vport: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_virtual_port_create_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("vport = ");
-                q.pp(self.vport)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[15] = bsn_virtual_port_create_request
-
-class bsn_virtual_port_remove_reply(bsn_header):
-    version = 1
-    type = 4
-    experimenter = 6035143
-    subtype = 26
-
-    def __init__(self, xid=None, status=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if status != None:
-            self.status = status
-        else:
-            self.status = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.status))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_virtual_port_remove_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 26)
-        obj.status = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.status != other.status: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_virtual_port_remove_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("status = ");
-                q.text("%#x" % self.status)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[26] = bsn_virtual_port_remove_reply
-
-class bsn_virtual_port_remove_request(bsn_header):
-    version = 1
-    type = 4
-    experimenter = 6035143
-    subtype = 17
-
-    def __init__(self, xid=None, vport_no=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if vport_no != None:
-            self.vport_no = vport_no
-        else:
-            self.vport_no = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.vport_no))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_virtual_port_remove_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 17)
-        obj.vport_no = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.vport_no != other.vport_no: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_virtual_port_remove_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("vport_no = ");
-                q.text("%#x" % self.vport_no)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[17] = bsn_virtual_port_remove_request
-
-class desc_stats_reply(stats_reply):
-    version = 1
-    type = 17
-    stats_type = 0
-
-    def __init__(self, xid=None, flags=None, mfr_desc=None, hw_desc=None, sw_desc=None, serial_num=None, dp_desc=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if mfr_desc != None:
-            self.mfr_desc = mfr_desc
-        else:
-            self.mfr_desc = ""
-        if hw_desc != None:
-            self.hw_desc = hw_desc
-        else:
-            self.hw_desc = ""
-        if sw_desc != None:
-            self.sw_desc = sw_desc
-        else:
-            self.sw_desc = ""
-        if serial_num != None:
-            self.serial_num = serial_num
-        else:
-            self.serial_num = ""
-        if dp_desc != None:
-            self.dp_desc = dp_desc
-        else:
-            self.dp_desc = ""
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append(struct.pack("!256s", self.mfr_desc))
-        packed.append(struct.pack("!256s", self.hw_desc))
-        packed.append(struct.pack("!256s", self.sw_desc))
-        packed.append(struct.pack("!32s", self.serial_num))
-        packed.append(struct.pack("!256s", self.dp_desc))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = desc_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 17)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 0)
-        obj.flags = reader.read("!H")[0]
-        obj.mfr_desc = reader.read("!256s")[0].rstrip("\x00")
-        obj.hw_desc = reader.read("!256s")[0].rstrip("\x00")
-        obj.sw_desc = reader.read("!256s")[0].rstrip("\x00")
-        obj.serial_num = reader.read("!32s")[0].rstrip("\x00")
-        obj.dp_desc = reader.read("!256s")[0].rstrip("\x00")
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.mfr_desc != other.mfr_desc: return False
-        if self.hw_desc != other.hw_desc: return False
-        if self.sw_desc != other.sw_desc: return False
-        if self.serial_num != other.serial_num: return False
-        if self.dp_desc != other.dp_desc: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("desc_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("mfr_desc = ");
-                q.pp(self.mfr_desc)
-                q.text(","); q.breakable()
-                q.text("hw_desc = ");
-                q.pp(self.hw_desc)
-                q.text(","); q.breakable()
-                q.text("sw_desc = ");
-                q.pp(self.sw_desc)
-                q.text(","); q.breakable()
-                q.text("serial_num = ");
-                q.pp(self.serial_num)
-                q.text(","); q.breakable()
-                q.text("dp_desc = ");
-                q.pp(self.dp_desc)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[0] = desc_stats_reply
-
-class desc_stats_request(stats_request):
-    version = 1
-    type = 16
-    stats_type = 0
-
-    def __init__(self, xid=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = desc_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 16)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 0)
-        obj.flags = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("desc_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[0] = desc_stats_request
-
-class echo_reply(message):
-    version = 1
-    type = 3
-
-    def __init__(self, xid=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = echo_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 3)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("echo_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[3] = echo_reply
-
-class echo_request(message):
-    version = 1
-    type = 2
-
-    def __init__(self, xid=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = echo_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 2)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("echo_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[2] = echo_request
-
-class features_reply(message):
-    version = 1
-    type = 6
-
-    def __init__(self, xid=None, datapath_id=None, n_buffers=None, n_tables=None, capabilities=None, actions=None, ports=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if datapath_id != None:
-            self.datapath_id = datapath_id
-        else:
-            self.datapath_id = 0
-        if n_buffers != None:
-            self.n_buffers = n_buffers
-        else:
-            self.n_buffers = 0
-        if n_tables != None:
-            self.n_tables = n_tables
-        else:
-            self.n_tables = 0
-        if capabilities != None:
-            self.capabilities = capabilities
-        else:
-            self.capabilities = 0
-        if actions != None:
-            self.actions = actions
-        else:
-            self.actions = 0
-        if ports != None:
-            self.ports = ports
-        else:
-            self.ports = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!Q", self.datapath_id))
-        packed.append(struct.pack("!L", self.n_buffers))
-        packed.append(struct.pack("!B", self.n_tables))
-        packed.append('\x00' * 3)
-        packed.append(struct.pack("!L", self.capabilities))
-        packed.append(struct.pack("!L", self.actions))
-        packed.append(loxi.generic_util.pack_list(self.ports))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = features_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 6)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.datapath_id = reader.read("!Q")[0]
-        obj.n_buffers = reader.read("!L")[0]
-        obj.n_tables = reader.read("!B")[0]
-        reader.skip(3)
-        obj.capabilities = reader.read("!L")[0]
-        obj.actions = reader.read("!L")[0]
-        obj.ports = loxi.generic_util.unpack_list(reader, ofp.common.port_desc.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.datapath_id != other.datapath_id: return False
-        if self.n_buffers != other.n_buffers: return False
-        if self.n_tables != other.n_tables: return False
-        if self.capabilities != other.capabilities: return False
-        if self.actions != other.actions: return False
-        if self.ports != other.ports: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("features_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("datapath_id = ");
-                q.text("%#x" % self.datapath_id)
-                q.text(","); q.breakable()
-                q.text("n_buffers = ");
-                q.text("%#x" % self.n_buffers)
-                q.text(","); q.breakable()
-                q.text("n_tables = ");
-                q.text("%#x" % self.n_tables)
-                q.text(","); q.breakable()
-                q.text("capabilities = ");
-                q.text("%#x" % self.capabilities)
-                q.text(","); q.breakable()
-                q.text("actions = ");
-                q.text("%#x" % self.actions)
-                q.text(","); q.breakable()
-                q.text("ports = ");
-                q.pp(self.ports)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[6] = features_reply
-
-class features_request(message):
-    version = 1
-    type = 5
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = features_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 5)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("features_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-message.subtypes[5] = features_request
-
-class flow_mod(message):
-    subtypes = {}
-
-    version = 1
-    type = 14
-
-    def __init__(self, xid=None, match=None, cookie=None, _command=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, flags=None, actions=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if _command != None:
-            self._command = _command
-        else:
-            self._command = 0
-        if idle_timeout != None:
-            self.idle_timeout = idle_timeout
-        else:
-            self.idle_timeout = 0
-        if hard_timeout != None:
-            self.hard_timeout = hard_timeout
-        else:
-            self.hard_timeout = 0
-        if priority != None:
-            self.priority = priority
-        else:
-            self.priority = 0
-        if buffer_id != None:
-            self.buffer_id = buffer_id
-        else:
-            self.buffer_id = 0
-        if out_port != None:
-            self.out_port = out_port
-        else:
-            self.out_port = 0
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if actions != None:
-            self.actions = actions
-        else:
-            self.actions = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(self.match.pack())
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(util.pack_fm_cmd(self._command))
-        packed.append(struct.pack("!H", self.idle_timeout))
-        packed.append(struct.pack("!H", self.hard_timeout))
-        packed.append(struct.pack("!H", self.priority))
-        packed.append(struct.pack("!L", self.buffer_id))
-        packed.append(util.pack_port_no(self.out_port))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append(loxi.generic_util.pack_list(self.actions))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 56)
-        subclass = flow_mod.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = flow_mod()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 14)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.match = ofp.match.unpack(reader)
-        obj.cookie = reader.read("!Q")[0]
-        obj._command = util.unpack_fm_cmd(reader)
-        obj.idle_timeout = reader.read("!H")[0]
-        obj.hard_timeout = reader.read("!H")[0]
-        obj.priority = reader.read("!H")[0]
-        obj.buffer_id = reader.read("!L")[0]
-        obj.out_port = util.unpack_port_no(reader)
-        obj.flags = reader.read("!H")[0]
-        obj.actions = loxi.generic_util.unpack_list(reader, ofp.action.action.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.match != other.match: return False
-        if self.cookie != other.cookie: return False
-        if self._command != other._command: return False
-        if self.idle_timeout != other.idle_timeout: return False
-        if self.hard_timeout != other.hard_timeout: return False
-        if self.priority != other.priority: return False
-        if self.buffer_id != other.buffer_id: return False
-        if self.out_port != other.out_port: return False
-        if self.flags != other.flags: return False
-        if self.actions != other.actions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_mod {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("idle_timeout = ");
-                q.text("%#x" % self.idle_timeout)
-                q.text(","); q.breakable()
-                q.text("hard_timeout = ");
-                q.text("%#x" % self.hard_timeout)
-                q.text(","); q.breakable()
-                q.text("priority = ");
-                q.text("%#x" % self.priority)
-                q.text(","); q.breakable()
-                q.text("buffer_id = ");
-                q.text("%#x" % self.buffer_id)
-                q.text(","); q.breakable()
-                q.text("out_port = ");
-                q.text(util.pretty_port(self.out_port))
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("actions = ");
-                q.pp(self.actions)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[14] = flow_mod
-
-class flow_add(flow_mod):
-    version = 1
-    type = 14
-    _command = 0
-
-    def __init__(self, xid=None, match=None, cookie=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, flags=None, actions=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if idle_timeout != None:
-            self.idle_timeout = idle_timeout
-        else:
-            self.idle_timeout = 0
-        if hard_timeout != None:
-            self.hard_timeout = hard_timeout
-        else:
-            self.hard_timeout = 0
-        if priority != None:
-            self.priority = priority
-        else:
-            self.priority = 0
-        if buffer_id != None:
-            self.buffer_id = buffer_id
-        else:
-            self.buffer_id = 0
-        if out_port != None:
-            self.out_port = out_port
-        else:
-            self.out_port = 0
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if actions != None:
-            self.actions = actions
-        else:
-            self.actions = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(self.match.pack())
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(util.pack_fm_cmd(self._command))
-        packed.append(struct.pack("!H", self.idle_timeout))
-        packed.append(struct.pack("!H", self.hard_timeout))
-        packed.append(struct.pack("!H", self.priority))
-        packed.append(struct.pack("!L", self.buffer_id))
-        packed.append(util.pack_port_no(self.out_port))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append(loxi.generic_util.pack_list(self.actions))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_add()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 14)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.match = ofp.match.unpack(reader)
-        obj.cookie = reader.read("!Q")[0]
-        __command = util.unpack_fm_cmd(reader)
-        assert(__command == 0)
-        obj.idle_timeout = reader.read("!H")[0]
-        obj.hard_timeout = reader.read("!H")[0]
-        obj.priority = reader.read("!H")[0]
-        obj.buffer_id = reader.read("!L")[0]
-        obj.out_port = util.unpack_port_no(reader)
-        obj.flags = reader.read("!H")[0]
-        obj.actions = loxi.generic_util.unpack_list(reader, ofp.action.action.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.match != other.match: return False
-        if self.cookie != other.cookie: return False
-        if self.idle_timeout != other.idle_timeout: return False
-        if self.hard_timeout != other.hard_timeout: return False
-        if self.priority != other.priority: return False
-        if self.buffer_id != other.buffer_id: return False
-        if self.out_port != other.out_port: return False
-        if self.flags != other.flags: return False
-        if self.actions != other.actions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_add {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("idle_timeout = ");
-                q.text("%#x" % self.idle_timeout)
-                q.text(","); q.breakable()
-                q.text("hard_timeout = ");
-                q.text("%#x" % self.hard_timeout)
-                q.text(","); q.breakable()
-                q.text("priority = ");
-                q.text("%#x" % self.priority)
-                q.text(","); q.breakable()
-                q.text("buffer_id = ");
-                q.text("%#x" % self.buffer_id)
-                q.text(","); q.breakable()
-                q.text("out_port = ");
-                q.text(util.pretty_port(self.out_port))
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("actions = ");
-                q.pp(self.actions)
-            q.breakable()
-        q.text('}')
-
-flow_mod.subtypes[0] = flow_add
-
-class flow_delete(flow_mod):
-    version = 1
-    type = 14
-    _command = 3
-
-    def __init__(self, xid=None, match=None, cookie=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, flags=None, actions=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if idle_timeout != None:
-            self.idle_timeout = idle_timeout
-        else:
-            self.idle_timeout = 0
-        if hard_timeout != None:
-            self.hard_timeout = hard_timeout
-        else:
-            self.hard_timeout = 0
-        if priority != None:
-            self.priority = priority
-        else:
-            self.priority = 0
-        if buffer_id != None:
-            self.buffer_id = buffer_id
-        else:
-            self.buffer_id = 0
-        if out_port != None:
-            self.out_port = out_port
-        else:
-            self.out_port = 0
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if actions != None:
-            self.actions = actions
-        else:
-            self.actions = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(self.match.pack())
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(util.pack_fm_cmd(self._command))
-        packed.append(struct.pack("!H", self.idle_timeout))
-        packed.append(struct.pack("!H", self.hard_timeout))
-        packed.append(struct.pack("!H", self.priority))
-        packed.append(struct.pack("!L", self.buffer_id))
-        packed.append(util.pack_port_no(self.out_port))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append(loxi.generic_util.pack_list(self.actions))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_delete()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 14)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.match = ofp.match.unpack(reader)
-        obj.cookie = reader.read("!Q")[0]
-        __command = util.unpack_fm_cmd(reader)
-        assert(__command == 3)
-        obj.idle_timeout = reader.read("!H")[0]
-        obj.hard_timeout = reader.read("!H")[0]
-        obj.priority = reader.read("!H")[0]
-        obj.buffer_id = reader.read("!L")[0]
-        obj.out_port = util.unpack_port_no(reader)
-        obj.flags = reader.read("!H")[0]
-        obj.actions = loxi.generic_util.unpack_list(reader, ofp.action.action.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.match != other.match: return False
-        if self.cookie != other.cookie: return False
-        if self.idle_timeout != other.idle_timeout: return False
-        if self.hard_timeout != other.hard_timeout: return False
-        if self.priority != other.priority: return False
-        if self.buffer_id != other.buffer_id: return False
-        if self.out_port != other.out_port: return False
-        if self.flags != other.flags: return False
-        if self.actions != other.actions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_delete {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("idle_timeout = ");
-                q.text("%#x" % self.idle_timeout)
-                q.text(","); q.breakable()
-                q.text("hard_timeout = ");
-                q.text("%#x" % self.hard_timeout)
-                q.text(","); q.breakable()
-                q.text("priority = ");
-                q.text("%#x" % self.priority)
-                q.text(","); q.breakable()
-                q.text("buffer_id = ");
-                q.text("%#x" % self.buffer_id)
-                q.text(","); q.breakable()
-                q.text("out_port = ");
-                q.text(util.pretty_port(self.out_port))
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("actions = ");
-                q.pp(self.actions)
-            q.breakable()
-        q.text('}')
-
-flow_mod.subtypes[3] = flow_delete
-
-class flow_delete_strict(flow_mod):
-    version = 1
-    type = 14
-    _command = 4
-
-    def __init__(self, xid=None, match=None, cookie=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, flags=None, actions=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if idle_timeout != None:
-            self.idle_timeout = idle_timeout
-        else:
-            self.idle_timeout = 0
-        if hard_timeout != None:
-            self.hard_timeout = hard_timeout
-        else:
-            self.hard_timeout = 0
-        if priority != None:
-            self.priority = priority
-        else:
-            self.priority = 0
-        if buffer_id != None:
-            self.buffer_id = buffer_id
-        else:
-            self.buffer_id = 0
-        if out_port != None:
-            self.out_port = out_port
-        else:
-            self.out_port = 0
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if actions != None:
-            self.actions = actions
-        else:
-            self.actions = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(self.match.pack())
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(util.pack_fm_cmd(self._command))
-        packed.append(struct.pack("!H", self.idle_timeout))
-        packed.append(struct.pack("!H", self.hard_timeout))
-        packed.append(struct.pack("!H", self.priority))
-        packed.append(struct.pack("!L", self.buffer_id))
-        packed.append(util.pack_port_no(self.out_port))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append(loxi.generic_util.pack_list(self.actions))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_delete_strict()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 14)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.match = ofp.match.unpack(reader)
-        obj.cookie = reader.read("!Q")[0]
-        __command = util.unpack_fm_cmd(reader)
-        assert(__command == 4)
-        obj.idle_timeout = reader.read("!H")[0]
-        obj.hard_timeout = reader.read("!H")[0]
-        obj.priority = reader.read("!H")[0]
-        obj.buffer_id = reader.read("!L")[0]
-        obj.out_port = util.unpack_port_no(reader)
-        obj.flags = reader.read("!H")[0]
-        obj.actions = loxi.generic_util.unpack_list(reader, ofp.action.action.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.match != other.match: return False
-        if self.cookie != other.cookie: return False
-        if self.idle_timeout != other.idle_timeout: return False
-        if self.hard_timeout != other.hard_timeout: return False
-        if self.priority != other.priority: return False
-        if self.buffer_id != other.buffer_id: return False
-        if self.out_port != other.out_port: return False
-        if self.flags != other.flags: return False
-        if self.actions != other.actions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_delete_strict {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("idle_timeout = ");
-                q.text("%#x" % self.idle_timeout)
-                q.text(","); q.breakable()
-                q.text("hard_timeout = ");
-                q.text("%#x" % self.hard_timeout)
-                q.text(","); q.breakable()
-                q.text("priority = ");
-                q.text("%#x" % self.priority)
-                q.text(","); q.breakable()
-                q.text("buffer_id = ");
-                q.text("%#x" % self.buffer_id)
-                q.text(","); q.breakable()
-                q.text("out_port = ");
-                q.text(util.pretty_port(self.out_port))
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("actions = ");
-                q.pp(self.actions)
-            q.breakable()
-        q.text('}')
-
-flow_mod.subtypes[4] = flow_delete_strict
-
-class flow_mod_failed_error_msg(error_msg):
-    version = 1
-    type = 1
-    err_type = 3
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_mod_failed_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 3)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_mod_failed_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[3] = flow_mod_failed_error_msg
-
-class flow_modify(flow_mod):
-    version = 1
-    type = 14
-    _command = 1
-
-    def __init__(self, xid=None, match=None, cookie=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, flags=None, actions=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if idle_timeout != None:
-            self.idle_timeout = idle_timeout
-        else:
-            self.idle_timeout = 0
-        if hard_timeout != None:
-            self.hard_timeout = hard_timeout
-        else:
-            self.hard_timeout = 0
-        if priority != None:
-            self.priority = priority
-        else:
-            self.priority = 0
-        if buffer_id != None:
-            self.buffer_id = buffer_id
-        else:
-            self.buffer_id = 0
-        if out_port != None:
-            self.out_port = out_port
-        else:
-            self.out_port = 0
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if actions != None:
-            self.actions = actions
-        else:
-            self.actions = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(self.match.pack())
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(util.pack_fm_cmd(self._command))
-        packed.append(struct.pack("!H", self.idle_timeout))
-        packed.append(struct.pack("!H", self.hard_timeout))
-        packed.append(struct.pack("!H", self.priority))
-        packed.append(struct.pack("!L", self.buffer_id))
-        packed.append(util.pack_port_no(self.out_port))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append(loxi.generic_util.pack_list(self.actions))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_modify()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 14)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.match = ofp.match.unpack(reader)
-        obj.cookie = reader.read("!Q")[0]
-        __command = util.unpack_fm_cmd(reader)
-        assert(__command == 1)
-        obj.idle_timeout = reader.read("!H")[0]
-        obj.hard_timeout = reader.read("!H")[0]
-        obj.priority = reader.read("!H")[0]
-        obj.buffer_id = reader.read("!L")[0]
-        obj.out_port = util.unpack_port_no(reader)
-        obj.flags = reader.read("!H")[0]
-        obj.actions = loxi.generic_util.unpack_list(reader, ofp.action.action.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.match != other.match: return False
-        if self.cookie != other.cookie: return False
-        if self.idle_timeout != other.idle_timeout: return False
-        if self.hard_timeout != other.hard_timeout: return False
-        if self.priority != other.priority: return False
-        if self.buffer_id != other.buffer_id: return False
-        if self.out_port != other.out_port: return False
-        if self.flags != other.flags: return False
-        if self.actions != other.actions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_modify {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("idle_timeout = ");
-                q.text("%#x" % self.idle_timeout)
-                q.text(","); q.breakable()
-                q.text("hard_timeout = ");
-                q.text("%#x" % self.hard_timeout)
-                q.text(","); q.breakable()
-                q.text("priority = ");
-                q.text("%#x" % self.priority)
-                q.text(","); q.breakable()
-                q.text("buffer_id = ");
-                q.text("%#x" % self.buffer_id)
-                q.text(","); q.breakable()
-                q.text("out_port = ");
-                q.text(util.pretty_port(self.out_port))
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("actions = ");
-                q.pp(self.actions)
-            q.breakable()
-        q.text('}')
-
-flow_mod.subtypes[1] = flow_modify
-
-class flow_modify_strict(flow_mod):
-    version = 1
-    type = 14
-    _command = 2
-
-    def __init__(self, xid=None, match=None, cookie=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, flags=None, actions=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if idle_timeout != None:
-            self.idle_timeout = idle_timeout
-        else:
-            self.idle_timeout = 0
-        if hard_timeout != None:
-            self.hard_timeout = hard_timeout
-        else:
-            self.hard_timeout = 0
-        if priority != None:
-            self.priority = priority
-        else:
-            self.priority = 0
-        if buffer_id != None:
-            self.buffer_id = buffer_id
-        else:
-            self.buffer_id = 0
-        if out_port != None:
-            self.out_port = out_port
-        else:
-            self.out_port = 0
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if actions != None:
-            self.actions = actions
-        else:
-            self.actions = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(self.match.pack())
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(util.pack_fm_cmd(self._command))
-        packed.append(struct.pack("!H", self.idle_timeout))
-        packed.append(struct.pack("!H", self.hard_timeout))
-        packed.append(struct.pack("!H", self.priority))
-        packed.append(struct.pack("!L", self.buffer_id))
-        packed.append(util.pack_port_no(self.out_port))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append(loxi.generic_util.pack_list(self.actions))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_modify_strict()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 14)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.match = ofp.match.unpack(reader)
-        obj.cookie = reader.read("!Q")[0]
-        __command = util.unpack_fm_cmd(reader)
-        assert(__command == 2)
-        obj.idle_timeout = reader.read("!H")[0]
-        obj.hard_timeout = reader.read("!H")[0]
-        obj.priority = reader.read("!H")[0]
-        obj.buffer_id = reader.read("!L")[0]
-        obj.out_port = util.unpack_port_no(reader)
-        obj.flags = reader.read("!H")[0]
-        obj.actions = loxi.generic_util.unpack_list(reader, ofp.action.action.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.match != other.match: return False
-        if self.cookie != other.cookie: return False
-        if self.idle_timeout != other.idle_timeout: return False
-        if self.hard_timeout != other.hard_timeout: return False
-        if self.priority != other.priority: return False
-        if self.buffer_id != other.buffer_id: return False
-        if self.out_port != other.out_port: return False
-        if self.flags != other.flags: return False
-        if self.actions != other.actions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_modify_strict {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("idle_timeout = ");
-                q.text("%#x" % self.idle_timeout)
-                q.text(","); q.breakable()
-                q.text("hard_timeout = ");
-                q.text("%#x" % self.hard_timeout)
-                q.text(","); q.breakable()
-                q.text("priority = ");
-                q.text("%#x" % self.priority)
-                q.text(","); q.breakable()
-                q.text("buffer_id = ");
-                q.text("%#x" % self.buffer_id)
-                q.text(","); q.breakable()
-                q.text("out_port = ");
-                q.text(util.pretty_port(self.out_port))
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("actions = ");
-                q.pp(self.actions)
-            q.breakable()
-        q.text('}')
-
-flow_mod.subtypes[2] = flow_modify_strict
-
-class flow_removed(message):
-    version = 1
-    type = 11
-
-    def __init__(self, xid=None, match=None, cookie=None, priority=None, reason=None, duration_sec=None, duration_nsec=None, idle_timeout=None, packet_count=None, byte_count=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if priority != None:
-            self.priority = priority
-        else:
-            self.priority = 0
-        if reason != None:
-            self.reason = reason
-        else:
-            self.reason = 0
-        if duration_sec != None:
-            self.duration_sec = duration_sec
-        else:
-            self.duration_sec = 0
-        if duration_nsec != None:
-            self.duration_nsec = duration_nsec
-        else:
-            self.duration_nsec = 0
-        if idle_timeout != None:
-            self.idle_timeout = idle_timeout
-        else:
-            self.idle_timeout = 0
-        if packet_count != None:
-            self.packet_count = packet_count
-        else:
-            self.packet_count = 0
-        if byte_count != None:
-            self.byte_count = byte_count
-        else:
-            self.byte_count = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(self.match.pack())
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(struct.pack("!H", self.priority))
-        packed.append(struct.pack("!B", self.reason))
-        packed.append('\x00' * 1)
-        packed.append(struct.pack("!L", self.duration_sec))
-        packed.append(struct.pack("!L", self.duration_nsec))
-        packed.append(struct.pack("!H", self.idle_timeout))
-        packed.append('\x00' * 2)
-        packed.append(struct.pack("!Q", self.packet_count))
-        packed.append(struct.pack("!Q", self.byte_count))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_removed()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 11)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.match = ofp.match.unpack(reader)
-        obj.cookie = reader.read("!Q")[0]
-        obj.priority = reader.read("!H")[0]
-        obj.reason = reader.read("!B")[0]
-        reader.skip(1)
-        obj.duration_sec = reader.read("!L")[0]
-        obj.duration_nsec = reader.read("!L")[0]
-        obj.idle_timeout = reader.read("!H")[0]
-        reader.skip(2)
-        obj.packet_count = reader.read("!Q")[0]
-        obj.byte_count = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.match != other.match: return False
-        if self.cookie != other.cookie: return False
-        if self.priority != other.priority: return False
-        if self.reason != other.reason: return False
-        if self.duration_sec != other.duration_sec: return False
-        if self.duration_nsec != other.duration_nsec: return False
-        if self.idle_timeout != other.idle_timeout: return False
-        if self.packet_count != other.packet_count: return False
-        if self.byte_count != other.byte_count: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_removed {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("priority = ");
-                q.text("%#x" % self.priority)
-                q.text(","); q.breakable()
-                q.text("reason = ");
-                q.text("%#x" % self.reason)
-                q.text(","); q.breakable()
-                q.text("duration_sec = ");
-                q.text("%#x" % self.duration_sec)
-                q.text(","); q.breakable()
-                q.text("duration_nsec = ");
-                q.text("%#x" % self.duration_nsec)
-                q.text(","); q.breakable()
-                q.text("idle_timeout = ");
-                q.text("%#x" % self.idle_timeout)
-                q.text(","); q.breakable()
-                q.text("packet_count = ");
-                q.text("%#x" % self.packet_count)
-                q.text(","); q.breakable()
-                q.text("byte_count = ");
-                q.text("%#x" % self.byte_count)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[11] = flow_removed
-
-class flow_stats_reply(stats_reply):
-    version = 1
-    type = 17
-    stats_type = 1
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 17)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 1)
-        obj.flags = reader.read("!H")[0]
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.flow_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[1] = flow_stats_reply
-
-class flow_stats_request(stats_request):
-    version = 1
-    type = 16
-    stats_type = 1
-
-    def __init__(self, xid=None, flags=None, match=None, table_id=None, out_port=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if out_port != None:
-            self.out_port = out_port
-        else:
-            self.out_port = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append(self.match.pack())
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append('\x00' * 1)
-        packed.append(util.pack_port_no(self.out_port))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 16)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 1)
-        obj.flags = reader.read("!H")[0]
-        obj.match = ofp.match.unpack(reader)
-        obj.table_id = reader.read("!B")[0]
-        reader.skip(1)
-        obj.out_port = util.unpack_port_no(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.match != other.match: return False
-        if self.table_id != other.table_id: return False
-        if self.out_port != other.out_port: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("out_port = ");
-                q.text(util.pretty_port(self.out_port))
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[1] = flow_stats_request
-
-class get_config_reply(message):
-    version = 1
-    type = 8
-
-    def __init__(self, xid=None, flags=None, miss_send_len=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if miss_send_len != None:
-            self.miss_send_len = miss_send_len
-        else:
-            self.miss_send_len = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append(struct.pack("!H", self.miss_send_len))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = get_config_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 8)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.flags = reader.read("!H")[0]
-        obj.miss_send_len = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.miss_send_len != other.miss_send_len: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("get_config_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("miss_send_len = ");
-                q.text("%#x" % self.miss_send_len)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[8] = get_config_reply
-
-class get_config_request(message):
-    version = 1
-    type = 7
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = get_config_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 7)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("get_config_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-message.subtypes[7] = get_config_request
-
-class hello(message):
-    version = 1
-    type = 0
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = hello()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 0)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("hello {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-message.subtypes[0] = hello
-
-class hello_failed_error_msg(error_msg):
-    version = 1
-    type = 1
-    err_type = 0
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = hello_failed_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 0)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("hello_failed_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[0] = hello_failed_error_msg
-
-class nicira_header(experimenter):
-    subtypes = {}
-
-    version = 1
-    type = 4
-    experimenter = 8992
-
-    def __init__(self, xid=None, subtype=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 12)
-        subclass = nicira_header.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = nicira_header()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 8992)
-        obj.subtype = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.subtype != other.subtype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("nicira_header {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-experimenter.subtypes[8992] = nicira_header
-
-class nicira_controller_role_reply(nicira_header):
-    version = 1
-    type = 4
-    experimenter = 8992
-    subtype = 11
-
-    def __init__(self, xid=None, role=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if role != None:
-            self.role = role
-        else:
-            self.role = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.role))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = nicira_controller_role_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 8992)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 11)
-        obj.role = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.role != other.role: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("nicira_controller_role_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("role = ");
-                q.text("%#x" % self.role)
-            q.breakable()
-        q.text('}')
-
-nicira_header.subtypes[11] = nicira_controller_role_reply
-
-class nicira_controller_role_request(nicira_header):
-    version = 1
-    type = 4
-    experimenter = 8992
-    subtype = 10
-
-    def __init__(self, xid=None, role=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if role != None:
-            self.role = role
-        else:
-            self.role = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.role))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = nicira_controller_role_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 8992)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 10)
-        obj.role = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.role != other.role: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("nicira_controller_role_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("role = ");
-                q.text("%#x" % self.role)
-            q.breakable()
-        q.text('}')
-
-nicira_header.subtypes[10] = nicira_controller_role_request
-
-class packet_in(message):
-    version = 1
-    type = 10
-
-    def __init__(self, xid=None, buffer_id=None, total_len=None, in_port=None, reason=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if buffer_id != None:
-            self.buffer_id = buffer_id
-        else:
-            self.buffer_id = 0
-        if total_len != None:
-            self.total_len = total_len
-        else:
-            self.total_len = 0
-        if in_port != None:
-            self.in_port = in_port
-        else:
-            self.in_port = 0
-        if reason != None:
-            self.reason = reason
-        else:
-            self.reason = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.buffer_id))
-        packed.append(struct.pack("!H", self.total_len))
-        packed.append(util.pack_port_no(self.in_port))
-        packed.append(struct.pack("!B", self.reason))
-        packed.append('\x00' * 1)
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = packet_in()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 10)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.buffer_id = reader.read("!L")[0]
-        obj.total_len = reader.read("!H")[0]
-        obj.in_port = util.unpack_port_no(reader)
-        obj.reason = reader.read("!B")[0]
-        reader.skip(1)
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.buffer_id != other.buffer_id: return False
-        if self.total_len != other.total_len: return False
-        if self.in_port != other.in_port: return False
-        if self.reason != other.reason: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("packet_in {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("buffer_id = ");
-                q.text("%#x" % self.buffer_id)
-                q.text(","); q.breakable()
-                q.text("total_len = ");
-                q.text("%#x" % self.total_len)
-                q.text(","); q.breakable()
-                q.text("in_port = ");
-                q.text(util.pretty_port(self.in_port))
-                q.text(","); q.breakable()
-                q.text("reason = ");
-                q.text("%#x" % self.reason)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[10] = packet_in
-
-class packet_out(message):
-    version = 1
-    type = 13
-
-    def __init__(self, xid=None, buffer_id=None, in_port=None, actions=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if buffer_id != None:
-            self.buffer_id = buffer_id
-        else:
-            self.buffer_id = 0
-        if in_port != None:
-            self.in_port = in_port
-        else:
-            self.in_port = 0
-        if actions != None:
-            self.actions = actions
-        else:
-            self.actions = []
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.buffer_id))
-        packed.append(util.pack_port_no(self.in_port))
-        packed.append(struct.pack("!H", 0)) # placeholder for actions_len at index 6
-        packed.append(loxi.generic_util.pack_list(self.actions))
-        packed[6] = struct.pack("!H", len(packed[-1]))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = packet_out()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 13)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.buffer_id = reader.read("!L")[0]
-        obj.in_port = util.unpack_port_no(reader)
-        _actions_len = reader.read("!H")[0]
-        obj.actions = loxi.generic_util.unpack_list(reader.slice(_actions_len), ofp.action.action.unpack)
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.buffer_id != other.buffer_id: return False
-        if self.in_port != other.in_port: return False
-        if self.actions != other.actions: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("packet_out {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("buffer_id = ");
-                q.text("%#x" % self.buffer_id)
-                q.text(","); q.breakable()
-                q.text("in_port = ");
-                q.text(util.pretty_port(self.in_port))
-                q.text(","); q.breakable()
-                q.text("actions = ");
-                q.pp(self.actions)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[13] = packet_out
-
-class port_mod(message):
-    version = 1
-    type = 15
-
-    def __init__(self, xid=None, port_no=None, hw_addr=None, config=None, mask=None, advertise=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if hw_addr != None:
-            self.hw_addr = hw_addr
-        else:
-            self.hw_addr = [0,0,0,0,0,0]
-        if config != None:
-            self.config = config
-        else:
-            self.config = 0
-        if mask != None:
-            self.mask = mask
-        else:
-            self.mask = 0
-        if advertise != None:
-            self.advertise = advertise
-        else:
-            self.advertise = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(struct.pack("!6B", *self.hw_addr))
-        packed.append(struct.pack("!L", self.config))
-        packed.append(struct.pack("!L", self.mask))
-        packed.append(struct.pack("!L", self.advertise))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = port_mod()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 15)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.port_no = util.unpack_port_no(reader)
-        obj.hw_addr = list(reader.read('!6B'))
-        obj.config = reader.read("!L")[0]
-        obj.mask = reader.read("!L")[0]
-        obj.advertise = reader.read("!L")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.port_no != other.port_no: return False
-        if self.hw_addr != other.hw_addr: return False
-        if self.config != other.config: return False
-        if self.mask != other.mask: return False
-        if self.advertise != other.advertise: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port_mod {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("hw_addr = ");
-                q.text(util.pretty_mac(self.hw_addr))
-                q.text(","); q.breakable()
-                q.text("config = ");
-                q.text("%#x" % self.config)
-                q.text(","); q.breakable()
-                q.text("mask = ");
-                q.text("%#x" % self.mask)
-                q.text(","); q.breakable()
-                q.text("advertise = ");
-                q.text("%#x" % self.advertise)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[15] = port_mod
-
-class port_mod_failed_error_msg(error_msg):
-    version = 1
-    type = 1
-    err_type = 4
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = port_mod_failed_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 4)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port_mod_failed_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[4] = port_mod_failed_error_msg
-
-class port_stats_reply(stats_reply):
-    version = 1
-    type = 17
-    stats_type = 4
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = port_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 17)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 4)
-        obj.flags = reader.read("!H")[0]
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.port_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[4] = port_stats_reply
-
-class port_stats_request(stats_request):
-    version = 1
-    type = 16
-    stats_type = 4
-
-    def __init__(self, xid=None, flags=None, port_no=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append('\x00' * 6)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = port_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 16)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 4)
-        obj.flags = reader.read("!H")[0]
-        obj.port_no = util.unpack_port_no(reader)
-        reader.skip(6)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.port_no != other.port_no: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[4] = port_stats_request
-
-class port_status(message):
-    version = 1
-    type = 12
-
-    def __init__(self, xid=None, reason=None, desc=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if reason != None:
-            self.reason = reason
-        else:
-            self.reason = 0
-        if desc != None:
-            self.desc = desc
-        else:
-            self.desc = ofp.port_desc()
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!B", self.reason))
-        packed.append('\x00' * 7)
-        packed.append(self.desc.pack())
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = port_status()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 12)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.reason = reader.read("!B")[0]
-        reader.skip(7)
-        obj.desc = ofp.port_desc.unpack(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.reason != other.reason: return False
-        if self.desc != other.desc: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port_status {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("reason = ");
-                q.text("%#x" % self.reason)
-                q.text(","); q.breakable()
-                q.text("desc = ");
-                q.pp(self.desc)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[12] = port_status
-
-class queue_get_config_reply(message):
-    version = 1
-    type = 21
-
-    def __init__(self, xid=None, port=None, queues=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if port != None:
-            self.port = port
-        else:
-            self.port = 0
-        if queues != None:
-            self.queues = queues
-        else:
-            self.queues = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(util.pack_port_no(self.port))
-        packed.append('\x00' * 6)
-        packed.append(loxi.generic_util.pack_list(self.queues))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = queue_get_config_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 21)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.port = util.unpack_port_no(reader)
-        reader.skip(6)
-        obj.queues = loxi.generic_util.unpack_list(reader, ofp.common.packet_queue.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.port != other.port: return False
-        if self.queues != other.queues: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_get_config_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("port = ");
-                q.text(util.pretty_port(self.port))
-                q.text(","); q.breakable()
-                q.text("queues = ");
-                q.pp(self.queues)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[21] = queue_get_config_reply
-
-class queue_get_config_request(message):
-    version = 1
-    type = 20
-
-    def __init__(self, xid=None, port=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if port != None:
-            self.port = port
-        else:
-            self.port = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(util.pack_port_no(self.port))
-        packed.append('\x00' * 2)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = queue_get_config_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 20)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.port = util.unpack_port_no(reader)
-        reader.skip(2)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.port != other.port: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_get_config_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("port = ");
-                q.text(util.pretty_port(self.port))
-            q.breakable()
-        q.text('}')
-
-message.subtypes[20] = queue_get_config_request
-
-class queue_op_failed_error_msg(error_msg):
-    version = 1
-    type = 1
-    err_type = 5
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = queue_op_failed_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 5)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_op_failed_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[5] = queue_op_failed_error_msg
-
-class queue_stats_reply(stats_reply):
-    version = 1
-    type = 17
-    stats_type = 5
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = queue_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 17)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 5)
-        obj.flags = reader.read("!H")[0]
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.queue_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[5] = queue_stats_reply
-
-class queue_stats_request(stats_request):
-    version = 1
-    type = 16
-    stats_type = 5
-
-    def __init__(self, xid=None, flags=None, port_no=None, queue_id=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if queue_id != None:
-            self.queue_id = queue_id
-        else:
-            self.queue_id = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append('\x00' * 2)
-        packed.append(struct.pack("!L", self.queue_id))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = queue_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 16)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 5)
-        obj.flags = reader.read("!H")[0]
-        obj.port_no = util.unpack_port_no(reader)
-        reader.skip(2)
-        obj.queue_id = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.port_no != other.port_no: return False
-        if self.queue_id != other.queue_id: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("queue_id = ");
-                q.text("%#x" % self.queue_id)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[5] = queue_stats_request
-
-class set_config(message):
-    version = 1
-    type = 9
-
-    def __init__(self, xid=None, flags=None, miss_send_len=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if miss_send_len != None:
-            self.miss_send_len = miss_send_len
-        else:
-            self.miss_send_len = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append(struct.pack("!H", self.miss_send_len))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_config()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 9)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.flags = reader.read("!H")[0]
-        obj.miss_send_len = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.miss_send_len != other.miss_send_len: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_config {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("miss_send_len = ");
-                q.text("%#x" % self.miss_send_len)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[9] = set_config
-
-class table_mod(message):
-    version = 1
-    type = 22
-
-    def __init__(self, xid=None, table_id=None, config=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if config != None:
-            self.config = config
-        else:
-            self.config = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append('\x00' * 3)
-        packed.append(struct.pack("!L", self.config))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_mod()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 22)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.table_id = reader.read("!B")[0]
-        reader.skip(3)
-        obj.config = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.table_id != other.table_id: return False
-        if self.config != other.config: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_mod {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("config = ");
-                q.text("%#x" % self.config)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[22] = table_mod
-
-class table_stats_reply(stats_reply):
-    version = 1
-    type = 17
-    stats_type = 3
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 17)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 3)
-        obj.flags = reader.read("!H")[0]
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.table_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[3] = table_stats_reply
-
-class table_stats_request(stats_request):
-    version = 1
-    type = 16
-    stats_type = 3
-
-    def __init__(self, xid=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 1)
-        _type = reader.read("!B")[0]
-        assert(_type == 16)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 3)
-        obj.flags = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[3] = table_stats_request
-
-
-def parse_header(buf):
-    if len(buf) < 8:
-        raise loxi.ProtocolError("too short to be an OpenFlow message")
-    return struct.unpack_from("!BBHL", buf)
-
-def parse_message(buf):
-    msg_ver, msg_type, msg_len, msg_xid = parse_header(buf)
-    if msg_ver != ofp.OFP_VERSION and msg_type != ofp.OFPT_HELLO:
-        raise loxi.ProtocolError("wrong OpenFlow version (expected %d, got %d)" % (ofp.OFP_VERSION, msg_ver))
-    if len(buf) != msg_len:
-        raise loxi.ProtocolError("incorrect message size")
-    return message.unpack(loxi.generic_util.OFReader(buf))
diff --git a/python/ofagent/loxi/of10/util.py b/python/ofagent/loxi/of10/util.py
deleted file mode 100644
index 28ffba1..0000000
--- a/python/ofagent/loxi/of10/util.py
+++ /dev/null
@@ -1,139 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-# Automatically generated by LOXI from template util.py
-# Do not modify
-
-import struct
-import loxi
-import const
-import common
-import action
-
-def pretty_mac(mac):
-    return ':'.join(["%02x" % x for x in mac])
-
-def pretty_ipv4(v):
-    return "%d.%d.%d.%d" % ((v >> 24) & 0xFF, (v >> 16) & 0xFF, (v >> 8) & 0xFF, v & 0xFF)
-
-def pretty_flags(v, flag_names):
-    set_flags = []
-    for flag_name in flag_names:
-        flag_value = getattr(const, flag_name)
-        if v & flag_value == flag_value:
-            set_flags.append(flag_name)
-        elif v & flag_value:
-            set_flags.append('%s&%#x' % (flag_name, v & flag_value))
-        v &= ~flag_value
-    if v:
-        set_flags.append("%#x" % v)
-    return '|'.join(set_flags) or '0'
-
-def pretty_wildcards(v):
-    if v == const.OFPFW_ALL:
-        return 'OFPFW_ALL'
-    flag_names = ['OFPFW_IN_PORT', 'OFPFW_DL_VLAN', 'OFPFW_DL_SRC', 'OFPFW_DL_DST',
-                  'OFPFW_DL_TYPE', 'OFPFW_NW_PROTO', 'OFPFW_TP_SRC', 'OFPFW_TP_DST',
-                  'OFPFW_NW_SRC_MASK', 'OFPFW_NW_DST_MASK', 'OFPFW_DL_VLAN_PCP',
-                  'OFPFW_NW_TOS']
-    return pretty_flags(v, flag_names)
-
-def pretty_port(v):
-    named_ports = [(k,v2) for (k,v2) in const.__dict__.iteritems() if k.startswith('OFPP_')]
-    for (k, v2) in named_ports:
-        if v == v2:
-            return k
-    return v
-
-def pack_port_no(value):
-    return struct.pack("!H", value)
-
-def unpack_port_no(reader):
-    return reader.read("!H")[0]
-
-def pack_fm_cmd(value):
-    return struct.pack("!H", value)
-
-def unpack_fm_cmd(reader):
-    return reader.read("!H")[0]
-
-def init_wc_bmap():
-    return const.OFPFW_ALL
-
-def pack_wc_bmap(value):
-    return struct.pack("!L", value)
-
-def unpack_wc_bmap(reader):
-    return reader.read("!L")[0]
-
-def init_match_bmap():
-    return const.OFPFW_ALL
-
-def pack_match_bmap(value):
-    return struct.pack("!L", value)
-
-def unpack_match_bmap(reader):
-    return reader.read("!L")[0]
-
-MASK64 = (1 << 64) - 1
-
-def pack_bitmap_128(value):
-    x = 0l
-    for y in value:
-        x |= 1 << y
-    return struct.pack("!QQ", (x >> 64) & MASK64, x & MASK64)
-
-def unpack_bitmap_128(reader):
-    hi, lo = reader.read("!QQ")
-    x = (hi << 64) | lo
-    i = 0
-    value = set()
-    while x != 0:
-        if x & 1 == 1:
-            value.add(i)
-        i += 1
-        x >>= 1
-    return value
-
-def pack_bitmap_512(value):
-    words = [0] * 8
-    for v in value:
-        assert v < 512
-        words[7-v/64] |= 1 << (v % 64)
-    return struct.pack("!8Q", *words)
-
-def unpack_bitmap_512(reader):
-    words = reader.read("!8Q")
-    x = 0l
-    for word in words:
-        x <<= 64
-        x |= word
-    i = 0
-    value = set()
-    while x != 0:
-        if x & 1 == 1:
-            value.add(i)
-        i += 1
-        x >>= 1
-    return value
-
-def pack_checksum_128(value):
-    return struct.pack("!QQ", (value >> 64) & MASK64, value & MASK64)
-
-def unpack_checksum_128(reader):
-    hi, lo = reader.read("!QQ")
-    return (hi << 64) | lo
diff --git a/python/ofagent/loxi/of11/__init__.py b/python/ofagent/loxi/of11/__init__.py
deleted file mode 100644
index 29d4afe..0000000
--- a/python/ofagent/loxi/of11/__init__.py
+++ /dev/null
@@ -1,29 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template init.py
-# Do not modify
-
-import const
-import action
-import message
-import instruction
-import common
-from const import *
-from common import *
-from loxi import ProtocolError
diff --git a/python/ofagent/loxi/of11/action.py b/python/ofagent/loxi/of11/action.py
deleted file mode 100644
index 79fc2ff..0000000
--- a/python/ofagent/loxi/of11/action.py
+++ /dev/null
@@ -1,1675 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template module.py
-# Do not modify
-
-import struct
-import loxi
-import util
-import loxi.generic_util
-
-import sys
-ofp = sys.modules['loxi.of11']
-
-class action(loxi.OFObject):
-    subtypes = {}
-
-
-    def __init__(self, type=None):
-        if type != None:
-            self.type = type
-        else:
-            self.type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 0)
-        subclass = action.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = action()
-        obj.type = reader.read("!H")[0]
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type != other.type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("action {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-
-class experimenter(action):
-    subtypes = {}
-
-    type = 65535
-
-    def __init__(self, experimenter=None, data=None):
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 4)
-        subclass = experimenter.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = experimenter()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.experimenter = reader.read("!L")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.experimenter != other.experimenter: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("experimenter {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[65535] = experimenter
-
-class bsn(experimenter):
-    subtypes = {}
-
-    type = 65535
-    experimenter = 6035143
-
-    def __init__(self, subtype=None):
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 8)
-        subclass = bsn.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = bsn()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        obj.subtype = reader.read("!L")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.subtype != other.subtype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-experimenter.subtypes[6035143] = bsn
-
-class bsn_checksum(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 4
-
-    def __init__(self, checksum=None):
-        if checksum != None:
-            self.checksum = checksum
-        else:
-            self.checksum = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(util.pack_checksum_128(self.checksum))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_checksum()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 4)
-        obj.checksum = util.unpack_checksum_128(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.checksum != other.checksum: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_checksum {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("checksum = ");
-                q.pp(self.checksum)
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[4] = bsn_checksum
-
-class bsn_mirror(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 1
-
-    def __init__(self, dest_port=None, vlan_tag=None, copy_stage=None):
-        if dest_port != None:
-            self.dest_port = dest_port
-        else:
-            self.dest_port = 0
-        if vlan_tag != None:
-            self.vlan_tag = vlan_tag
-        else:
-            self.vlan_tag = 0
-        if copy_stage != None:
-            self.copy_stage = copy_stage
-        else:
-            self.copy_stage = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.dest_port))
-        packed.append(struct.pack("!L", self.vlan_tag))
-        packed.append(struct.pack("!B", self.copy_stage))
-        packed.append('\x00' * 3)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_mirror()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 1)
-        obj.dest_port = reader.read("!L")[0]
-        obj.vlan_tag = reader.read("!L")[0]
-        obj.copy_stage = reader.read("!B")[0]
-        reader.skip(3)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.dest_port != other.dest_port: return False
-        if self.vlan_tag != other.vlan_tag: return False
-        if self.copy_stage != other.copy_stage: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_mirror {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("dest_port = ");
-                q.text("%#x" % self.dest_port)
-                q.text(","); q.breakable()
-                q.text("vlan_tag = ");
-                q.text("%#x" % self.vlan_tag)
-                q.text(","); q.breakable()
-                q.text("copy_stage = ");
-                q.text("%#x" % self.copy_stage)
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[1] = bsn_mirror
-
-class bsn_set_tunnel_dst(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 2
-
-    def __init__(self, dst=None):
-        if dst != None:
-            self.dst = dst
-        else:
-            self.dst = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.dst))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_set_tunnel_dst()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 2)
-        obj.dst = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.dst != other.dst: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_set_tunnel_dst {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("dst = ");
-                q.text("%#x" % self.dst)
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[2] = bsn_set_tunnel_dst
-
-class copy_ttl_in(action):
-    type = 12
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = copy_ttl_in()
-        _type = reader.read("!H")[0]
-        assert(_type == 12)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("copy_ttl_in {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action.subtypes[12] = copy_ttl_in
-
-class copy_ttl_out(action):
-    type = 11
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = copy_ttl_out()
-        _type = reader.read("!H")[0]
-        assert(_type == 11)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("copy_ttl_out {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action.subtypes[11] = copy_ttl_out
-
-class dec_mpls_ttl(action):
-    type = 16
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = dec_mpls_ttl()
-        _type = reader.read("!H")[0]
-        assert(_type == 16)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("dec_mpls_ttl {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action.subtypes[16] = dec_mpls_ttl
-
-class dec_nw_ttl(action):
-    type = 24
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = dec_nw_ttl()
-        _type = reader.read("!H")[0]
-        assert(_type == 24)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("dec_nw_ttl {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action.subtypes[24] = dec_nw_ttl
-
-class group(action):
-    type = 22
-
-    def __init__(self, group_id=None):
-        if group_id != None:
-            self.group_id = group_id
-        else:
-            self.group_id = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.group_id))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group()
-        _type = reader.read("!H")[0]
-        assert(_type == 22)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.group_id = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.group_id != other.group_id: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("group_id = ");
-                q.text("%#x" % self.group_id)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[22] = group
-
-class nicira(experimenter):
-    subtypes = {}
-
-    type = 65535
-    experimenter = 8992
-
-    def __init__(self, subtype=None):
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!H", self.subtype))
-        packed.append('\x00' * 2)
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 8)
-        subclass = nicira.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = nicira()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 8992)
-        obj.subtype = reader.read("!H")[0]
-        reader.skip(2)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.subtype != other.subtype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("nicira {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-experimenter.subtypes[8992] = nicira
-
-class nicira_dec_ttl(nicira):
-    type = 65535
-    experimenter = 8992
-    subtype = 18
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!H", self.subtype))
-        packed.append('\x00' * 2)
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = nicira_dec_ttl()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 8992)
-        _subtype = reader.read("!H")[0]
-        assert(_subtype == 18)
-        reader.skip(2)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("nicira_dec_ttl {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-nicira.subtypes[18] = nicira_dec_ttl
-
-class output(action):
-    type = 0
-
-    def __init__(self, port=None, max_len=None):
-        if port != None:
-            self.port = port
-        else:
-            self.port = 0
-        if max_len != None:
-            self.max_len = max_len
-        else:
-            self.max_len = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(util.pack_port_no(self.port))
-        packed.append(struct.pack("!H", self.max_len))
-        packed.append('\x00' * 6)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = output()
-        _type = reader.read("!H")[0]
-        assert(_type == 0)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.port = util.unpack_port_no(reader)
-        obj.max_len = reader.read("!H")[0]
-        reader.skip(6)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.port != other.port: return False
-        if self.max_len != other.max_len: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("output {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("port = ");
-                q.text(util.pretty_port(self.port))
-                q.text(","); q.breakable()
-                q.text("max_len = ");
-                q.text("%#x" % self.max_len)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[0] = output
-
-class pop_mpls(action):
-    type = 20
-
-    def __init__(self, ethertype=None):
-        if ethertype != None:
-            self.ethertype = ethertype
-        else:
-            self.ethertype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!H", self.ethertype))
-        packed.append('\x00' * 2)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = pop_mpls()
-        _type = reader.read("!H")[0]
-        assert(_type == 20)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.ethertype = reader.read("!H")[0]
-        reader.skip(2)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.ethertype != other.ethertype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("pop_mpls {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("ethertype = ");
-                q.text("%#x" % self.ethertype)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[20] = pop_mpls
-
-class pop_vlan(action):
-    type = 18
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = pop_vlan()
-        _type = reader.read("!H")[0]
-        assert(_type == 18)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("pop_vlan {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action.subtypes[18] = pop_vlan
-
-class push_mpls(action):
-    type = 19
-
-    def __init__(self, ethertype=None):
-        if ethertype != None:
-            self.ethertype = ethertype
-        else:
-            self.ethertype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!H", self.ethertype))
-        packed.append('\x00' * 2)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = push_mpls()
-        _type = reader.read("!H")[0]
-        assert(_type == 19)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.ethertype = reader.read("!H")[0]
-        reader.skip(2)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.ethertype != other.ethertype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("push_mpls {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("ethertype = ");
-                q.text("%#x" % self.ethertype)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[19] = push_mpls
-
-class push_vlan(action):
-    type = 17
-
-    def __init__(self, ethertype=None):
-        if ethertype != None:
-            self.ethertype = ethertype
-        else:
-            self.ethertype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!H", self.ethertype))
-        packed.append('\x00' * 2)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = push_vlan()
-        _type = reader.read("!H")[0]
-        assert(_type == 17)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.ethertype = reader.read("!H")[0]
-        reader.skip(2)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.ethertype != other.ethertype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("push_vlan {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("ethertype = ");
-                q.text("%#x" % self.ethertype)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[17] = push_vlan
-
-class set_dl_dst(action):
-    type = 4
-
-    def __init__(self, dl_addr=None):
-        if dl_addr != None:
-            self.dl_addr = dl_addr
-        else:
-            self.dl_addr = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!6B", *self.dl_addr))
-        packed.append('\x00' * 6)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_dl_dst()
-        _type = reader.read("!H")[0]
-        assert(_type == 4)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.dl_addr = list(reader.read('!6B'))
-        reader.skip(6)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.dl_addr != other.dl_addr: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_dl_dst {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("dl_addr = ");
-                q.text(util.pretty_mac(self.dl_addr))
-            q.breakable()
-        q.text('}')
-
-action.subtypes[4] = set_dl_dst
-
-class set_dl_src(action):
-    type = 3
-
-    def __init__(self, dl_addr=None):
-        if dl_addr != None:
-            self.dl_addr = dl_addr
-        else:
-            self.dl_addr = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!6B", *self.dl_addr))
-        packed.append('\x00' * 6)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_dl_src()
-        _type = reader.read("!H")[0]
-        assert(_type == 3)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.dl_addr = list(reader.read('!6B'))
-        reader.skip(6)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.dl_addr != other.dl_addr: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_dl_src {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("dl_addr = ");
-                q.text(util.pretty_mac(self.dl_addr))
-            q.breakable()
-        q.text('}')
-
-action.subtypes[3] = set_dl_src
-
-class set_mpls_label(action):
-    type = 13
-
-    def __init__(self, mpls_label=None):
-        if mpls_label != None:
-            self.mpls_label = mpls_label
-        else:
-            self.mpls_label = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.mpls_label))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_mpls_label()
-        _type = reader.read("!H")[0]
-        assert(_type == 13)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.mpls_label = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.mpls_label != other.mpls_label: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_mpls_label {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("mpls_label = ");
-                q.text("%#x" % self.mpls_label)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[13] = set_mpls_label
-
-class set_mpls_tc(action):
-    type = 14
-
-    def __init__(self, mpls_tc=None):
-        if mpls_tc != None:
-            self.mpls_tc = mpls_tc
-        else:
-            self.mpls_tc = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!B", self.mpls_tc))
-        packed.append('\x00' * 3)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_mpls_tc()
-        _type = reader.read("!H")[0]
-        assert(_type == 14)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.mpls_tc = reader.read("!B")[0]
-        reader.skip(3)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.mpls_tc != other.mpls_tc: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_mpls_tc {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("mpls_tc = ");
-                q.text("%#x" % self.mpls_tc)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[14] = set_mpls_tc
-
-class set_mpls_ttl(action):
-    type = 15
-
-    def __init__(self, mpls_ttl=None):
-        if mpls_ttl != None:
-            self.mpls_ttl = mpls_ttl
-        else:
-            self.mpls_ttl = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!B", self.mpls_ttl))
-        packed.append('\x00' * 3)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_mpls_ttl()
-        _type = reader.read("!H")[0]
-        assert(_type == 15)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.mpls_ttl = reader.read("!B")[0]
-        reader.skip(3)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.mpls_ttl != other.mpls_ttl: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_mpls_ttl {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("mpls_ttl = ");
-                q.text("%#x" % self.mpls_ttl)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[15] = set_mpls_ttl
-
-class set_nw_dst(action):
-    type = 6
-
-    def __init__(self, nw_addr=None):
-        if nw_addr != None:
-            self.nw_addr = nw_addr
-        else:
-            self.nw_addr = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.nw_addr))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_nw_dst()
-        _type = reader.read("!H")[0]
-        assert(_type == 6)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.nw_addr = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.nw_addr != other.nw_addr: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_nw_dst {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("nw_addr = ");
-                q.text("%#x" % self.nw_addr)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[6] = set_nw_dst
-
-class set_nw_ecn(action):
-    type = 8
-
-    def __init__(self, nw_ecn=None):
-        if nw_ecn != None:
-            self.nw_ecn = nw_ecn
-        else:
-            self.nw_ecn = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!B", self.nw_ecn))
-        packed.append('\x00' * 3)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_nw_ecn()
-        _type = reader.read("!H")[0]
-        assert(_type == 8)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.nw_ecn = reader.read("!B")[0]
-        reader.skip(3)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.nw_ecn != other.nw_ecn: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_nw_ecn {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("nw_ecn = ");
-                q.text("%#x" % self.nw_ecn)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[8] = set_nw_ecn
-
-class set_nw_src(action):
-    type = 5
-
-    def __init__(self, nw_addr=None):
-        if nw_addr != None:
-            self.nw_addr = nw_addr
-        else:
-            self.nw_addr = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.nw_addr))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_nw_src()
-        _type = reader.read("!H")[0]
-        assert(_type == 5)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.nw_addr = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.nw_addr != other.nw_addr: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_nw_src {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("nw_addr = ");
-                q.text("%#x" % self.nw_addr)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[5] = set_nw_src
-
-class set_nw_tos(action):
-    type = 7
-
-    def __init__(self, nw_tos=None):
-        if nw_tos != None:
-            self.nw_tos = nw_tos
-        else:
-            self.nw_tos = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!B", self.nw_tos))
-        packed.append('\x00' * 3)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_nw_tos()
-        _type = reader.read("!H")[0]
-        assert(_type == 7)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.nw_tos = reader.read("!B")[0]
-        reader.skip(3)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.nw_tos != other.nw_tos: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_nw_tos {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("nw_tos = ");
-                q.text("%#x" % self.nw_tos)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[7] = set_nw_tos
-
-class set_nw_ttl(action):
-    type = 23
-
-    def __init__(self, nw_ttl=None):
-        if nw_ttl != None:
-            self.nw_ttl = nw_ttl
-        else:
-            self.nw_ttl = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!B", self.nw_ttl))
-        packed.append('\x00' * 3)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_nw_ttl()
-        _type = reader.read("!H")[0]
-        assert(_type == 23)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.nw_ttl = reader.read("!B")[0]
-        reader.skip(3)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.nw_ttl != other.nw_ttl: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_nw_ttl {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("nw_ttl = ");
-                q.text("%#x" % self.nw_ttl)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[23] = set_nw_ttl
-
-class set_queue(action):
-    type = 21
-
-    def __init__(self, queue_id=None):
-        if queue_id != None:
-            self.queue_id = queue_id
-        else:
-            self.queue_id = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.queue_id))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_queue()
-        _type = reader.read("!H")[0]
-        assert(_type == 21)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.queue_id = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.queue_id != other.queue_id: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_queue {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("queue_id = ");
-                q.text("%#x" % self.queue_id)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[21] = set_queue
-
-class set_tp_dst(action):
-    type = 10
-
-    def __init__(self, tp_port=None):
-        if tp_port != None:
-            self.tp_port = tp_port
-        else:
-            self.tp_port = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!H", self.tp_port))
-        packed.append('\x00' * 2)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_tp_dst()
-        _type = reader.read("!H")[0]
-        assert(_type == 10)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.tp_port = reader.read("!H")[0]
-        reader.skip(2)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.tp_port != other.tp_port: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_tp_dst {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("tp_port = ");
-                q.text("%#x" % self.tp_port)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[10] = set_tp_dst
-
-class set_tp_src(action):
-    type = 9
-
-    def __init__(self, tp_port=None):
-        if tp_port != None:
-            self.tp_port = tp_port
-        else:
-            self.tp_port = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!H", self.tp_port))
-        packed.append('\x00' * 2)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_tp_src()
-        _type = reader.read("!H")[0]
-        assert(_type == 9)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.tp_port = reader.read("!H")[0]
-        reader.skip(2)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.tp_port != other.tp_port: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_tp_src {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("tp_port = ");
-                q.text("%#x" % self.tp_port)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[9] = set_tp_src
-
-class set_vlan_pcp(action):
-    type = 2
-
-    def __init__(self, vlan_pcp=None):
-        if vlan_pcp != None:
-            self.vlan_pcp = vlan_pcp
-        else:
-            self.vlan_pcp = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!B", self.vlan_pcp))
-        packed.append('\x00' * 3)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_vlan_pcp()
-        _type = reader.read("!H")[0]
-        assert(_type == 2)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.vlan_pcp = reader.read("!B")[0]
-        reader.skip(3)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.vlan_pcp != other.vlan_pcp: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_vlan_pcp {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("vlan_pcp = ");
-                q.text("%#x" % self.vlan_pcp)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[2] = set_vlan_pcp
-
-class set_vlan_vid(action):
-    type = 1
-
-    def __init__(self, vlan_vid=None):
-        if vlan_vid != None:
-            self.vlan_vid = vlan_vid
-        else:
-            self.vlan_vid = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!H", self.vlan_vid))
-        packed.append('\x00' * 2)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_vlan_vid()
-        _type = reader.read("!H")[0]
-        assert(_type == 1)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.vlan_vid = reader.read("!H")[0]
-        reader.skip(2)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.vlan_vid != other.vlan_vid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_vlan_vid {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("vlan_vid = ");
-                q.text("%#x" % self.vlan_vid)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[1] = set_vlan_vid
-
-
diff --git a/python/ofagent/loxi/of11/common.py b/python/ofagent/loxi/of11/common.py
deleted file mode 100644
index dadd6bc..0000000
--- a/python/ofagent/loxi/of11/common.py
+++ /dev/null
@@ -1,1744 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template module.py
-# Do not modify
-
-import struct
-import loxi
-import util
-import loxi.generic_util
-
-import sys
-ofp = sys.modules['loxi.of11']
-
-class bsn_interface(loxi.OFObject):
-
-    def __init__(self, hw_addr=None, name=None, ipv4_addr=None, ipv4_netmask=None):
-        if hw_addr != None:
-            self.hw_addr = hw_addr
-        else:
-            self.hw_addr = [0,0,0,0,0,0]
-        if name != None:
-            self.name = name
-        else:
-            self.name = ""
-        if ipv4_addr != None:
-            self.ipv4_addr = ipv4_addr
-        else:
-            self.ipv4_addr = 0
-        if ipv4_netmask != None:
-            self.ipv4_netmask = ipv4_netmask
-        else:
-            self.ipv4_netmask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!6B", *self.hw_addr))
-        packed.append('\x00' * 2)
-        packed.append(struct.pack("!16s", self.name))
-        packed.append(struct.pack("!L", self.ipv4_addr))
-        packed.append(struct.pack("!L", self.ipv4_netmask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_interface()
-        obj.hw_addr = list(reader.read('!6B'))
-        reader.skip(2)
-        obj.name = reader.read("!16s")[0].rstrip("\x00")
-        obj.ipv4_addr = reader.read("!L")[0]
-        obj.ipv4_netmask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.hw_addr != other.hw_addr: return False
-        if self.name != other.name: return False
-        if self.ipv4_addr != other.ipv4_addr: return False
-        if self.ipv4_netmask != other.ipv4_netmask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_interface {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("hw_addr = ");
-                q.text(util.pretty_mac(self.hw_addr))
-                q.text(","); q.breakable()
-                q.text("name = ");
-                q.pp(self.name)
-                q.text(","); q.breakable()
-                q.text("ipv4_addr = ");
-                q.text(util.pretty_ipv4(self.ipv4_addr))
-                q.text(","); q.breakable()
-                q.text("ipv4_netmask = ");
-                q.text(util.pretty_ipv4(self.ipv4_netmask))
-            q.breakable()
-        q.text('}')
-
-
-class bsn_vport(loxi.OFObject):
-    subtypes = {}
-
-
-    def __init__(self, type=None):
-        if type != None:
-            self.type = type
-        else:
-            self.type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 0)
-        subclass = bsn_vport.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = bsn_vport()
-        obj.type = reader.read("!H")[0]
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type != other.type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vport {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-
-class bsn_vport_l2gre(bsn_vport):
-    type = 1
-
-    def __init__(self, flags=None, port_no=None, loopback_port_no=None, local_mac=None, nh_mac=None, src_ip=None, dst_ip=None, dscp=None, ttl=None, vpn=None, rate_limit=None, if_name=None):
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if loopback_port_no != None:
-            self.loopback_port_no = loopback_port_no
-        else:
-            self.loopback_port_no = 0
-        if local_mac != None:
-            self.local_mac = local_mac
-        else:
-            self.local_mac = [0,0,0,0,0,0]
-        if nh_mac != None:
-            self.nh_mac = nh_mac
-        else:
-            self.nh_mac = [0,0,0,0,0,0]
-        if src_ip != None:
-            self.src_ip = src_ip
-        else:
-            self.src_ip = 0
-        if dst_ip != None:
-            self.dst_ip = dst_ip
-        else:
-            self.dst_ip = 0
-        if dscp != None:
-            self.dscp = dscp
-        else:
-            self.dscp = 0
-        if ttl != None:
-            self.ttl = ttl
-        else:
-            self.ttl = 0
-        if vpn != None:
-            self.vpn = vpn
-        else:
-            self.vpn = 0
-        if rate_limit != None:
-            self.rate_limit = rate_limit
-        else:
-            self.rate_limit = 0
-        if if_name != None:
-            self.if_name = if_name
-        else:
-            self.if_name = ""
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.flags))
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(util.pack_port_no(self.loopback_port_no))
-        packed.append(struct.pack("!6B", *self.local_mac))
-        packed.append(struct.pack("!6B", *self.nh_mac))
-        packed.append(struct.pack("!L", self.src_ip))
-        packed.append(struct.pack("!L", self.dst_ip))
-        packed.append(struct.pack("!B", self.dscp))
-        packed.append(struct.pack("!B", self.ttl))
-        packed.append('\x00' * 2)
-        packed.append(struct.pack("!L", self.vpn))
-        packed.append(struct.pack("!L", self.rate_limit))
-        packed.append(struct.pack("!16s", self.if_name))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_vport_l2gre()
-        _type = reader.read("!H")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.flags = reader.read("!L")[0]
-        obj.port_no = util.unpack_port_no(reader)
-        obj.loopback_port_no = util.unpack_port_no(reader)
-        obj.local_mac = list(reader.read('!6B'))
-        obj.nh_mac = list(reader.read('!6B'))
-        obj.src_ip = reader.read("!L")[0]
-        obj.dst_ip = reader.read("!L")[0]
-        obj.dscp = reader.read("!B")[0]
-        obj.ttl = reader.read("!B")[0]
-        reader.skip(2)
-        obj.vpn = reader.read("!L")[0]
-        obj.rate_limit = reader.read("!L")[0]
-        obj.if_name = reader.read("!16s")[0].rstrip("\x00")
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.flags != other.flags: return False
-        if self.port_no != other.port_no: return False
-        if self.loopback_port_no != other.loopback_port_no: return False
-        if self.local_mac != other.local_mac: return False
-        if self.nh_mac != other.nh_mac: return False
-        if self.src_ip != other.src_ip: return False
-        if self.dst_ip != other.dst_ip: return False
-        if self.dscp != other.dscp: return False
-        if self.ttl != other.ttl: return False
-        if self.vpn != other.vpn: return False
-        if self.rate_limit != other.rate_limit: return False
-        if self.if_name != other.if_name: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vport_l2gre {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("loopback_port_no = ");
-                q.text(util.pretty_port(self.loopback_port_no))
-                q.text(","); q.breakable()
-                q.text("local_mac = ");
-                q.text(util.pretty_mac(self.local_mac))
-                q.text(","); q.breakable()
-                q.text("nh_mac = ");
-                q.text(util.pretty_mac(self.nh_mac))
-                q.text(","); q.breakable()
-                q.text("src_ip = ");
-                q.text(util.pretty_ipv4(self.src_ip))
-                q.text(","); q.breakable()
-                q.text("dst_ip = ");
-                q.text(util.pretty_ipv4(self.dst_ip))
-                q.text(","); q.breakable()
-                q.text("dscp = ");
-                q.text("%#x" % self.dscp)
-                q.text(","); q.breakable()
-                q.text("ttl = ");
-                q.text("%#x" % self.ttl)
-                q.text(","); q.breakable()
-                q.text("vpn = ");
-                q.text("%#x" % self.vpn)
-                q.text(","); q.breakable()
-                q.text("rate_limit = ");
-                q.text("%#x" % self.rate_limit)
-                q.text(","); q.breakable()
-                q.text("if_name = ");
-                q.pp(self.if_name)
-            q.breakable()
-        q.text('}')
-
-bsn_vport.subtypes[1] = bsn_vport_l2gre
-
-class bsn_vport_q_in_q(bsn_vport):
-    type = 0
-
-    def __init__(self, port_no=None, ingress_tpid=None, ingress_vlan_id=None, egress_tpid=None, egress_vlan_id=None, if_name=None):
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if ingress_tpid != None:
-            self.ingress_tpid = ingress_tpid
-        else:
-            self.ingress_tpid = 0
-        if ingress_vlan_id != None:
-            self.ingress_vlan_id = ingress_vlan_id
-        else:
-            self.ingress_vlan_id = 0
-        if egress_tpid != None:
-            self.egress_tpid = egress_tpid
-        else:
-            self.egress_tpid = 0
-        if egress_vlan_id != None:
-            self.egress_vlan_id = egress_vlan_id
-        else:
-            self.egress_vlan_id = 0
-        if if_name != None:
-            self.if_name = if_name
-        else:
-            self.if_name = ""
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.port_no))
-        packed.append(struct.pack("!H", self.ingress_tpid))
-        packed.append(struct.pack("!H", self.ingress_vlan_id))
-        packed.append(struct.pack("!H", self.egress_tpid))
-        packed.append(struct.pack("!H", self.egress_vlan_id))
-        packed.append(struct.pack("!16s", self.if_name))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_vport_q_in_q()
-        _type = reader.read("!H")[0]
-        assert(_type == 0)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.port_no = reader.read("!L")[0]
-        obj.ingress_tpid = reader.read("!H")[0]
-        obj.ingress_vlan_id = reader.read("!H")[0]
-        obj.egress_tpid = reader.read("!H")[0]
-        obj.egress_vlan_id = reader.read("!H")[0]
-        obj.if_name = reader.read("!16s")[0].rstrip("\x00")
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.port_no != other.port_no: return False
-        if self.ingress_tpid != other.ingress_tpid: return False
-        if self.ingress_vlan_id != other.ingress_vlan_id: return False
-        if self.egress_tpid != other.egress_tpid: return False
-        if self.egress_vlan_id != other.egress_vlan_id: return False
-        if self.if_name != other.if_name: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vport_q_in_q {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("port_no = ");
-                q.text("%#x" % self.port_no)
-                q.text(","); q.breakable()
-                q.text("ingress_tpid = ");
-                q.text("%#x" % self.ingress_tpid)
-                q.text(","); q.breakable()
-                q.text("ingress_vlan_id = ");
-                q.text("%#x" % self.ingress_vlan_id)
-                q.text(","); q.breakable()
-                q.text("egress_tpid = ");
-                q.text("%#x" % self.egress_tpid)
-                q.text(","); q.breakable()
-                q.text("egress_vlan_id = ");
-                q.text("%#x" % self.egress_vlan_id)
-                q.text(","); q.breakable()
-                q.text("if_name = ");
-                q.pp(self.if_name)
-            q.breakable()
-        q.text('}')
-
-bsn_vport.subtypes[0] = bsn_vport_q_in_q
-
-class bucket(loxi.OFObject):
-
-    def __init__(self, weight=None, watch_port=None, watch_group=None, actions=None):
-        if weight != None:
-            self.weight = weight
-        else:
-            self.weight = 0
-        if watch_port != None:
-            self.watch_port = watch_port
-        else:
-            self.watch_port = 0
-        if watch_group != None:
-            self.watch_group = watch_group
-        else:
-            self.watch_group = 0
-        if actions != None:
-            self.actions = actions
-        else:
-            self.actions = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 0
-        packed.append(struct.pack("!H", self.weight))
-        packed.append(util.pack_port_no(self.watch_port))
-        packed.append(struct.pack("!L", self.watch_group))
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.actions))
-        length = sum([len(x) for x in packed])
-        packed[0] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bucket()
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 2)
-        obj.weight = reader.read("!H")[0]
-        obj.watch_port = util.unpack_port_no(reader)
-        obj.watch_group = reader.read("!L")[0]
-        reader.skip(4)
-        obj.actions = loxi.generic_util.unpack_list(reader, ofp.action.action.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.weight != other.weight: return False
-        if self.watch_port != other.watch_port: return False
-        if self.watch_group != other.watch_group: return False
-        if self.actions != other.actions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bucket {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("weight = ");
-                q.text("%#x" % self.weight)
-                q.text(","); q.breakable()
-                q.text("watch_port = ");
-                q.text(util.pretty_port(self.watch_port))
-                q.text(","); q.breakable()
-                q.text("watch_group = ");
-                q.text("%#x" % self.watch_group)
-                q.text(","); q.breakable()
-                q.text("actions = ");
-                q.pp(self.actions)
-            q.breakable()
-        q.text('}')
-
-
-class bucket_counter(loxi.OFObject):
-
-    def __init__(self, packet_count=None, byte_count=None):
-        if packet_count != None:
-            self.packet_count = packet_count
-        else:
-            self.packet_count = 0
-        if byte_count != None:
-            self.byte_count = byte_count
-        else:
-            self.byte_count = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!Q", self.packet_count))
-        packed.append(struct.pack("!Q", self.byte_count))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bucket_counter()
-        obj.packet_count = reader.read("!Q")[0]
-        obj.byte_count = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.packet_count != other.packet_count: return False
-        if self.byte_count != other.byte_count: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bucket_counter {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("packet_count = ");
-                q.text("%#x" % self.packet_count)
-                q.text(","); q.breakable()
-                q.text("byte_count = ");
-                q.text("%#x" % self.byte_count)
-            q.breakable()
-        q.text('}')
-
-
-class flow_stats_entry(loxi.OFObject):
-
-    def __init__(self, table_id=None, duration_sec=None, duration_nsec=None, priority=None, idle_timeout=None, hard_timeout=None, cookie=None, packet_count=None, byte_count=None, match=None, instructions=None):
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if duration_sec != None:
-            self.duration_sec = duration_sec
-        else:
-            self.duration_sec = 0
-        if duration_nsec != None:
-            self.duration_nsec = duration_nsec
-        else:
-            self.duration_nsec = 0
-        if priority != None:
-            self.priority = priority
-        else:
-            self.priority = 0
-        if idle_timeout != None:
-            self.idle_timeout = idle_timeout
-        else:
-            self.idle_timeout = 0
-        if hard_timeout != None:
-            self.hard_timeout = hard_timeout
-        else:
-            self.hard_timeout = 0
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if packet_count != None:
-            self.packet_count = packet_count
-        else:
-            self.packet_count = 0
-        if byte_count != None:
-            self.byte_count = byte_count
-        else:
-            self.byte_count = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        if instructions != None:
-            self.instructions = instructions
-        else:
-            self.instructions = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 0
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append('\x00' * 1)
-        packed.append(struct.pack("!L", self.duration_sec))
-        packed.append(struct.pack("!L", self.duration_nsec))
-        packed.append(struct.pack("!H", self.priority))
-        packed.append(struct.pack("!H", self.idle_timeout))
-        packed.append(struct.pack("!H", self.hard_timeout))
-        packed.append('\x00' * 6)
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(struct.pack("!Q", self.packet_count))
-        packed.append(struct.pack("!Q", self.byte_count))
-        packed.append(self.match.pack())
-        packed.append(loxi.generic_util.pack_list(self.instructions))
-        length = sum([len(x) for x in packed])
-        packed[0] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_stats_entry()
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 2)
-        obj.table_id = reader.read("!B")[0]
-        reader.skip(1)
-        obj.duration_sec = reader.read("!L")[0]
-        obj.duration_nsec = reader.read("!L")[0]
-        obj.priority = reader.read("!H")[0]
-        obj.idle_timeout = reader.read("!H")[0]
-        obj.hard_timeout = reader.read("!H")[0]
-        reader.skip(6)
-        obj.cookie = reader.read("!Q")[0]
-        obj.packet_count = reader.read("!Q")[0]
-        obj.byte_count = reader.read("!Q")[0]
-        obj.match = ofp.match.unpack(reader)
-        obj.instructions = loxi.generic_util.unpack_list(reader, ofp.instruction.instruction.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.table_id != other.table_id: return False
-        if self.duration_sec != other.duration_sec: return False
-        if self.duration_nsec != other.duration_nsec: return False
-        if self.priority != other.priority: return False
-        if self.idle_timeout != other.idle_timeout: return False
-        if self.hard_timeout != other.hard_timeout: return False
-        if self.cookie != other.cookie: return False
-        if self.packet_count != other.packet_count: return False
-        if self.byte_count != other.byte_count: return False
-        if self.match != other.match: return False
-        if self.instructions != other.instructions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("duration_sec = ");
-                q.text("%#x" % self.duration_sec)
-                q.text(","); q.breakable()
-                q.text("duration_nsec = ");
-                q.text("%#x" % self.duration_nsec)
-                q.text(","); q.breakable()
-                q.text("priority = ");
-                q.text("%#x" % self.priority)
-                q.text(","); q.breakable()
-                q.text("idle_timeout = ");
-                q.text("%#x" % self.idle_timeout)
-                q.text(","); q.breakable()
-                q.text("hard_timeout = ");
-                q.text("%#x" % self.hard_timeout)
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("packet_count = ");
-                q.text("%#x" % self.packet_count)
-                q.text(","); q.breakable()
-                q.text("byte_count = ");
-                q.text("%#x" % self.byte_count)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-                q.text(","); q.breakable()
-                q.text("instructions = ");
-                q.pp(self.instructions)
-            q.breakable()
-        q.text('}')
-
-
-class group_desc_stats_entry(loxi.OFObject):
-
-    def __init__(self, group_type=None, group_id=None, buckets=None):
-        if group_type != None:
-            self.group_type = group_type
-        else:
-            self.group_type = 0
-        if group_id != None:
-            self.group_id = group_id
-        else:
-            self.group_id = 0
-        if buckets != None:
-            self.buckets = buckets
-        else:
-            self.buckets = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 0
-        packed.append(struct.pack("!B", self.group_type))
-        packed.append('\x00' * 1)
-        packed.append(struct.pack("!L", self.group_id))
-        packed.append(loxi.generic_util.pack_list(self.buckets))
-        length = sum([len(x) for x in packed])
-        packed[0] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group_desc_stats_entry()
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 2)
-        obj.group_type = reader.read("!B")[0]
-        reader.skip(1)
-        obj.group_id = reader.read("!L")[0]
-        obj.buckets = loxi.generic_util.unpack_list(reader, ofp.common.bucket.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.group_type != other.group_type: return False
-        if self.group_id != other.group_id: return False
-        if self.buckets != other.buckets: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_desc_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("group_type = ");
-                q.text("%#x" % self.group_type)
-                q.text(","); q.breakable()
-                q.text("group_id = ");
-                q.text("%#x" % self.group_id)
-                q.text(","); q.breakable()
-                q.text("buckets = ");
-                q.pp(self.buckets)
-            q.breakable()
-        q.text('}')
-
-
-class group_stats_entry(loxi.OFObject):
-
-    def __init__(self, group_id=None, ref_count=None, packet_count=None, byte_count=None, bucket_stats=None):
-        if group_id != None:
-            self.group_id = group_id
-        else:
-            self.group_id = 0
-        if ref_count != None:
-            self.ref_count = ref_count
-        else:
-            self.ref_count = 0
-        if packet_count != None:
-            self.packet_count = packet_count
-        else:
-            self.packet_count = 0
-        if byte_count != None:
-            self.byte_count = byte_count
-        else:
-            self.byte_count = 0
-        if bucket_stats != None:
-            self.bucket_stats = bucket_stats
-        else:
-            self.bucket_stats = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 0
-        packed.append('\x00' * 2)
-        packed.append(struct.pack("!L", self.group_id))
-        packed.append(struct.pack("!L", self.ref_count))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!Q", self.packet_count))
-        packed.append(struct.pack("!Q", self.byte_count))
-        packed.append(loxi.generic_util.pack_list(self.bucket_stats))
-        length = sum([len(x) for x in packed])
-        packed[0] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group_stats_entry()
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 2)
-        reader.skip(2)
-        obj.group_id = reader.read("!L")[0]
-        obj.ref_count = reader.read("!L")[0]
-        reader.skip(4)
-        obj.packet_count = reader.read("!Q")[0]
-        obj.byte_count = reader.read("!Q")[0]
-        obj.bucket_stats = loxi.generic_util.unpack_list(reader, ofp.common.bucket_counter.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.group_id != other.group_id: return False
-        if self.ref_count != other.ref_count: return False
-        if self.packet_count != other.packet_count: return False
-        if self.byte_count != other.byte_count: return False
-        if self.bucket_stats != other.bucket_stats: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("group_id = ");
-                q.text("%#x" % self.group_id)
-                q.text(","); q.breakable()
-                q.text("ref_count = ");
-                q.text("%#x" % self.ref_count)
-                q.text(","); q.breakable()
-                q.text("packet_count = ");
-                q.text("%#x" % self.packet_count)
-                q.text(","); q.breakable()
-                q.text("byte_count = ");
-                q.text("%#x" % self.byte_count)
-                q.text(","); q.breakable()
-                q.text("bucket_stats = ");
-                q.pp(self.bucket_stats)
-            q.breakable()
-        q.text('}')
-
-
-class match_v2(loxi.OFObject):
-    type = 0
-
-    def __init__(self, in_port=None, wildcards=None, eth_src=None, eth_src_mask=None, eth_dst=None, eth_dst_mask=None, vlan_vid=None, vlan_pcp=None, eth_type=None, ip_dscp=None, ip_proto=None, ipv4_src=None, ipv4_src_mask=None, ipv4_dst=None, ipv4_dst_mask=None, tcp_src=None, tcp_dst=None, mpls_label=None, mpls_tc=None, metadata=None, metadata_mask=None):
-        if in_port != None:
-            self.in_port = in_port
-        else:
-            self.in_port = 0
-        if wildcards != None:
-            self.wildcards = wildcards
-        else:
-            self.wildcards = util.init_wc_bmap()
-        if eth_src != None:
-            self.eth_src = eth_src
-        else:
-            self.eth_src = [0,0,0,0,0,0]
-        if eth_src_mask != None:
-            self.eth_src_mask = eth_src_mask
-        else:
-            self.eth_src_mask = [0,0,0,0,0,0]
-        if eth_dst != None:
-            self.eth_dst = eth_dst
-        else:
-            self.eth_dst = [0,0,0,0,0,0]
-        if eth_dst_mask != None:
-            self.eth_dst_mask = eth_dst_mask
-        else:
-            self.eth_dst_mask = [0,0,0,0,0,0]
-        if vlan_vid != None:
-            self.vlan_vid = vlan_vid
-        else:
-            self.vlan_vid = 0
-        if vlan_pcp != None:
-            self.vlan_pcp = vlan_pcp
-        else:
-            self.vlan_pcp = 0
-        if eth_type != None:
-            self.eth_type = eth_type
-        else:
-            self.eth_type = 0
-        if ip_dscp != None:
-            self.ip_dscp = ip_dscp
-        else:
-            self.ip_dscp = 0
-        if ip_proto != None:
-            self.ip_proto = ip_proto
-        else:
-            self.ip_proto = 0
-        if ipv4_src != None:
-            self.ipv4_src = ipv4_src
-        else:
-            self.ipv4_src = 0
-        if ipv4_src_mask != None:
-            self.ipv4_src_mask = ipv4_src_mask
-        else:
-            self.ipv4_src_mask = 0
-        if ipv4_dst != None:
-            self.ipv4_dst = ipv4_dst
-        else:
-            self.ipv4_dst = 0
-        if ipv4_dst_mask != None:
-            self.ipv4_dst_mask = ipv4_dst_mask
-        else:
-            self.ipv4_dst_mask = 0
-        if tcp_src != None:
-            self.tcp_src = tcp_src
-        else:
-            self.tcp_src = 0
-        if tcp_dst != None:
-            self.tcp_dst = tcp_dst
-        else:
-            self.tcp_dst = 0
-        if mpls_label != None:
-            self.mpls_label = mpls_label
-        else:
-            self.mpls_label = 0
-        if mpls_tc != None:
-            self.mpls_tc = mpls_tc
-        else:
-            self.mpls_tc = 0
-        if metadata != None:
-            self.metadata = metadata
-        else:
-            self.metadata = 0
-        if metadata_mask != None:
-            self.metadata_mask = metadata_mask
-        else:
-            self.metadata_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(util.pack_port_no(self.in_port))
-        packed.append(util.pack_wc_bmap(self.wildcards))
-        packed.append(struct.pack("!6B", *self.eth_src))
-        packed.append(struct.pack("!6B", *self.eth_src_mask))
-        packed.append(struct.pack("!6B", *self.eth_dst))
-        packed.append(struct.pack("!6B", *self.eth_dst_mask))
-        packed.append(struct.pack("!H", self.vlan_vid))
-        packed.append(struct.pack("!B", self.vlan_pcp))
-        packed.append('\x00' * 1)
-        packed.append(struct.pack("!H", self.eth_type))
-        packed.append(struct.pack("!B", self.ip_dscp))
-        packed.append(struct.pack("!B", self.ip_proto))
-        packed.append(struct.pack("!L", self.ipv4_src))
-        packed.append(struct.pack("!L", self.ipv4_src_mask))
-        packed.append(struct.pack("!L", self.ipv4_dst))
-        packed.append(struct.pack("!L", self.ipv4_dst_mask))
-        packed.append(struct.pack("!H", self.tcp_src))
-        packed.append(struct.pack("!H", self.tcp_dst))
-        packed.append(struct.pack("!L", self.mpls_label))
-        packed.append(struct.pack("!B", self.mpls_tc))
-        packed.append('\x00' * 3)
-        packed.append(struct.pack("!Q", self.metadata))
-        packed.append(struct.pack("!Q", self.metadata_mask))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = match_v2()
-        _type = reader.read("!H")[0]
-        assert(_type == 0)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.in_port = util.unpack_port_no(reader)
-        obj.wildcards = util.unpack_wc_bmap(reader)
-        obj.eth_src = list(reader.read('!6B'))
-        obj.eth_src_mask = list(reader.read('!6B'))
-        obj.eth_dst = list(reader.read('!6B'))
-        obj.eth_dst_mask = list(reader.read('!6B'))
-        obj.vlan_vid = reader.read("!H")[0]
-        obj.vlan_pcp = reader.read("!B")[0]
-        reader.skip(1)
-        obj.eth_type = reader.read("!H")[0]
-        obj.ip_dscp = reader.read("!B")[0]
-        obj.ip_proto = reader.read("!B")[0]
-        obj.ipv4_src = reader.read("!L")[0]
-        obj.ipv4_src_mask = reader.read("!L")[0]
-        obj.ipv4_dst = reader.read("!L")[0]
-        obj.ipv4_dst_mask = reader.read("!L")[0]
-        obj.tcp_src = reader.read("!H")[0]
-        obj.tcp_dst = reader.read("!H")[0]
-        obj.mpls_label = reader.read("!L")[0]
-        obj.mpls_tc = reader.read("!B")[0]
-        reader.skip(3)
-        obj.metadata = reader.read("!Q")[0]
-        obj.metadata_mask = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.in_port != other.in_port: return False
-        if self.wildcards != other.wildcards: return False
-        if self.eth_src != other.eth_src: return False
-        if self.eth_src_mask != other.eth_src_mask: return False
-        if self.eth_dst != other.eth_dst: return False
-        if self.eth_dst_mask != other.eth_dst_mask: return False
-        if self.vlan_vid != other.vlan_vid: return False
-        if self.vlan_pcp != other.vlan_pcp: return False
-        if self.eth_type != other.eth_type: return False
-        if self.ip_dscp != other.ip_dscp: return False
-        if self.ip_proto != other.ip_proto: return False
-        if self.ipv4_src != other.ipv4_src: return False
-        if self.ipv4_src_mask != other.ipv4_src_mask: return False
-        if self.ipv4_dst != other.ipv4_dst: return False
-        if self.ipv4_dst_mask != other.ipv4_dst_mask: return False
-        if self.tcp_src != other.tcp_src: return False
-        if self.tcp_dst != other.tcp_dst: return False
-        if self.mpls_label != other.mpls_label: return False
-        if self.mpls_tc != other.mpls_tc: return False
-        if self.metadata != other.metadata: return False
-        if self.metadata_mask != other.metadata_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("match_v2 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("in_port = ");
-                q.text(util.pretty_port(self.in_port))
-                q.text(","); q.breakable()
-                q.text("wildcards = ");
-                q.text(util.pretty_wildcards(self.wildcards))
-                q.text(","); q.breakable()
-                q.text("eth_src = ");
-                q.text(util.pretty_mac(self.eth_src))
-                q.text(","); q.breakable()
-                q.text("eth_src_mask = ");
-                q.text(util.pretty_mac(self.eth_src_mask))
-                q.text(","); q.breakable()
-                q.text("eth_dst = ");
-                q.text(util.pretty_mac(self.eth_dst))
-                q.text(","); q.breakable()
-                q.text("eth_dst_mask = ");
-                q.text(util.pretty_mac(self.eth_dst_mask))
-                q.text(","); q.breakable()
-                q.text("vlan_vid = ");
-                q.text("%#x" % self.vlan_vid)
-                q.text(","); q.breakable()
-                q.text("vlan_pcp = ");
-                q.text("%#x" % self.vlan_pcp)
-                q.text(","); q.breakable()
-                q.text("eth_type = ");
-                q.text("%#x" % self.eth_type)
-                q.text(","); q.breakable()
-                q.text("ip_dscp = ");
-                q.text("%#x" % self.ip_dscp)
-                q.text(","); q.breakable()
-                q.text("ip_proto = ");
-                q.text("%#x" % self.ip_proto)
-                q.text(","); q.breakable()
-                q.text("ipv4_src = ");
-                q.text(util.pretty_ipv4(self.ipv4_src))
-                q.text(","); q.breakable()
-                q.text("ipv4_src_mask = ");
-                q.text(util.pretty_ipv4(self.ipv4_src_mask))
-                q.text(","); q.breakable()
-                q.text("ipv4_dst = ");
-                q.text(util.pretty_ipv4(self.ipv4_dst))
-                q.text(","); q.breakable()
-                q.text("ipv4_dst_mask = ");
-                q.text(util.pretty_ipv4(self.ipv4_dst_mask))
-                q.text(","); q.breakable()
-                q.text("tcp_src = ");
-                q.text("%#x" % self.tcp_src)
-                q.text(","); q.breakable()
-                q.text("tcp_dst = ");
-                q.text("%#x" % self.tcp_dst)
-                q.text(","); q.breakable()
-                q.text("mpls_label = ");
-                q.text("%#x" % self.mpls_label)
-                q.text(","); q.breakable()
-                q.text("mpls_tc = ");
-                q.text("%#x" % self.mpls_tc)
-                q.text(","); q.breakable()
-                q.text("metadata = ");
-                q.text("%#x" % self.metadata)
-                q.text(","); q.breakable()
-                q.text("metadata_mask = ");
-                q.text("%#x" % self.metadata_mask)
-            q.breakable()
-        q.text('}')
-
-
-class packet_queue(loxi.OFObject):
-
-    def __init__(self, queue_id=None, properties=None):
-        if queue_id != None:
-            self.queue_id = queue_id
-        else:
-            self.queue_id = 0
-        if properties != None:
-            self.properties = properties
-        else:
-            self.properties = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.queue_id))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 2)
-        packed.append(loxi.generic_util.pack_list(self.properties))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = packet_queue()
-        obj.queue_id = reader.read("!L")[0]
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 6)
-        reader.skip(2)
-        obj.properties = loxi.generic_util.unpack_list(reader, ofp.common.queue_prop.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.queue_id != other.queue_id: return False
-        if self.properties != other.properties: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("packet_queue {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("queue_id = ");
-                q.text("%#x" % self.queue_id)
-                q.text(","); q.breakable()
-                q.text("properties = ");
-                q.pp(self.properties)
-            q.breakable()
-        q.text('}')
-
-
-class port_desc(loxi.OFObject):
-
-    def __init__(self, port_no=None, hw_addr=None, name=None, config=None, state=None, curr=None, advertised=None, supported=None, peer=None, curr_speed=None, max_speed=None):
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if hw_addr != None:
-            self.hw_addr = hw_addr
-        else:
-            self.hw_addr = [0,0,0,0,0,0]
-        if name != None:
-            self.name = name
-        else:
-            self.name = ""
-        if config != None:
-            self.config = config
-        else:
-            self.config = 0
-        if state != None:
-            self.state = state
-        else:
-            self.state = 0
-        if curr != None:
-            self.curr = curr
-        else:
-            self.curr = 0
-        if advertised != None:
-            self.advertised = advertised
-        else:
-            self.advertised = 0
-        if supported != None:
-            self.supported = supported
-        else:
-            self.supported = 0
-        if peer != None:
-            self.peer = peer
-        else:
-            self.peer = 0
-        if curr_speed != None:
-            self.curr_speed = curr_speed
-        else:
-            self.curr_speed = 0
-        if max_speed != None:
-            self.max_speed = max_speed
-        else:
-            self.max_speed = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!6B", *self.hw_addr))
-        packed.append('\x00' * 2)
-        packed.append(struct.pack("!16s", self.name))
-        packed.append(struct.pack("!L", self.config))
-        packed.append(struct.pack("!L", self.state))
-        packed.append(struct.pack("!L", self.curr))
-        packed.append(struct.pack("!L", self.advertised))
-        packed.append(struct.pack("!L", self.supported))
-        packed.append(struct.pack("!L", self.peer))
-        packed.append(struct.pack("!L", self.curr_speed))
-        packed.append(struct.pack("!L", self.max_speed))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = port_desc()
-        obj.port_no = util.unpack_port_no(reader)
-        reader.skip(4)
-        obj.hw_addr = list(reader.read('!6B'))
-        reader.skip(2)
-        obj.name = reader.read("!16s")[0].rstrip("\x00")
-        obj.config = reader.read("!L")[0]
-        obj.state = reader.read("!L")[0]
-        obj.curr = reader.read("!L")[0]
-        obj.advertised = reader.read("!L")[0]
-        obj.supported = reader.read("!L")[0]
-        obj.peer = reader.read("!L")[0]
-        obj.curr_speed = reader.read("!L")[0]
-        obj.max_speed = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.port_no != other.port_no: return False
-        if self.hw_addr != other.hw_addr: return False
-        if self.name != other.name: return False
-        if self.config != other.config: return False
-        if self.state != other.state: return False
-        if self.curr != other.curr: return False
-        if self.advertised != other.advertised: return False
-        if self.supported != other.supported: return False
-        if self.peer != other.peer: return False
-        if self.curr_speed != other.curr_speed: return False
-        if self.max_speed != other.max_speed: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port_desc {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("hw_addr = ");
-                q.text(util.pretty_mac(self.hw_addr))
-                q.text(","); q.breakable()
-                q.text("name = ");
-                q.pp(self.name)
-                q.text(","); q.breakable()
-                q.text("config = ");
-                q.text("%#x" % self.config)
-                q.text(","); q.breakable()
-                q.text("state = ");
-                q.text("%#x" % self.state)
-                q.text(","); q.breakable()
-                q.text("curr = ");
-                q.text("%#x" % self.curr)
-                q.text(","); q.breakable()
-                q.text("advertised = ");
-                q.text("%#x" % self.advertised)
-                q.text(","); q.breakable()
-                q.text("supported = ");
-                q.text("%#x" % self.supported)
-                q.text(","); q.breakable()
-                q.text("peer = ");
-                q.text("%#x" % self.peer)
-                q.text(","); q.breakable()
-                q.text("curr_speed = ");
-                q.text("%#x" % self.curr_speed)
-                q.text(","); q.breakable()
-                q.text("max_speed = ");
-                q.text("%#x" % self.max_speed)
-            q.breakable()
-        q.text('}')
-
-
-class port_stats_entry(loxi.OFObject):
-
-    def __init__(self, port_no=None, rx_packets=None, tx_packets=None, rx_bytes=None, tx_bytes=None, rx_dropped=None, tx_dropped=None, rx_errors=None, tx_errors=None, rx_frame_err=None, rx_over_err=None, rx_crc_err=None, collisions=None):
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if rx_packets != None:
-            self.rx_packets = rx_packets
-        else:
-            self.rx_packets = 0
-        if tx_packets != None:
-            self.tx_packets = tx_packets
-        else:
-            self.tx_packets = 0
-        if rx_bytes != None:
-            self.rx_bytes = rx_bytes
-        else:
-            self.rx_bytes = 0
-        if tx_bytes != None:
-            self.tx_bytes = tx_bytes
-        else:
-            self.tx_bytes = 0
-        if rx_dropped != None:
-            self.rx_dropped = rx_dropped
-        else:
-            self.rx_dropped = 0
-        if tx_dropped != None:
-            self.tx_dropped = tx_dropped
-        else:
-            self.tx_dropped = 0
-        if rx_errors != None:
-            self.rx_errors = rx_errors
-        else:
-            self.rx_errors = 0
-        if tx_errors != None:
-            self.tx_errors = tx_errors
-        else:
-            self.tx_errors = 0
-        if rx_frame_err != None:
-            self.rx_frame_err = rx_frame_err
-        else:
-            self.rx_frame_err = 0
-        if rx_over_err != None:
-            self.rx_over_err = rx_over_err
-        else:
-            self.rx_over_err = 0
-        if rx_crc_err != None:
-            self.rx_crc_err = rx_crc_err
-        else:
-            self.rx_crc_err = 0
-        if collisions != None:
-            self.collisions = collisions
-        else:
-            self.collisions = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!Q", self.rx_packets))
-        packed.append(struct.pack("!Q", self.tx_packets))
-        packed.append(struct.pack("!Q", self.rx_bytes))
-        packed.append(struct.pack("!Q", self.tx_bytes))
-        packed.append(struct.pack("!Q", self.rx_dropped))
-        packed.append(struct.pack("!Q", self.tx_dropped))
-        packed.append(struct.pack("!Q", self.rx_errors))
-        packed.append(struct.pack("!Q", self.tx_errors))
-        packed.append(struct.pack("!Q", self.rx_frame_err))
-        packed.append(struct.pack("!Q", self.rx_over_err))
-        packed.append(struct.pack("!Q", self.rx_crc_err))
-        packed.append(struct.pack("!Q", self.collisions))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = port_stats_entry()
-        obj.port_no = util.unpack_port_no(reader)
-        reader.skip(4)
-        obj.rx_packets = reader.read("!Q")[0]
-        obj.tx_packets = reader.read("!Q")[0]
-        obj.rx_bytes = reader.read("!Q")[0]
-        obj.tx_bytes = reader.read("!Q")[0]
-        obj.rx_dropped = reader.read("!Q")[0]
-        obj.tx_dropped = reader.read("!Q")[0]
-        obj.rx_errors = reader.read("!Q")[0]
-        obj.tx_errors = reader.read("!Q")[0]
-        obj.rx_frame_err = reader.read("!Q")[0]
-        obj.rx_over_err = reader.read("!Q")[0]
-        obj.rx_crc_err = reader.read("!Q")[0]
-        obj.collisions = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.port_no != other.port_no: return False
-        if self.rx_packets != other.rx_packets: return False
-        if self.tx_packets != other.tx_packets: return False
-        if self.rx_bytes != other.rx_bytes: return False
-        if self.tx_bytes != other.tx_bytes: return False
-        if self.rx_dropped != other.rx_dropped: return False
-        if self.tx_dropped != other.tx_dropped: return False
-        if self.rx_errors != other.rx_errors: return False
-        if self.tx_errors != other.tx_errors: return False
-        if self.rx_frame_err != other.rx_frame_err: return False
-        if self.rx_over_err != other.rx_over_err: return False
-        if self.rx_crc_err != other.rx_crc_err: return False
-        if self.collisions != other.collisions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("rx_packets = ");
-                q.text("%#x" % self.rx_packets)
-                q.text(","); q.breakable()
-                q.text("tx_packets = ");
-                q.text("%#x" % self.tx_packets)
-                q.text(","); q.breakable()
-                q.text("rx_bytes = ");
-                q.text("%#x" % self.rx_bytes)
-                q.text(","); q.breakable()
-                q.text("tx_bytes = ");
-                q.text("%#x" % self.tx_bytes)
-                q.text(","); q.breakable()
-                q.text("rx_dropped = ");
-                q.text("%#x" % self.rx_dropped)
-                q.text(","); q.breakable()
-                q.text("tx_dropped = ");
-                q.text("%#x" % self.tx_dropped)
-                q.text(","); q.breakable()
-                q.text("rx_errors = ");
-                q.text("%#x" % self.rx_errors)
-                q.text(","); q.breakable()
-                q.text("tx_errors = ");
-                q.text("%#x" % self.tx_errors)
-                q.text(","); q.breakable()
-                q.text("rx_frame_err = ");
-                q.text("%#x" % self.rx_frame_err)
-                q.text(","); q.breakable()
-                q.text("rx_over_err = ");
-                q.text("%#x" % self.rx_over_err)
-                q.text(","); q.breakable()
-                q.text("rx_crc_err = ");
-                q.text("%#x" % self.rx_crc_err)
-                q.text(","); q.breakable()
-                q.text("collisions = ");
-                q.text("%#x" % self.collisions)
-            q.breakable()
-        q.text('}')
-
-
-class queue_prop(loxi.OFObject):
-    subtypes = {}
-
-
-    def __init__(self, type=None):
-        if type != None:
-            self.type = type
-        else:
-            self.type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 0)
-        subclass = queue_prop.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = queue_prop()
-        obj.type = reader.read("!H")[0]
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type != other.type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_prop {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-
-class queue_prop_min_rate(queue_prop):
-    type = 1
-
-    def __init__(self, rate=None):
-        if rate != None:
-            self.rate = rate
-        else:
-            self.rate = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!H", self.rate))
-        packed.append('\x00' * 6)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = queue_prop_min_rate()
-        _type = reader.read("!H")[0]
-        assert(_type == 1)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        obj.rate = reader.read("!H")[0]
-        reader.skip(6)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.rate != other.rate: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_prop_min_rate {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("rate = ");
-                q.text("%#x" % self.rate)
-            q.breakable()
-        q.text('}')
-
-queue_prop.subtypes[1] = queue_prop_min_rate
-
-class queue_stats_entry(loxi.OFObject):
-
-    def __init__(self, port_no=None, queue_id=None, tx_bytes=None, tx_packets=None, tx_errors=None):
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if queue_id != None:
-            self.queue_id = queue_id
-        else:
-            self.queue_id = 0
-        if tx_bytes != None:
-            self.tx_bytes = tx_bytes
-        else:
-            self.tx_bytes = 0
-        if tx_packets != None:
-            self.tx_packets = tx_packets
-        else:
-            self.tx_packets = 0
-        if tx_errors != None:
-            self.tx_errors = tx_errors
-        else:
-            self.tx_errors = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(struct.pack("!L", self.queue_id))
-        packed.append(struct.pack("!Q", self.tx_bytes))
-        packed.append(struct.pack("!Q", self.tx_packets))
-        packed.append(struct.pack("!Q", self.tx_errors))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = queue_stats_entry()
-        obj.port_no = util.unpack_port_no(reader)
-        obj.queue_id = reader.read("!L")[0]
-        obj.tx_bytes = reader.read("!Q")[0]
-        obj.tx_packets = reader.read("!Q")[0]
-        obj.tx_errors = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.port_no != other.port_no: return False
-        if self.queue_id != other.queue_id: return False
-        if self.tx_bytes != other.tx_bytes: return False
-        if self.tx_packets != other.tx_packets: return False
-        if self.tx_errors != other.tx_errors: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("queue_id = ");
-                q.text("%#x" % self.queue_id)
-                q.text(","); q.breakable()
-                q.text("tx_bytes = ");
-                q.text("%#x" % self.tx_bytes)
-                q.text(","); q.breakable()
-                q.text("tx_packets = ");
-                q.text("%#x" % self.tx_packets)
-                q.text(","); q.breakable()
-                q.text("tx_errors = ");
-                q.text("%#x" % self.tx_errors)
-            q.breakable()
-        q.text('}')
-
-
-class table_stats_entry(loxi.OFObject):
-
-    def __init__(self, table_id=None, name=None, wildcards=None, match=None, instructions=None, write_actions=None, apply_actions=None, config=None, max_entries=None, active_count=None, lookup_count=None, matched_count=None):
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if name != None:
-            self.name = name
-        else:
-            self.name = ""
-        if wildcards != None:
-            self.wildcards = wildcards
-        else:
-            self.wildcards = util.init_wc_bmap()
-        if match != None:
-            self.match = match
-        else:
-            self.match = util.init_match_bmap()
-        if instructions != None:
-            self.instructions = instructions
-        else:
-            self.instructions = 0
-        if write_actions != None:
-            self.write_actions = write_actions
-        else:
-            self.write_actions = 0
-        if apply_actions != None:
-            self.apply_actions = apply_actions
-        else:
-            self.apply_actions = 0
-        if config != None:
-            self.config = config
-        else:
-            self.config = 0
-        if max_entries != None:
-            self.max_entries = max_entries
-        else:
-            self.max_entries = 0
-        if active_count != None:
-            self.active_count = active_count
-        else:
-            self.active_count = 0
-        if lookup_count != None:
-            self.lookup_count = lookup_count
-        else:
-            self.lookup_count = 0
-        if matched_count != None:
-            self.matched_count = matched_count
-        else:
-            self.matched_count = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append('\x00' * 7)
-        packed.append(struct.pack("!32s", self.name))
-        packed.append(util.pack_wc_bmap(self.wildcards))
-        packed.append(util.pack_match_bmap(self.match))
-        packed.append(struct.pack("!L", self.instructions))
-        packed.append(struct.pack("!L", self.write_actions))
-        packed.append(struct.pack("!L", self.apply_actions))
-        packed.append(struct.pack("!L", self.config))
-        packed.append(struct.pack("!L", self.max_entries))
-        packed.append(struct.pack("!L", self.active_count))
-        packed.append(struct.pack("!Q", self.lookup_count))
-        packed.append(struct.pack("!Q", self.matched_count))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_stats_entry()
-        obj.table_id = reader.read("!B")[0]
-        reader.skip(7)
-        obj.name = reader.read("!32s")[0].rstrip("\x00")
-        obj.wildcards = util.unpack_wc_bmap(reader)
-        obj.match = util.unpack_match_bmap(reader)
-        obj.instructions = reader.read("!L")[0]
-        obj.write_actions = reader.read("!L")[0]
-        obj.apply_actions = reader.read("!L")[0]
-        obj.config = reader.read("!L")[0]
-        obj.max_entries = reader.read("!L")[0]
-        obj.active_count = reader.read("!L")[0]
-        obj.lookup_count = reader.read("!Q")[0]
-        obj.matched_count = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.table_id != other.table_id: return False
-        if self.name != other.name: return False
-        if self.wildcards != other.wildcards: return False
-        if self.match != other.match: return False
-        if self.instructions != other.instructions: return False
-        if self.write_actions != other.write_actions: return False
-        if self.apply_actions != other.apply_actions: return False
-        if self.config != other.config: return False
-        if self.max_entries != other.max_entries: return False
-        if self.active_count != other.active_count: return False
-        if self.lookup_count != other.lookup_count: return False
-        if self.matched_count != other.matched_count: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("name = ");
-                q.pp(self.name)
-                q.text(","); q.breakable()
-                q.text("wildcards = ");
-                q.text(util.pretty_wildcards(self.wildcards))
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-                q.text(","); q.breakable()
-                q.text("instructions = ");
-                q.text("%#x" % self.instructions)
-                q.text(","); q.breakable()
-                q.text("write_actions = ");
-                q.text("%#x" % self.write_actions)
-                q.text(","); q.breakable()
-                q.text("apply_actions = ");
-                q.text("%#x" % self.apply_actions)
-                q.text(","); q.breakable()
-                q.text("config = ");
-                q.text("%#x" % self.config)
-                q.text(","); q.breakable()
-                q.text("max_entries = ");
-                q.text("%#x" % self.max_entries)
-                q.text(","); q.breakable()
-                q.text("active_count = ");
-                q.text("%#x" % self.active_count)
-                q.text(","); q.breakable()
-                q.text("lookup_count = ");
-                q.text("%#x" % self.lookup_count)
-                q.text(","); q.breakable()
-                q.text("matched_count = ");
-                q.text("%#x" % self.matched_count)
-            q.breakable()
-        q.text('}')
-
-
-
-match = match_v2
diff --git a/python/ofagent/loxi/of11/const.py b/python/ofagent/loxi/of11/const.py
deleted file mode 100644
index 9705d89..0000000
--- a/python/ofagent/loxi/of11/const.py
+++ /dev/null
@@ -1,733 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template const.py
-# Do not modify
-
-OFP_VERSION = 2
-
-# Identifiers from group macro_definitions
-OFP_MAX_TABLE_NAME_LEN = 32
-OFP_MAX_PORT_NAME_LEN = 16
-OFP_TCP_PORT = 6653
-OFP_SSL_PORT = 6653
-OFP_ETH_ALEN = 6
-OFP_DEFAULT_MISS_SEND_LEN = 128
-OFPFW_ICMP_TYPE = 64
-OFPFW_ICMP_CODE = 128
-OFP_DL_TYPE_ETH2_CUTOFF = 1536
-OFP_DL_TYPE_NOT_ETH_TYPE = 1535
-OFP_VLAN_NONE = 0
-OFPMT_STANDARD_LENGTH = 88
-OFP_FLOW_PERMANENT = 0
-OFP_DEFAULT_PRIORITY = 32768
-DESC_STR_LEN = 256
-SERIAL_NUM_LEN = 32
-OFPQ_ALL = 4294967295
-OFPQ_MIN_RATE_UNCFG = 65535
-
-# Identifiers from group of_bsn_pdu_slot_num
-BSN_PDU_SLOT_NUM_ANY = 255
-
-of_bsn_pdu_slot_num_map = {
-    255: 'BSN_PDU_SLOT_NUM_ANY',
-}
-
-# Identifiers from group ofp_action_type
-OFPAT_OUTPUT = 0
-OFPAT_SET_VLAN_VID = 1
-OFPAT_SET_VLAN_PCP = 2
-OFPAT_SET_DL_SRC = 3
-OFPAT_SET_DL_DST = 4
-OFPAT_SET_NW_SRC = 5
-OFPAT_SET_NW_DST = 6
-OFPAT_SET_NW_TOS = 7
-OFPAT_SET_NW_ECN = 8
-OFPAT_SET_TP_SRC = 9
-OFPAT_SET_TP_DST = 10
-OFPAT_COPY_TTL_OUT = 11
-OFPAT_COPY_TTL_IN = 12
-OFPAT_SET_MPLS_LABEL = 13
-OFPAT_SET_MPLS_TC = 14
-OFPAT_SET_MPLS_TTL = 15
-OFPAT_DEC_MPLS_TTL = 16
-OFPAT_PUSH_VLAN = 17
-OFPAT_POP_VLAN = 18
-OFPAT_PUSH_MPLS = 19
-OFPAT_POP_MPLS = 20
-OFPAT_SET_QUEUE = 21
-OFPAT_GROUP = 22
-OFPAT_SET_NW_TTL = 23
-OFPAT_DEC_NW_TTL = 24
-OFPAT_EXPERIMENTER = 65535
-
-ofp_action_type_map = {
-    0: 'OFPAT_OUTPUT',
-    1: 'OFPAT_SET_VLAN_VID',
-    2: 'OFPAT_SET_VLAN_PCP',
-    3: 'OFPAT_SET_DL_SRC',
-    4: 'OFPAT_SET_DL_DST',
-    5: 'OFPAT_SET_NW_SRC',
-    6: 'OFPAT_SET_NW_DST',
-    7: 'OFPAT_SET_NW_TOS',
-    8: 'OFPAT_SET_NW_ECN',
-    9: 'OFPAT_SET_TP_SRC',
-    10: 'OFPAT_SET_TP_DST',
-    11: 'OFPAT_COPY_TTL_OUT',
-    12: 'OFPAT_COPY_TTL_IN',
-    13: 'OFPAT_SET_MPLS_LABEL',
-    14: 'OFPAT_SET_MPLS_TC',
-    15: 'OFPAT_SET_MPLS_TTL',
-    16: 'OFPAT_DEC_MPLS_TTL',
-    17: 'OFPAT_PUSH_VLAN',
-    18: 'OFPAT_POP_VLAN',
-    19: 'OFPAT_PUSH_MPLS',
-    20: 'OFPAT_POP_MPLS',
-    21: 'OFPAT_SET_QUEUE',
-    22: 'OFPAT_GROUP',
-    23: 'OFPAT_SET_NW_TTL',
-    24: 'OFPAT_DEC_NW_TTL',
-    65535: 'OFPAT_EXPERIMENTER',
-}
-
-# Identifiers from group ofp_bad_action_code
-OFPBAC_BAD_TYPE = 0
-OFPBAC_BAD_LEN = 1
-OFPBAC_BAD_EXPERIMENTER = 2
-OFPBAC_BAD_EXPERIMENTER_TYPE = 3
-OFPBAC_BAD_OUT_PORT = 4
-OFPBAC_BAD_ARGUMENT = 5
-OFPBAC_EPERM = 6
-OFPBAC_TOO_MANY = 7
-OFPBAC_BAD_QUEUE = 8
-OFPBAC_BAD_OUT_GROUP = 9
-OFPBAC_MATCH_INCONSISTENT = 10
-OFPBAC_UNSUPPORTED_ORDER = 11
-OFPBAC_BAD_TAG = 12
-
-ofp_bad_action_code_map = {
-    0: 'OFPBAC_BAD_TYPE',
-    1: 'OFPBAC_BAD_LEN',
-    2: 'OFPBAC_BAD_EXPERIMENTER',
-    3: 'OFPBAC_BAD_EXPERIMENTER_TYPE',
-    4: 'OFPBAC_BAD_OUT_PORT',
-    5: 'OFPBAC_BAD_ARGUMENT',
-    6: 'OFPBAC_EPERM',
-    7: 'OFPBAC_TOO_MANY',
-    8: 'OFPBAC_BAD_QUEUE',
-    9: 'OFPBAC_BAD_OUT_GROUP',
-    10: 'OFPBAC_MATCH_INCONSISTENT',
-    11: 'OFPBAC_UNSUPPORTED_ORDER',
-    12: 'OFPBAC_BAD_TAG',
-}
-
-# Identifiers from group ofp_bad_instruction_code
-OFPBIC_UNKNOWN_INST = 0
-OFPBIC_UNSUP_INST = 1
-OFPBIC_BAD_TABLE_ID = 2
-OFPBIC_UNSUP_METADATA = 3
-OFPBIC_UNSUP_METADATA_MASK = 4
-OFPBIC_UNSUP_EXP_INST = 5
-
-ofp_bad_instruction_code_map = {
-    0: 'OFPBIC_UNKNOWN_INST',
-    1: 'OFPBIC_UNSUP_INST',
-    2: 'OFPBIC_BAD_TABLE_ID',
-    3: 'OFPBIC_UNSUP_METADATA',
-    4: 'OFPBIC_UNSUP_METADATA_MASK',
-    5: 'OFPBIC_UNSUP_EXP_INST',
-}
-
-# Identifiers from group ofp_bad_match_code
-OFPBMC_BAD_TYPE = 0
-OFPBMC_BAD_LEN = 1
-OFPBMC_BAD_TAG = 2
-OFPBMC_BAD_DL_ADDR_MASK = 3
-OFPBMC_BAD_NW_ADDR_MASK = 4
-OFPBMC_BAD_WILDCARDS = 5
-OFPBMC_BAD_FIELD = 6
-OFPBMC_BAD_VALUE = 7
-
-ofp_bad_match_code_map = {
-    0: 'OFPBMC_BAD_TYPE',
-    1: 'OFPBMC_BAD_LEN',
-    2: 'OFPBMC_BAD_TAG',
-    3: 'OFPBMC_BAD_DL_ADDR_MASK',
-    4: 'OFPBMC_BAD_NW_ADDR_MASK',
-    5: 'OFPBMC_BAD_WILDCARDS',
-    6: 'OFPBMC_BAD_FIELD',
-    7: 'OFPBMC_BAD_VALUE',
-}
-
-# Identifiers from group ofp_bad_request_code
-OFPBRC_BAD_VERSION = 0
-OFPBRC_BAD_TYPE = 1
-OFPBRC_BAD_STAT = 2
-OFPBRC_BAD_EXPERIMENTER = 3
-OFPBRC_BAD_SUBTYPE = 4
-OFPBRC_EPERM = 5
-OFPBRC_BAD_LEN = 6
-OFPBRC_BUFFER_EMPTY = 7
-OFPBRC_BUFFER_UNKNOWN = 8
-OFPBRC_BAD_TABLE_ID = 9
-
-ofp_bad_request_code_map = {
-    0: 'OFPBRC_BAD_VERSION',
-    1: 'OFPBRC_BAD_TYPE',
-    2: 'OFPBRC_BAD_STAT',
-    3: 'OFPBRC_BAD_EXPERIMENTER',
-    4: 'OFPBRC_BAD_SUBTYPE',
-    5: 'OFPBRC_EPERM',
-    6: 'OFPBRC_BAD_LEN',
-    7: 'OFPBRC_BUFFER_EMPTY',
-    8: 'OFPBRC_BUFFER_UNKNOWN',
-    9: 'OFPBRC_BAD_TABLE_ID',
-}
-
-# Identifiers from group ofp_bsn_vport_l2gre_flags
-OF_BSN_VPORT_L2GRE_LOCAL_MAC_IS_VALID = 1
-OF_BSN_VPORT_L2GRE_DSCP_ASSIGN = 2
-OF_BSN_VPORT_L2GRE_DSCP_COPY = 4
-OF_BSN_VPORT_L2GRE_LOOPBACK_IS_VALID = 8
-OF_BSN_VPORT_L2GRE_RATE_LIMIT_IS_VALID = 16
-
-ofp_bsn_vport_l2gre_flags_map = {
-    1: 'OF_BSN_VPORT_L2GRE_LOCAL_MAC_IS_VALID',
-    2: 'OF_BSN_VPORT_L2GRE_DSCP_ASSIGN',
-    4: 'OF_BSN_VPORT_L2GRE_DSCP_COPY',
-    8: 'OF_BSN_VPORT_L2GRE_LOOPBACK_IS_VALID',
-    16: 'OF_BSN_VPORT_L2GRE_RATE_LIMIT_IS_VALID',
-}
-
-# Identifiers from group ofp_bsn_vport_q_in_q_untagged
-OF_BSN_VPORT_Q_IN_Q_UNTAGGED = 65535
-
-ofp_bsn_vport_q_in_q_untagged_map = {
-    65535: 'OF_BSN_VPORT_Q_IN_Q_UNTAGGED',
-}
-
-# Identifiers from group ofp_bsn_vport_status
-OF_BSN_VPORT_STATUS_OK = 0
-OF_BSN_VPORT_STATUS_FAILED = 1
-
-ofp_bsn_vport_status_map = {
-    0: 'OF_BSN_VPORT_STATUS_OK',
-    1: 'OF_BSN_VPORT_STATUS_FAILED',
-}
-
-# Identifiers from group ofp_capabilities
-OFPC_FLOW_STATS = 1
-OFPC_TABLE_STATS = 2
-OFPC_PORT_STATS = 4
-OFPC_GROUP_STATS = 8
-OFPC_IP_REASM = 32
-OFPC_QUEUE_STATS = 64
-OFPC_ARP_MATCH_IP = 128
-
-ofp_capabilities_map = {
-    1: 'OFPC_FLOW_STATS',
-    2: 'OFPC_TABLE_STATS',
-    4: 'OFPC_PORT_STATS',
-    8: 'OFPC_GROUP_STATS',
-    32: 'OFPC_IP_REASM',
-    64: 'OFPC_QUEUE_STATS',
-    128: 'OFPC_ARP_MATCH_IP',
-}
-
-# Identifiers from group ofp_config_flags
-OFPC_FRAG_NORMAL = 0
-OFPC_FRAG_DROP = 1
-OFPC_FRAG_REASM = 2
-OFPC_FRAG_MASK = 3
-OFPC_INVALID_TTL_TO_CONTROLLER = 4
-
-ofp_config_flags_map = {
-    0: 'OFPC_FRAG_NORMAL',
-    1: 'OFPC_FRAG_DROP',
-    2: 'OFPC_FRAG_REASM',
-    3: 'OFPC_FRAG_MASK',
-    4: 'OFPC_INVALID_TTL_TO_CONTROLLER',
-}
-
-# Identifiers from group ofp_error_type
-OFPET_HELLO_FAILED = 0
-OFPET_BAD_REQUEST = 1
-OFPET_BAD_ACTION = 2
-OFPET_BAD_INSTRUCTION = 3
-OFPET_BAD_MATCH = 4
-OFPET_FLOW_MOD_FAILED = 5
-OFPET_GROUP_MOD_FAILED = 6
-OFPET_PORT_MOD_FAILED = 7
-OFPET_TABLE_MOD_FAILED = 8
-OFPET_QUEUE_OP_FAILED = 9
-OFPET_SWITCH_CONFIG_FAILED = 10
-
-ofp_error_type_map = {
-    0: 'OFPET_HELLO_FAILED',
-    1: 'OFPET_BAD_REQUEST',
-    2: 'OFPET_BAD_ACTION',
-    3: 'OFPET_BAD_INSTRUCTION',
-    4: 'OFPET_BAD_MATCH',
-    5: 'OFPET_FLOW_MOD_FAILED',
-    6: 'OFPET_GROUP_MOD_FAILED',
-    7: 'OFPET_PORT_MOD_FAILED',
-    8: 'OFPET_TABLE_MOD_FAILED',
-    9: 'OFPET_QUEUE_OP_FAILED',
-    10: 'OFPET_SWITCH_CONFIG_FAILED',
-}
-
-# Identifiers from group ofp_flow_mod_command
-OFPFC_ADD = 0
-OFPFC_MODIFY = 1
-OFPFC_MODIFY_STRICT = 2
-OFPFC_DELETE = 3
-OFPFC_DELETE_STRICT = 4
-
-ofp_flow_mod_command_map = {
-    0: 'OFPFC_ADD',
-    1: 'OFPFC_MODIFY',
-    2: 'OFPFC_MODIFY_STRICT',
-    3: 'OFPFC_DELETE',
-    4: 'OFPFC_DELETE_STRICT',
-}
-
-# Identifiers from group ofp_flow_mod_failed_code
-OFPFMFC_UNKNOWN = 0
-OFPFMFC_TABLE_FULL = 1
-OFPFMFC_BAD_TABLE_ID = 2
-OFPFMFC_OVERLAP = 3
-OFPFMFC_EPERM = 4
-OFPFMFC_BAD_TIMEOUT = 5
-OFPFMFC_BAD_COMMAND = 6
-
-ofp_flow_mod_failed_code_map = {
-    0: 'OFPFMFC_UNKNOWN',
-    1: 'OFPFMFC_TABLE_FULL',
-    2: 'OFPFMFC_BAD_TABLE_ID',
-    3: 'OFPFMFC_OVERLAP',
-    4: 'OFPFMFC_EPERM',
-    5: 'OFPFMFC_BAD_TIMEOUT',
-    6: 'OFPFMFC_BAD_COMMAND',
-}
-
-# Identifiers from group ofp_flow_mod_flags
-OFPFF_SEND_FLOW_REM = 1
-OFPFF_CHECK_OVERLAP = 2
-
-ofp_flow_mod_flags_map = {
-    1: 'OFPFF_SEND_FLOW_REM',
-    2: 'OFPFF_CHECK_OVERLAP',
-}
-
-# Identifiers from group ofp_flow_removed_reason
-OFPRR_IDLE_TIMEOUT = 0
-OFPRR_HARD_TIMEOUT = 1
-OFPRR_DELETE = 2
-OFPRR_GROUP_DELETE = 3
-
-ofp_flow_removed_reason_map = {
-    0: 'OFPRR_IDLE_TIMEOUT',
-    1: 'OFPRR_HARD_TIMEOUT',
-    2: 'OFPRR_DELETE',
-    3: 'OFPRR_GROUP_DELETE',
-}
-
-# Identifiers from group ofp_flow_wildcards
-OFPFW_IN_PORT = 1
-OFPFW_DL_VLAN = 2
-OFPFW_DL_VLAN_PCP = 4
-OFPFW_DL_TYPE = 8
-OFPFW_NW_TOS = 16
-OFPFW_NW_PROTO = 32
-OFPFW_TP_SRC = 64
-OFPFW_TP_DST = 128
-OFPFW_MPLS_LABEL = 256
-OFPFW_MPLS_TC = 512
-OFPFW_ALL = 1023
-
-ofp_flow_wildcards_map = {
-    1: 'OFPFW_IN_PORT',
-    2: 'OFPFW_DL_VLAN',
-    4: 'OFPFW_DL_VLAN_PCP',
-    8: 'OFPFW_DL_TYPE',
-    16: 'OFPFW_NW_TOS',
-    32: 'OFPFW_NW_PROTO',
-    64: 'OFPFW_TP_SRC',
-    128: 'OFPFW_TP_DST',
-    256: 'OFPFW_MPLS_LABEL',
-    512: 'OFPFW_MPLS_TC',
-}
-
-# Identifiers from group ofp_group
-OFPG_MAX = 4294967040
-OFPG_ALL = 4294967292
-OFPG_ANY = 4294967295
-
-ofp_group_map = {
-    4294967040: 'OFPG_MAX',
-    4294967292: 'OFPG_ALL',
-    4294967295: 'OFPG_ANY',
-}
-
-# Identifiers from group ofp_group_mod_command
-OFPGC_ADD = 0
-OFPGC_MODIFY = 1
-OFPGC_DELETE = 2
-
-ofp_group_mod_command_map = {
-    0: 'OFPGC_ADD',
-    1: 'OFPGC_MODIFY',
-    2: 'OFPGC_DELETE',
-}
-
-# Identifiers from group ofp_group_mod_failed_code
-OFPGMFC_GROUP_EXISTS = 0
-OFPGMFC_INVALID_GROUP = 1
-OFPGMFC_WEIGHT_UNSUPPORTED = 2
-OFPGMFC_OUT_OF_GROUPS = 3
-OFPGMFC_OUT_OF_BUCKETS = 4
-OFPGMFC_CHAINING_UNSUPPORTED = 5
-OFPGMFC_WATCH_UNSUPPORTED = 6
-OFPGMFC_LOOP = 7
-OFPGMFC_UNKNOWN_GROUP = 8
-
-ofp_group_mod_failed_code_map = {
-    0: 'OFPGMFC_GROUP_EXISTS',
-    1: 'OFPGMFC_INVALID_GROUP',
-    2: 'OFPGMFC_WEIGHT_UNSUPPORTED',
-    3: 'OFPGMFC_OUT_OF_GROUPS',
-    4: 'OFPGMFC_OUT_OF_BUCKETS',
-    5: 'OFPGMFC_CHAINING_UNSUPPORTED',
-    6: 'OFPGMFC_WATCH_UNSUPPORTED',
-    7: 'OFPGMFC_LOOP',
-    8: 'OFPGMFC_UNKNOWN_GROUP',
-}
-
-# Identifiers from group ofp_group_type
-OFPGT_ALL = 0
-OFPGT_SELECT = 1
-OFPGT_INDIRECT = 2
-OFPGT_FF = 3
-
-ofp_group_type_map = {
-    0: 'OFPGT_ALL',
-    1: 'OFPGT_SELECT',
-    2: 'OFPGT_INDIRECT',
-    3: 'OFPGT_FF',
-}
-
-# Identifiers from group ofp_hello_failed_code
-OFPHFC_INCOMPATIBLE = 0
-OFPHFC_EPERM = 1
-
-ofp_hello_failed_code_map = {
-    0: 'OFPHFC_INCOMPATIBLE',
-    1: 'OFPHFC_EPERM',
-}
-
-# Identifiers from group ofp_instruction_type
-OFPIT_GOTO_TABLE = 1
-OFPIT_WRITE_METADATA = 2
-OFPIT_WRITE_ACTIONS = 3
-OFPIT_APPLY_ACTIONS = 4
-OFPIT_CLEAR_ACTIONS = 5
-OFPIT_EXPERIMENTER = 65535
-
-ofp_instruction_type_map = {
-    1: 'OFPIT_GOTO_TABLE',
-    2: 'OFPIT_WRITE_METADATA',
-    3: 'OFPIT_WRITE_ACTIONS',
-    4: 'OFPIT_APPLY_ACTIONS',
-    5: 'OFPIT_CLEAR_ACTIONS',
-    65535: 'OFPIT_EXPERIMENTER',
-}
-
-# Identifiers from group ofp_match_type
-OFPMT_STANDARD = 0
-
-ofp_match_type_map = {
-    0: 'OFPMT_STANDARD',
-}
-
-# Identifiers from group ofp_packet_in_reason
-OFPR_NO_MATCH = 0
-OFPR_ACTION = 1
-
-ofp_packet_in_reason_map = {
-    0: 'OFPR_NO_MATCH',
-    1: 'OFPR_ACTION',
-}
-
-# Identifiers from group ofp_port
-OFPP_MAX = 4294967040
-OFPP_IN_PORT = 4294967288
-OFPP_TABLE = 4294967289
-OFPP_NORMAL = 4294967290
-OFPP_FLOOD = 4294967291
-OFPP_ALL = 4294967292
-OFPP_CONTROLLER = 4294967293
-OFPP_LOCAL = 4294967294
-OFPP_ANY = 4294967295
-
-ofp_port_map = {
-    4294967040: 'OFPP_MAX',
-    4294967288: 'OFPP_IN_PORT',
-    4294967289: 'OFPP_TABLE',
-    4294967290: 'OFPP_NORMAL',
-    4294967291: 'OFPP_FLOOD',
-    4294967292: 'OFPP_ALL',
-    4294967293: 'OFPP_CONTROLLER',
-    4294967294: 'OFPP_LOCAL',
-    4294967295: 'OFPP_ANY',
-}
-
-# Identifiers from group ofp_port_config
-OFPPC_PORT_DOWN = 1
-OFPPC_NO_RECV = 4
-OFPPC_NO_FWD = 32
-OFPPC_NO_PACKET_IN = 64
-OFPPC_BSN_MIRROR_DEST = 2147483648
-
-ofp_port_config_map = {
-    1: 'OFPPC_PORT_DOWN',
-    4: 'OFPPC_NO_RECV',
-    32: 'OFPPC_NO_FWD',
-    64: 'OFPPC_NO_PACKET_IN',
-    2147483648: 'OFPPC_BSN_MIRROR_DEST',
-}
-
-# Identifiers from group ofp_port_features
-OFPPF_10MB_HD = 1
-OFPPF_10MB_FD = 2
-OFPPF_100MB_HD = 4
-OFPPF_100MB_FD = 8
-OFPPF_1GB_HD = 16
-OFPPF_1GB_FD = 32
-OFPPF_10GB_FD = 64
-OFPPF_40GB_FD = 128
-OFPPF_100GB_FD = 256
-OFPPF_1TB_FD = 512
-OFPPF_OTHER = 1024
-OFPPF_COPPER = 2048
-OFPPF_FIBER = 4096
-OFPPF_AUTONEG = 8192
-OFPPF_PAUSE = 16384
-OFPPF_PAUSE_ASYM = 32768
-
-ofp_port_features_map = {
-    1: 'OFPPF_10MB_HD',
-    2: 'OFPPF_10MB_FD',
-    4: 'OFPPF_100MB_HD',
-    8: 'OFPPF_100MB_FD',
-    16: 'OFPPF_1GB_HD',
-    32: 'OFPPF_1GB_FD',
-    64: 'OFPPF_10GB_FD',
-    128: 'OFPPF_40GB_FD',
-    256: 'OFPPF_100GB_FD',
-    512: 'OFPPF_1TB_FD',
-    1024: 'OFPPF_OTHER',
-    2048: 'OFPPF_COPPER',
-    4096: 'OFPPF_FIBER',
-    8192: 'OFPPF_AUTONEG',
-    16384: 'OFPPF_PAUSE',
-    32768: 'OFPPF_PAUSE_ASYM',
-}
-
-# Identifiers from group ofp_port_mod_failed_code
-OFPPMFC_BAD_PORT = 0
-OFPPMFC_BAD_HW_ADDR = 1
-OFPPMFC_BAD_CONFIG = 2
-OFPPMFC_BAD_ADVERTISE = 3
-
-ofp_port_mod_failed_code_map = {
-    0: 'OFPPMFC_BAD_PORT',
-    1: 'OFPPMFC_BAD_HW_ADDR',
-    2: 'OFPPMFC_BAD_CONFIG',
-    3: 'OFPPMFC_BAD_ADVERTISE',
-}
-
-# Identifiers from group ofp_port_reason
-OFPPR_ADD = 0
-OFPPR_DELETE = 1
-OFPPR_MODIFY = 2
-
-ofp_port_reason_map = {
-    0: 'OFPPR_ADD',
-    1: 'OFPPR_DELETE',
-    2: 'OFPPR_MODIFY',
-}
-
-# Identifiers from group ofp_port_state
-OFPPS_LINK_DOWN = 1
-OFPPS_BLOCKED = 2
-OFPPS_LIVE = 4
-
-ofp_port_state_map = {
-    1: 'OFPPS_LINK_DOWN',
-    2: 'OFPPS_BLOCKED',
-    4: 'OFPPS_LIVE',
-}
-
-# Identifiers from group ofp_queue_op_failed_code
-OFPQOFC_BAD_PORT = 0
-OFPQOFC_BAD_QUEUE = 1
-OFPQOFC_EPERM = 2
-
-ofp_queue_op_failed_code_map = {
-    0: 'OFPQOFC_BAD_PORT',
-    1: 'OFPQOFC_BAD_QUEUE',
-    2: 'OFPQOFC_EPERM',
-}
-
-# Identifiers from group ofp_queue_properties
-OFPQT_NONE = 0
-OFPQT_MIN_RATE = 1
-
-ofp_queue_properties_map = {
-    0: 'OFPQT_NONE',
-    1: 'OFPQT_MIN_RATE',
-}
-
-# Identifiers from group ofp_stats_reply_flags
-OFPSF_REPLY_MORE = 1
-
-ofp_stats_reply_flags_map = {
-    1: 'OFPSF_REPLY_MORE',
-}
-
-# Identifiers from group ofp_stats_request_flags
-
-ofp_stats_request_flags_map = {
-}
-
-# Identifiers from group ofp_stats_type
-OFPST_DESC = 0
-OFPST_FLOW = 1
-OFPST_AGGREGATE = 2
-OFPST_TABLE = 3
-OFPST_PORT = 4
-OFPST_QUEUE = 5
-OFPST_GROUP = 6
-OFPST_GROUP_DESC = 7
-OFPST_EXPERIMENTER = 65535
-
-ofp_stats_type_map = {
-    0: 'OFPST_DESC',
-    1: 'OFPST_FLOW',
-    2: 'OFPST_AGGREGATE',
-    3: 'OFPST_TABLE',
-    4: 'OFPST_PORT',
-    5: 'OFPST_QUEUE',
-    6: 'OFPST_GROUP',
-    7: 'OFPST_GROUP_DESC',
-    65535: 'OFPST_EXPERIMENTER',
-}
-
-# Identifiers from group ofp_switch_config_failed_code
-OFPSCFC_BAD_FLAGS = 0
-OFPSCFC_BAD_LEN = 1
-
-ofp_switch_config_failed_code_map = {
-    0: 'OFPSCFC_BAD_FLAGS',
-    1: 'OFPSCFC_BAD_LEN',
-}
-
-# Identifiers from group ofp_table_config
-OFPTC_TABLE_MISS_CONTROLLER = 0
-OFPTC_TABLE_MISS_CONTINUE = 1
-OFPTC_TABLE_MISS_DROP = 2
-OFPTC_TABLE_MISS_MASK = 3
-
-ofp_table_config_map = {
-    0: 'OFPTC_TABLE_MISS_CONTROLLER',
-    1: 'OFPTC_TABLE_MISS_CONTINUE',
-    2: 'OFPTC_TABLE_MISS_DROP',
-    3: 'OFPTC_TABLE_MISS_MASK',
-}
-
-# Identifiers from group ofp_table_mod_failed_code
-OFPTMFC_BAD_TABLE = 0
-OFPTMFC_BAD_CONFIG = 1
-
-ofp_table_mod_failed_code_map = {
-    0: 'OFPTMFC_BAD_TABLE',
-    1: 'OFPTMFC_BAD_CONFIG',
-}
-
-# Identifiers from group ofp_type
-OFPT_HELLO = 0
-OFPT_ERROR = 1
-OFPT_ECHO_REQUEST = 2
-OFPT_ECHO_REPLY = 3
-OFPT_EXPERIMENTER = 4
-OFPT_FEATURES_REQUEST = 5
-OFPT_FEATURES_REPLY = 6
-OFPT_GET_CONFIG_REQUEST = 7
-OFPT_GET_CONFIG_REPLY = 8
-OFPT_SET_CONFIG = 9
-OFPT_PACKET_IN = 10
-OFPT_FLOW_REMOVED = 11
-OFPT_PORT_STATUS = 12
-OFPT_PACKET_OUT = 13
-OFPT_FLOW_MOD = 14
-OFPT_GROUP_MOD = 15
-OFPT_PORT_MOD = 16
-OFPT_TABLE_MOD = 17
-OFPT_STATS_REQUEST = 18
-OFPT_STATS_REPLY = 19
-OFPT_BARRIER_REQUEST = 20
-OFPT_BARRIER_REPLY = 21
-OFPT_QUEUE_GET_CONFIG_REQUEST = 22
-OFPT_QUEUE_GET_CONFIG_REPLY = 23
-
-ofp_type_map = {
-    0: 'OFPT_HELLO',
-    1: 'OFPT_ERROR',
-    2: 'OFPT_ECHO_REQUEST',
-    3: 'OFPT_ECHO_REPLY',
-    4: 'OFPT_EXPERIMENTER',
-    5: 'OFPT_FEATURES_REQUEST',
-    6: 'OFPT_FEATURES_REPLY',
-    7: 'OFPT_GET_CONFIG_REQUEST',
-    8: 'OFPT_GET_CONFIG_REPLY',
-    9: 'OFPT_SET_CONFIG',
-    10: 'OFPT_PACKET_IN',
-    11: 'OFPT_FLOW_REMOVED',
-    12: 'OFPT_PORT_STATUS',
-    13: 'OFPT_PACKET_OUT',
-    14: 'OFPT_FLOW_MOD',
-    15: 'OFPT_GROUP_MOD',
-    16: 'OFPT_PORT_MOD',
-    17: 'OFPT_TABLE_MOD',
-    18: 'OFPT_STATS_REQUEST',
-    19: 'OFPT_STATS_REPLY',
-    20: 'OFPT_BARRIER_REQUEST',
-    21: 'OFPT_BARRIER_REPLY',
-    22: 'OFPT_QUEUE_GET_CONFIG_REQUEST',
-    23: 'OFPT_QUEUE_GET_CONFIG_REPLY',
-}
-
-# Identifiers from group ofp_vlan_id
-OFPVID_ANY = 65534
-OFPVID_NONE = 65535
-
-ofp_vlan_id_map = {
-    65534: 'OFPVID_ANY',
-    65535: 'OFPVID_NONE',
-}
-
diff --git a/python/ofagent/loxi/of11/instruction.py b/python/ofagent/loxi/of11/instruction.py
deleted file mode 100644
index 7910aef..0000000
--- a/python/ofagent/loxi/of11/instruction.py
+++ /dev/null
@@ -1,386 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template module.py
-# Do not modify
-
-import struct
-import loxi
-import util
-import loxi.generic_util
-
-import sys
-ofp = sys.modules['loxi.of11']
-
-class instruction(loxi.OFObject):
-    subtypes = {}
-
-
-    def __init__(self, type=None):
-        if type != None:
-            self.type = type
-        else:
-            self.type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 0)
-        subclass = instruction.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = instruction()
-        obj.type = reader.read("!H")[0]
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type != other.type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("instruction {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-
-class apply_actions(instruction):
-    type = 4
-
-    def __init__(self, actions=None):
-        if actions != None:
-            self.actions = actions
-        else:
-            self.actions = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.actions))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = apply_actions()
-        _type = reader.read("!H")[0]
-        assert(_type == 4)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        obj.actions = loxi.generic_util.unpack_list(reader, ofp.action.action.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.actions != other.actions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("apply_actions {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("actions = ");
-                q.pp(self.actions)
-            q.breakable()
-        q.text('}')
-
-instruction.subtypes[4] = apply_actions
-
-class clear_actions(instruction):
-    type = 5
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = clear_actions()
-        _type = reader.read("!H")[0]
-        assert(_type == 5)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("clear_actions {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-instruction.subtypes[5] = clear_actions
-
-class experimenter(instruction):
-    subtypes = {}
-
-    type = 65535
-
-    def __init__(self, experimenter=None, data=None):
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 4)
-        subclass = experimenter.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = experimenter()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.experimenter = reader.read("!L")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.experimenter != other.experimenter: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("experimenter {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-instruction.subtypes[65535] = experimenter
-
-class goto_table(instruction):
-    type = 1
-
-    def __init__(self, table_id=None):
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append('\x00' * 3)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = goto_table()
-        _type = reader.read("!H")[0]
-        assert(_type == 1)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.table_id = reader.read("!B")[0]
-        reader.skip(3)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.table_id != other.table_id: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("goto_table {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-            q.breakable()
-        q.text('}')
-
-instruction.subtypes[1] = goto_table
-
-class write_actions(instruction):
-    type = 3
-
-    def __init__(self, actions=None):
-        if actions != None:
-            self.actions = actions
-        else:
-            self.actions = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.actions))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = write_actions()
-        _type = reader.read("!H")[0]
-        assert(_type == 3)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        obj.actions = loxi.generic_util.unpack_list(reader, ofp.action.action.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.actions != other.actions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("write_actions {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("actions = ");
-                q.pp(self.actions)
-            q.breakable()
-        q.text('}')
-
-instruction.subtypes[3] = write_actions
-
-class write_metadata(instruction):
-    type = 2
-
-    def __init__(self, metadata=None, metadata_mask=None):
-        if metadata != None:
-            self.metadata = metadata
-        else:
-            self.metadata = 0
-        if metadata_mask != None:
-            self.metadata_mask = metadata_mask
-        else:
-            self.metadata_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!Q", self.metadata))
-        packed.append(struct.pack("!Q", self.metadata_mask))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = write_metadata()
-        _type = reader.read("!H")[0]
-        assert(_type == 2)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        obj.metadata = reader.read("!Q")[0]
-        obj.metadata_mask = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.metadata != other.metadata: return False
-        if self.metadata_mask != other.metadata_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("write_metadata {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("metadata = ");
-                q.text("%#x" % self.metadata)
-                q.text(","); q.breakable()
-                q.text("metadata_mask = ");
-                q.text("%#x" % self.metadata_mask)
-            q.breakable()
-        q.text('}')
-
-instruction.subtypes[2] = write_metadata
-
-
diff --git a/python/ofagent/loxi/of11/message.py b/python/ofagent/loxi/of11/message.py
deleted file mode 100644
index cb102f8..0000000
--- a/python/ofagent/loxi/of11/message.py
+++ /dev/null
@@ -1,7856 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template module.py
-# Do not modify
-
-import struct
-import loxi
-import util
-import loxi.generic_util
-
-import sys
-ofp = sys.modules['loxi.of11']
-
-class message(loxi.OFObject):
-    subtypes = {}
-
-    version = 2
-
-    def __init__(self, type=None, xid=None):
-        if type != None:
-            self.type = type
-        else:
-            self.type = 0
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('B', 1)
-        subclass = message.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = message()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        obj.type = reader.read("!B")[0]
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type != other.type: return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("message {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-
-class stats_reply(message):
-    subtypes = {}
-
-    version = 2
-    type = 19
-
-    def __init__(self, xid=None, stats_type=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if stats_type != None:
-            self.stats_type = stats_type
-        else:
-            self.stats_type = 0
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 8)
-        subclass = stats_reply.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.stats_type = reader.read("!H")[0]
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.stats_type != other.stats_type: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[19] = stats_reply
-
-class aggregate_stats_reply(stats_reply):
-    version = 2
-    type = 19
-    stats_type = 2
-
-    def __init__(self, xid=None, flags=None, packet_count=None, byte_count=None, flow_count=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if packet_count != None:
-            self.packet_count = packet_count
-        else:
-            self.packet_count = 0
-        if byte_count != None:
-            self.byte_count = byte_count
-        else:
-            self.byte_count = 0
-        if flow_count != None:
-            self.flow_count = flow_count
-        else:
-            self.flow_count = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!Q", self.packet_count))
-        packed.append(struct.pack("!Q", self.byte_count))
-        packed.append(struct.pack("!L", self.flow_count))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = aggregate_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 2)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.packet_count = reader.read("!Q")[0]
-        obj.byte_count = reader.read("!Q")[0]
-        obj.flow_count = reader.read("!L")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.packet_count != other.packet_count: return False
-        if self.byte_count != other.byte_count: return False
-        if self.flow_count != other.flow_count: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("aggregate_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("packet_count = ");
-                q.text("%#x" % self.packet_count)
-                q.text(","); q.breakable()
-                q.text("byte_count = ");
-                q.text("%#x" % self.byte_count)
-                q.text(","); q.breakable()
-                q.text("flow_count = ");
-                q.text("%#x" % self.flow_count)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[2] = aggregate_stats_reply
-
-class stats_request(message):
-    subtypes = {}
-
-    version = 2
-    type = 18
-
-    def __init__(self, xid=None, stats_type=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if stats_type != None:
-            self.stats_type = stats_type
-        else:
-            self.stats_type = 0
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 8)
-        subclass = stats_request.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.stats_type = reader.read("!H")[0]
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.stats_type != other.stats_type: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[18] = stats_request
-
-class aggregate_stats_request(stats_request):
-    version = 2
-    type = 18
-    stats_type = 2
-
-    def __init__(self, xid=None, flags=None, table_id=None, out_port=None, out_group=None, cookie=None, cookie_mask=None, match=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if out_port != None:
-            self.out_port = out_port
-        else:
-            self.out_port = 0
-        if out_group != None:
-            self.out_group = out_group
-        else:
-            self.out_group = 0
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if cookie_mask != None:
-            self.cookie_mask = cookie_mask
-        else:
-            self.cookie_mask = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append('\x00' * 3)
-        packed.append(util.pack_port_no(self.out_port))
-        packed.append(struct.pack("!L", self.out_group))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(struct.pack("!Q", self.cookie_mask))
-        packed.append(self.match.pack())
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = aggregate_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 2)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.table_id = reader.read("!B")[0]
-        reader.skip(3)
-        obj.out_port = util.unpack_port_no(reader)
-        obj.out_group = reader.read("!L")[0]
-        reader.skip(4)
-        obj.cookie = reader.read("!Q")[0]
-        obj.cookie_mask = reader.read("!Q")[0]
-        obj.match = ofp.match.unpack(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.table_id != other.table_id: return False
-        if self.out_port != other.out_port: return False
-        if self.out_group != other.out_group: return False
-        if self.cookie != other.cookie: return False
-        if self.cookie_mask != other.cookie_mask: return False
-        if self.match != other.match: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("aggregate_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("out_port = ");
-                q.text(util.pretty_port(self.out_port))
-                q.text(","); q.breakable()
-                q.text("out_group = ");
-                q.text("%#x" % self.out_group)
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("cookie_mask = ");
-                q.text("%#x" % self.cookie_mask)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[2] = aggregate_stats_request
-
-class error_msg(message):
-    subtypes = {}
-
-    version = 2
-    type = 1
-
-    def __init__(self, xid=None, err_type=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if err_type != None:
-            self.err_type = err_type
-        else:
-            self.err_type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 8)
-        subclass = error_msg.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.err_type = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.err_type != other.err_type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-message.subtypes[1] = error_msg
-
-class bad_action_error_msg(error_msg):
-    version = 2
-    type = 1
-    err_type = 2
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bad_action_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 2)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bad_action_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[2] = bad_action_error_msg
-
-class bad_instruction_error_msg(error_msg):
-    version = 2
-    type = 1
-    err_type = 3
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bad_instruction_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 3)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bad_instruction_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[3] = bad_instruction_error_msg
-
-class bad_match_error_msg(error_msg):
-    version = 2
-    type = 1
-    err_type = 4
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bad_match_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 4)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bad_match_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[4] = bad_match_error_msg
-
-class bad_request_error_msg(error_msg):
-    version = 2
-    type = 1
-    err_type = 1
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bad_request_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 1)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bad_request_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[1] = bad_request_error_msg
-
-class barrier_reply(message):
-    version = 2
-    type = 21
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = barrier_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 21)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("barrier_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-message.subtypes[21] = barrier_reply
-
-class barrier_request(message):
-    version = 2
-    type = 20
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = barrier_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 20)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("barrier_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-message.subtypes[20] = barrier_request
-
-class experimenter(message):
-    subtypes = {}
-
-    version = 2
-    type = 4
-
-    def __init__(self, xid=None, experimenter=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 8)
-        subclass = experimenter.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = experimenter()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.experimenter = reader.read("!L")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.experimenter != other.experimenter: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("experimenter {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[4] = experimenter
-
-class bsn_header(experimenter):
-    subtypes = {}
-
-    version = 2
-    type = 4
-    experimenter = 6035143
-
-    def __init__(self, xid=None, subtype=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 12)
-        subclass = bsn_header.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = bsn_header()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        obj.subtype = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.subtype != other.subtype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_header {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-experimenter.subtypes[6035143] = bsn_header
-
-class bsn_bw_clear_data_reply(bsn_header):
-    version = 2
-    type = 4
-    experimenter = 6035143
-    subtype = 22
-
-    def __init__(self, xid=None, status=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if status != None:
-            self.status = status
-        else:
-            self.status = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.status))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_bw_clear_data_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 22)
-        obj.status = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.status != other.status: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_bw_clear_data_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("status = ");
-                q.text("%#x" % self.status)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[22] = bsn_bw_clear_data_reply
-
-class bsn_bw_clear_data_request(bsn_header):
-    version = 2
-    type = 4
-    experimenter = 6035143
-    subtype = 21
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_bw_clear_data_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 21)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_bw_clear_data_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[21] = bsn_bw_clear_data_request
-
-class bsn_bw_enable_get_reply(bsn_header):
-    version = 2
-    type = 4
-    experimenter = 6035143
-    subtype = 20
-
-    def __init__(self, xid=None, enabled=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if enabled != None:
-            self.enabled = enabled
-        else:
-            self.enabled = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.enabled))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_bw_enable_get_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 20)
-        obj.enabled = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.enabled != other.enabled: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_bw_enable_get_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("enabled = ");
-                q.text("%#x" % self.enabled)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[20] = bsn_bw_enable_get_reply
-
-class bsn_bw_enable_get_request(bsn_header):
-    version = 2
-    type = 4
-    experimenter = 6035143
-    subtype = 19
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_bw_enable_get_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 19)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_bw_enable_get_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[19] = bsn_bw_enable_get_request
-
-class bsn_bw_enable_set_reply(bsn_header):
-    version = 2
-    type = 4
-    experimenter = 6035143
-    subtype = 23
-
-    def __init__(self, xid=None, enable=None, status=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if enable != None:
-            self.enable = enable
-        else:
-            self.enable = 0
-        if status != None:
-            self.status = status
-        else:
-            self.status = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.enable))
-        packed.append(struct.pack("!L", self.status))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_bw_enable_set_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 23)
-        obj.enable = reader.read("!L")[0]
-        obj.status = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.enable != other.enable: return False
-        if self.status != other.status: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_bw_enable_set_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("enable = ");
-                q.text("%#x" % self.enable)
-                q.text(","); q.breakable()
-                q.text("status = ");
-                q.text("%#x" % self.status)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[23] = bsn_bw_enable_set_reply
-
-class bsn_bw_enable_set_request(bsn_header):
-    version = 2
-    type = 4
-    experimenter = 6035143
-    subtype = 18
-
-    def __init__(self, xid=None, enable=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if enable != None:
-            self.enable = enable
-        else:
-            self.enable = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.enable))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_bw_enable_set_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 18)
-        obj.enable = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.enable != other.enable: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_bw_enable_set_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("enable = ");
-                q.text("%#x" % self.enable)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[18] = bsn_bw_enable_set_request
-
-class bsn_get_interfaces_reply(bsn_header):
-    version = 2
-    type = 4
-    experimenter = 6035143
-    subtype = 10
-
-    def __init__(self, xid=None, interfaces=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if interfaces != None:
-            self.interfaces = interfaces
-        else:
-            self.interfaces = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(loxi.generic_util.pack_list(self.interfaces))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_get_interfaces_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 10)
-        obj.interfaces = loxi.generic_util.unpack_list(reader, ofp.common.bsn_interface.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.interfaces != other.interfaces: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_get_interfaces_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("interfaces = ");
-                q.pp(self.interfaces)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[10] = bsn_get_interfaces_reply
-
-class bsn_get_interfaces_request(bsn_header):
-    version = 2
-    type = 4
-    experimenter = 6035143
-    subtype = 9
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_get_interfaces_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 9)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_get_interfaces_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[9] = bsn_get_interfaces_request
-
-class bsn_get_mirroring_reply(bsn_header):
-    version = 2
-    type = 4
-    experimenter = 6035143
-    subtype = 5
-
-    def __init__(self, xid=None, report_mirror_ports=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if report_mirror_ports != None:
-            self.report_mirror_ports = report_mirror_ports
-        else:
-            self.report_mirror_ports = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!B", self.report_mirror_ports))
-        packed.append('\x00' * 3)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_get_mirroring_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 5)
-        obj.report_mirror_ports = reader.read("!B")[0]
-        reader.skip(3)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.report_mirror_ports != other.report_mirror_ports: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_get_mirroring_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("report_mirror_ports = ");
-                q.text("%#x" % self.report_mirror_ports)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[5] = bsn_get_mirroring_reply
-
-class bsn_get_mirroring_request(bsn_header):
-    version = 2
-    type = 4
-    experimenter = 6035143
-    subtype = 4
-
-    def __init__(self, xid=None, report_mirror_ports=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if report_mirror_ports != None:
-            self.report_mirror_ports = report_mirror_ports
-        else:
-            self.report_mirror_ports = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!B", self.report_mirror_ports))
-        packed.append('\x00' * 3)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_get_mirroring_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 4)
-        obj.report_mirror_ports = reader.read("!B")[0]
-        reader.skip(3)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.report_mirror_ports != other.report_mirror_ports: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_get_mirroring_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("report_mirror_ports = ");
-                q.text("%#x" % self.report_mirror_ports)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[4] = bsn_get_mirroring_request
-
-class bsn_pdu_rx_reply(bsn_header):
-    version = 2
-    type = 4
-    experimenter = 6035143
-    subtype = 34
-
-    def __init__(self, xid=None, status=None, port_no=None, slot_num=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if status != None:
-            self.status = status
-        else:
-            self.status = 0
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if slot_num != None:
-            self.slot_num = slot_num
-        else:
-            self.slot_num = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.status))
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(struct.pack("!B", self.slot_num))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_pdu_rx_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 34)
-        obj.status = reader.read("!L")[0]
-        obj.port_no = util.unpack_port_no(reader)
-        obj.slot_num = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.status != other.status: return False
-        if self.port_no != other.port_no: return False
-        if self.slot_num != other.slot_num: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_pdu_rx_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("status = ");
-                q.text("%#x" % self.status)
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("slot_num = ");
-                q.text("%#x" % self.slot_num)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[34] = bsn_pdu_rx_reply
-
-class bsn_pdu_rx_request(bsn_header):
-    version = 2
-    type = 4
-    experimenter = 6035143
-    subtype = 33
-
-    def __init__(self, xid=None, timeout_ms=None, port_no=None, slot_num=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if timeout_ms != None:
-            self.timeout_ms = timeout_ms
-        else:
-            self.timeout_ms = 0
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if slot_num != None:
-            self.slot_num = slot_num
-        else:
-            self.slot_num = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.timeout_ms))
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(struct.pack("!B", self.slot_num))
-        packed.append('\x00' * 3)
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_pdu_rx_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 33)
-        obj.timeout_ms = reader.read("!L")[0]
-        obj.port_no = util.unpack_port_no(reader)
-        obj.slot_num = reader.read("!B")[0]
-        reader.skip(3)
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.timeout_ms != other.timeout_ms: return False
-        if self.port_no != other.port_no: return False
-        if self.slot_num != other.slot_num: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_pdu_rx_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("timeout_ms = ");
-                q.text("%#x" % self.timeout_ms)
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("slot_num = ");
-                q.text("%#x" % self.slot_num)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[33] = bsn_pdu_rx_request
-
-class bsn_pdu_rx_timeout(bsn_header):
-    version = 2
-    type = 4
-    experimenter = 6035143
-    subtype = 35
-
-    def __init__(self, xid=None, port_no=None, slot_num=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if slot_num != None:
-            self.slot_num = slot_num
-        else:
-            self.slot_num = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(struct.pack("!B", self.slot_num))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_pdu_rx_timeout()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 35)
-        obj.port_no = util.unpack_port_no(reader)
-        obj.slot_num = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.port_no != other.port_no: return False
-        if self.slot_num != other.slot_num: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_pdu_rx_timeout {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("slot_num = ");
-                q.text("%#x" % self.slot_num)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[35] = bsn_pdu_rx_timeout
-
-class bsn_pdu_tx_reply(bsn_header):
-    version = 2
-    type = 4
-    experimenter = 6035143
-    subtype = 32
-
-    def __init__(self, xid=None, status=None, port_no=None, slot_num=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if status != None:
-            self.status = status
-        else:
-            self.status = 0
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if slot_num != None:
-            self.slot_num = slot_num
-        else:
-            self.slot_num = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.status))
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(struct.pack("!B", self.slot_num))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_pdu_tx_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 32)
-        obj.status = reader.read("!L")[0]
-        obj.port_no = util.unpack_port_no(reader)
-        obj.slot_num = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.status != other.status: return False
-        if self.port_no != other.port_no: return False
-        if self.slot_num != other.slot_num: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_pdu_tx_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("status = ");
-                q.text("%#x" % self.status)
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("slot_num = ");
-                q.text("%#x" % self.slot_num)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[32] = bsn_pdu_tx_reply
-
-class bsn_pdu_tx_request(bsn_header):
-    version = 2
-    type = 4
-    experimenter = 6035143
-    subtype = 31
-
-    def __init__(self, xid=None, tx_interval_ms=None, port_no=None, slot_num=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if tx_interval_ms != None:
-            self.tx_interval_ms = tx_interval_ms
-        else:
-            self.tx_interval_ms = 0
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if slot_num != None:
-            self.slot_num = slot_num
-        else:
-            self.slot_num = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.tx_interval_ms))
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(struct.pack("!B", self.slot_num))
-        packed.append('\x00' * 3)
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_pdu_tx_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 31)
-        obj.tx_interval_ms = reader.read("!L")[0]
-        obj.port_no = util.unpack_port_no(reader)
-        obj.slot_num = reader.read("!B")[0]
-        reader.skip(3)
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.tx_interval_ms != other.tx_interval_ms: return False
-        if self.port_no != other.port_no: return False
-        if self.slot_num != other.slot_num: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_pdu_tx_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("tx_interval_ms = ");
-                q.text("%#x" % self.tx_interval_ms)
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("slot_num = ");
-                q.text("%#x" % self.slot_num)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[31] = bsn_pdu_tx_request
-
-class bsn_set_mirroring(bsn_header):
-    version = 2
-    type = 4
-    experimenter = 6035143
-    subtype = 3
-
-    def __init__(self, xid=None, report_mirror_ports=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if report_mirror_ports != None:
-            self.report_mirror_ports = report_mirror_ports
-        else:
-            self.report_mirror_ports = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!B", self.report_mirror_ports))
-        packed.append('\x00' * 3)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_set_mirroring()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 3)
-        obj.report_mirror_ports = reader.read("!B")[0]
-        reader.skip(3)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.report_mirror_ports != other.report_mirror_ports: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_set_mirroring {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("report_mirror_ports = ");
-                q.text("%#x" % self.report_mirror_ports)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[3] = bsn_set_mirroring
-
-class bsn_set_pktin_suppression_reply(bsn_header):
-    version = 2
-    type = 4
-    experimenter = 6035143
-    subtype = 25
-
-    def __init__(self, xid=None, status=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if status != None:
-            self.status = status
-        else:
-            self.status = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.status))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_set_pktin_suppression_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 25)
-        obj.status = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.status != other.status: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_set_pktin_suppression_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("status = ");
-                q.text("%#x" % self.status)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[25] = bsn_set_pktin_suppression_reply
-
-class bsn_set_pktin_suppression_request(bsn_header):
-    version = 2
-    type = 4
-    experimenter = 6035143
-    subtype = 11
-
-    def __init__(self, xid=None, enabled=None, idle_timeout=None, hard_timeout=None, priority=None, cookie=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if enabled != None:
-            self.enabled = enabled
-        else:
-            self.enabled = 0
-        if idle_timeout != None:
-            self.idle_timeout = idle_timeout
-        else:
-            self.idle_timeout = 0
-        if hard_timeout != None:
-            self.hard_timeout = hard_timeout
-        else:
-            self.hard_timeout = 0
-        if priority != None:
-            self.priority = priority
-        else:
-            self.priority = 0
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!B", self.enabled))
-        packed.append('\x00' * 1)
-        packed.append(struct.pack("!H", self.idle_timeout))
-        packed.append(struct.pack("!H", self.hard_timeout))
-        packed.append(struct.pack("!H", self.priority))
-        packed.append(struct.pack("!Q", self.cookie))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_set_pktin_suppression_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 11)
-        obj.enabled = reader.read("!B")[0]
-        reader.skip(1)
-        obj.idle_timeout = reader.read("!H")[0]
-        obj.hard_timeout = reader.read("!H")[0]
-        obj.priority = reader.read("!H")[0]
-        obj.cookie = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.enabled != other.enabled: return False
-        if self.idle_timeout != other.idle_timeout: return False
-        if self.hard_timeout != other.hard_timeout: return False
-        if self.priority != other.priority: return False
-        if self.cookie != other.cookie: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_set_pktin_suppression_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("enabled = ");
-                q.text("%#x" % self.enabled)
-                q.text(","); q.breakable()
-                q.text("idle_timeout = ");
-                q.text("%#x" % self.idle_timeout)
-                q.text(","); q.breakable()
-                q.text("hard_timeout = ");
-                q.text("%#x" % self.hard_timeout)
-                q.text(","); q.breakable()
-                q.text("priority = ");
-                q.text("%#x" % self.priority)
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[11] = bsn_set_pktin_suppression_request
-
-class experimenter_stats_reply(stats_reply):
-    subtypes = {}
-
-    version = 2
-    type = 19
-    stats_type = 65535
-
-    def __init__(self, xid=None, flags=None, experimenter=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append('\x00' * 4)
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 16)
-        subclass = experimenter_stats_reply.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = experimenter_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.experimenter = reader.read("!L")[0]
-        reader.skip(4)
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.experimenter != other.experimenter: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("experimenter_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[65535] = experimenter_stats_reply
-
-class bsn_stats_reply(experimenter_stats_reply):
-    subtypes = {}
-
-    version = 2
-    type = 19
-    stats_type = 65535
-    experimenter = 6035143
-
-    def __init__(self, xid=None, flags=None, subtype=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 20)
-        subclass = bsn_stats_reply.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = bsn_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        obj.subtype = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.subtype != other.subtype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-experimenter_stats_reply.subtypes[6035143] = bsn_stats_reply
-
-class experimenter_stats_request(stats_request):
-    subtypes = {}
-
-    version = 2
-    type = 18
-    stats_type = 65535
-
-    def __init__(self, xid=None, flags=None, experimenter=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append('\x00' * 4)
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 16)
-        subclass = experimenter_stats_request.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = experimenter_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.experimenter = reader.read("!L")[0]
-        reader.skip(4)
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.experimenter != other.experimenter: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("experimenter_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[65535] = experimenter_stats_request
-
-class bsn_stats_request(experimenter_stats_request):
-    subtypes = {}
-
-    version = 2
-    type = 18
-    stats_type = 65535
-    experimenter = 6035143
-
-    def __init__(self, xid=None, flags=None, subtype=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 20)
-        subclass = bsn_stats_request.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = bsn_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        obj.subtype = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.subtype != other.subtype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-experimenter_stats_request.subtypes[6035143] = bsn_stats_request
-
-class bsn_virtual_port_create_reply(bsn_header):
-    version = 2
-    type = 4
-    experimenter = 6035143
-    subtype = 16
-
-    def __init__(self, xid=None, status=None, vport_no=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if status != None:
-            self.status = status
-        else:
-            self.status = 0
-        if vport_no != None:
-            self.vport_no = vport_no
-        else:
-            self.vport_no = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.status))
-        packed.append(struct.pack("!L", self.vport_no))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_virtual_port_create_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 16)
-        obj.status = reader.read("!L")[0]
-        obj.vport_no = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.status != other.status: return False
-        if self.vport_no != other.vport_no: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_virtual_port_create_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("status = ");
-                q.text("%#x" % self.status)
-                q.text(","); q.breakable()
-                q.text("vport_no = ");
-                q.text("%#x" % self.vport_no)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[16] = bsn_virtual_port_create_reply
-
-class bsn_virtual_port_create_request(bsn_header):
-    version = 2
-    type = 4
-    experimenter = 6035143
-    subtype = 15
-
-    def __init__(self, xid=None, vport=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if vport != None:
-            self.vport = vport
-        else:
-            self.vport = ofp.bsn_vport()
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(self.vport.pack())
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_virtual_port_create_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 15)
-        obj.vport = ofp.bsn_vport.unpack(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.vport != other.vport: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_virtual_port_create_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("vport = ");
-                q.pp(self.vport)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[15] = bsn_virtual_port_create_request
-
-class bsn_virtual_port_remove_reply(bsn_header):
-    version = 2
-    type = 4
-    experimenter = 6035143
-    subtype = 26
-
-    def __init__(self, xid=None, status=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if status != None:
-            self.status = status
-        else:
-            self.status = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.status))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_virtual_port_remove_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 26)
-        obj.status = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.status != other.status: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_virtual_port_remove_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("status = ");
-                q.text("%#x" % self.status)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[26] = bsn_virtual_port_remove_reply
-
-class bsn_virtual_port_remove_request(bsn_header):
-    version = 2
-    type = 4
-    experimenter = 6035143
-    subtype = 17
-
-    def __init__(self, xid=None, vport_no=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if vport_no != None:
-            self.vport_no = vport_no
-        else:
-            self.vport_no = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.vport_no))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_virtual_port_remove_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 17)
-        obj.vport_no = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.vport_no != other.vport_no: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_virtual_port_remove_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("vport_no = ");
-                q.text("%#x" % self.vport_no)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[17] = bsn_virtual_port_remove_request
-
-class desc_stats_reply(stats_reply):
-    version = 2
-    type = 19
-    stats_type = 0
-
-    def __init__(self, xid=None, flags=None, mfr_desc=None, hw_desc=None, sw_desc=None, serial_num=None, dp_desc=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if mfr_desc != None:
-            self.mfr_desc = mfr_desc
-        else:
-            self.mfr_desc = ""
-        if hw_desc != None:
-            self.hw_desc = hw_desc
-        else:
-            self.hw_desc = ""
-        if sw_desc != None:
-            self.sw_desc = sw_desc
-        else:
-            self.sw_desc = ""
-        if serial_num != None:
-            self.serial_num = serial_num
-        else:
-            self.serial_num = ""
-        if dp_desc != None:
-            self.dp_desc = dp_desc
-        else:
-            self.dp_desc = ""
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!256s", self.mfr_desc))
-        packed.append(struct.pack("!256s", self.hw_desc))
-        packed.append(struct.pack("!256s", self.sw_desc))
-        packed.append(struct.pack("!32s", self.serial_num))
-        packed.append(struct.pack("!256s", self.dp_desc))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = desc_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 0)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.mfr_desc = reader.read("!256s")[0].rstrip("\x00")
-        obj.hw_desc = reader.read("!256s")[0].rstrip("\x00")
-        obj.sw_desc = reader.read("!256s")[0].rstrip("\x00")
-        obj.serial_num = reader.read("!32s")[0].rstrip("\x00")
-        obj.dp_desc = reader.read("!256s")[0].rstrip("\x00")
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.mfr_desc != other.mfr_desc: return False
-        if self.hw_desc != other.hw_desc: return False
-        if self.sw_desc != other.sw_desc: return False
-        if self.serial_num != other.serial_num: return False
-        if self.dp_desc != other.dp_desc: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("desc_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("mfr_desc = ");
-                q.pp(self.mfr_desc)
-                q.text(","); q.breakable()
-                q.text("hw_desc = ");
-                q.pp(self.hw_desc)
-                q.text(","); q.breakable()
-                q.text("sw_desc = ");
-                q.pp(self.sw_desc)
-                q.text(","); q.breakable()
-                q.text("serial_num = ");
-                q.pp(self.serial_num)
-                q.text(","); q.breakable()
-                q.text("dp_desc = ");
-                q.pp(self.dp_desc)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[0] = desc_stats_reply
-
-class desc_stats_request(stats_request):
-    version = 2
-    type = 18
-    stats_type = 0
-
-    def __init__(self, xid=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = desc_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 0)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("desc_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[0] = desc_stats_request
-
-class echo_reply(message):
-    version = 2
-    type = 3
-
-    def __init__(self, xid=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = echo_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 3)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("echo_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[3] = echo_reply
-
-class echo_request(message):
-    version = 2
-    type = 2
-
-    def __init__(self, xid=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = echo_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 2)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("echo_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[2] = echo_request
-
-class features_reply(message):
-    version = 2
-    type = 6
-
-    def __init__(self, xid=None, datapath_id=None, n_buffers=None, n_tables=None, capabilities=None, reserved=None, ports=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if datapath_id != None:
-            self.datapath_id = datapath_id
-        else:
-            self.datapath_id = 0
-        if n_buffers != None:
-            self.n_buffers = n_buffers
-        else:
-            self.n_buffers = 0
-        if n_tables != None:
-            self.n_tables = n_tables
-        else:
-            self.n_tables = 0
-        if capabilities != None:
-            self.capabilities = capabilities
-        else:
-            self.capabilities = 0
-        if reserved != None:
-            self.reserved = reserved
-        else:
-            self.reserved = 0
-        if ports != None:
-            self.ports = ports
-        else:
-            self.ports = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!Q", self.datapath_id))
-        packed.append(struct.pack("!L", self.n_buffers))
-        packed.append(struct.pack("!B", self.n_tables))
-        packed.append('\x00' * 3)
-        packed.append(struct.pack("!L", self.capabilities))
-        packed.append(struct.pack("!L", self.reserved))
-        packed.append(loxi.generic_util.pack_list(self.ports))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = features_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 6)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.datapath_id = reader.read("!Q")[0]
-        obj.n_buffers = reader.read("!L")[0]
-        obj.n_tables = reader.read("!B")[0]
-        reader.skip(3)
-        obj.capabilities = reader.read("!L")[0]
-        obj.reserved = reader.read("!L")[0]
-        obj.ports = loxi.generic_util.unpack_list(reader, ofp.common.port_desc.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.datapath_id != other.datapath_id: return False
-        if self.n_buffers != other.n_buffers: return False
-        if self.n_tables != other.n_tables: return False
-        if self.capabilities != other.capabilities: return False
-        if self.reserved != other.reserved: return False
-        if self.ports != other.ports: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("features_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("datapath_id = ");
-                q.text("%#x" % self.datapath_id)
-                q.text(","); q.breakable()
-                q.text("n_buffers = ");
-                q.text("%#x" % self.n_buffers)
-                q.text(","); q.breakable()
-                q.text("n_tables = ");
-                q.text("%#x" % self.n_tables)
-                q.text(","); q.breakable()
-                q.text("capabilities = ");
-                q.text("%#x" % self.capabilities)
-                q.text(","); q.breakable()
-                q.text("reserved = ");
-                q.text("%#x" % self.reserved)
-                q.text(","); q.breakable()
-                q.text("ports = ");
-                q.pp(self.ports)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[6] = features_reply
-
-class features_request(message):
-    version = 2
-    type = 5
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = features_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 5)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("features_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-message.subtypes[5] = features_request
-
-class flow_mod(message):
-    subtypes = {}
-
-    version = 2
-    type = 14
-
-    def __init__(self, xid=None, cookie=None, cookie_mask=None, table_id=None, _command=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, out_group=None, flags=None, match=None, instructions=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if cookie_mask != None:
-            self.cookie_mask = cookie_mask
-        else:
-            self.cookie_mask = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if _command != None:
-            self._command = _command
-        else:
-            self._command = 0
-        if idle_timeout != None:
-            self.idle_timeout = idle_timeout
-        else:
-            self.idle_timeout = 0
-        if hard_timeout != None:
-            self.hard_timeout = hard_timeout
-        else:
-            self.hard_timeout = 0
-        if priority != None:
-            self.priority = priority
-        else:
-            self.priority = 0
-        if buffer_id != None:
-            self.buffer_id = buffer_id
-        else:
-            self.buffer_id = 0
-        if out_port != None:
-            self.out_port = out_port
-        else:
-            self.out_port = 0
-        if out_group != None:
-            self.out_group = out_group
-        else:
-            self.out_group = 0
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        if instructions != None:
-            self.instructions = instructions
-        else:
-            self.instructions = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(struct.pack("!Q", self.cookie_mask))
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append(util.pack_fm_cmd(self._command))
-        packed.append(struct.pack("!H", self.idle_timeout))
-        packed.append(struct.pack("!H", self.hard_timeout))
-        packed.append(struct.pack("!H", self.priority))
-        packed.append(struct.pack("!L", self.buffer_id))
-        packed.append(util.pack_port_no(self.out_port))
-        packed.append(struct.pack("!L", self.out_group))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 2)
-        packed.append(self.match.pack())
-        packed.append(loxi.generic_util.pack_list(self.instructions))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('B', 25)
-        subclass = flow_mod.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = flow_mod()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 14)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.cookie = reader.read("!Q")[0]
-        obj.cookie_mask = reader.read("!Q")[0]
-        obj.table_id = reader.read("!B")[0]
-        obj._command = util.unpack_fm_cmd(reader)
-        obj.idle_timeout = reader.read("!H")[0]
-        obj.hard_timeout = reader.read("!H")[0]
-        obj.priority = reader.read("!H")[0]
-        obj.buffer_id = reader.read("!L")[0]
-        obj.out_port = util.unpack_port_no(reader)
-        obj.out_group = reader.read("!L")[0]
-        obj.flags = reader.read("!H")[0]
-        reader.skip(2)
-        obj.match = ofp.match.unpack(reader)
-        obj.instructions = loxi.generic_util.unpack_list(reader, ofp.instruction.instruction.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.cookie != other.cookie: return False
-        if self.cookie_mask != other.cookie_mask: return False
-        if self.table_id != other.table_id: return False
-        if self._command != other._command: return False
-        if self.idle_timeout != other.idle_timeout: return False
-        if self.hard_timeout != other.hard_timeout: return False
-        if self.priority != other.priority: return False
-        if self.buffer_id != other.buffer_id: return False
-        if self.out_port != other.out_port: return False
-        if self.out_group != other.out_group: return False
-        if self.flags != other.flags: return False
-        if self.match != other.match: return False
-        if self.instructions != other.instructions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_mod {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("cookie_mask = ");
-                q.text("%#x" % self.cookie_mask)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("idle_timeout = ");
-                q.text("%#x" % self.idle_timeout)
-                q.text(","); q.breakable()
-                q.text("hard_timeout = ");
-                q.text("%#x" % self.hard_timeout)
-                q.text(","); q.breakable()
-                q.text("priority = ");
-                q.text("%#x" % self.priority)
-                q.text(","); q.breakable()
-                q.text("buffer_id = ");
-                q.text("%#x" % self.buffer_id)
-                q.text(","); q.breakable()
-                q.text("out_port = ");
-                q.text(util.pretty_port(self.out_port))
-                q.text(","); q.breakable()
-                q.text("out_group = ");
-                q.text("%#x" % self.out_group)
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-                q.text(","); q.breakable()
-                q.text("instructions = ");
-                q.pp(self.instructions)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[14] = flow_mod
-
-class flow_add(flow_mod):
-    version = 2
-    type = 14
-    _command = 0
-
-    def __init__(self, xid=None, cookie=None, cookie_mask=None, table_id=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, out_group=None, flags=None, match=None, instructions=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if cookie_mask != None:
-            self.cookie_mask = cookie_mask
-        else:
-            self.cookie_mask = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if idle_timeout != None:
-            self.idle_timeout = idle_timeout
-        else:
-            self.idle_timeout = 0
-        if hard_timeout != None:
-            self.hard_timeout = hard_timeout
-        else:
-            self.hard_timeout = 0
-        if priority != None:
-            self.priority = priority
-        else:
-            self.priority = 0
-        if buffer_id != None:
-            self.buffer_id = buffer_id
-        else:
-            self.buffer_id = 0
-        if out_port != None:
-            self.out_port = out_port
-        else:
-            self.out_port = 0
-        if out_group != None:
-            self.out_group = out_group
-        else:
-            self.out_group = 0
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        if instructions != None:
-            self.instructions = instructions
-        else:
-            self.instructions = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(struct.pack("!Q", self.cookie_mask))
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append(util.pack_fm_cmd(self._command))
-        packed.append(struct.pack("!H", self.idle_timeout))
-        packed.append(struct.pack("!H", self.hard_timeout))
-        packed.append(struct.pack("!H", self.priority))
-        packed.append(struct.pack("!L", self.buffer_id))
-        packed.append(util.pack_port_no(self.out_port))
-        packed.append(struct.pack("!L", self.out_group))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 2)
-        packed.append(self.match.pack())
-        packed.append(loxi.generic_util.pack_list(self.instructions))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_add()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 14)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.cookie = reader.read("!Q")[0]
-        obj.cookie_mask = reader.read("!Q")[0]
-        obj.table_id = reader.read("!B")[0]
-        __command = util.unpack_fm_cmd(reader)
-        assert(__command == 0)
-        obj.idle_timeout = reader.read("!H")[0]
-        obj.hard_timeout = reader.read("!H")[0]
-        obj.priority = reader.read("!H")[0]
-        obj.buffer_id = reader.read("!L")[0]
-        obj.out_port = util.unpack_port_no(reader)
-        obj.out_group = reader.read("!L")[0]
-        obj.flags = reader.read("!H")[0]
-        reader.skip(2)
-        obj.match = ofp.match.unpack(reader)
-        obj.instructions = loxi.generic_util.unpack_list(reader, ofp.instruction.instruction.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.cookie != other.cookie: return False
-        if self.cookie_mask != other.cookie_mask: return False
-        if self.table_id != other.table_id: return False
-        if self.idle_timeout != other.idle_timeout: return False
-        if self.hard_timeout != other.hard_timeout: return False
-        if self.priority != other.priority: return False
-        if self.buffer_id != other.buffer_id: return False
-        if self.out_port != other.out_port: return False
-        if self.out_group != other.out_group: return False
-        if self.flags != other.flags: return False
-        if self.match != other.match: return False
-        if self.instructions != other.instructions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_add {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("cookie_mask = ");
-                q.text("%#x" % self.cookie_mask)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("idle_timeout = ");
-                q.text("%#x" % self.idle_timeout)
-                q.text(","); q.breakable()
-                q.text("hard_timeout = ");
-                q.text("%#x" % self.hard_timeout)
-                q.text(","); q.breakable()
-                q.text("priority = ");
-                q.text("%#x" % self.priority)
-                q.text(","); q.breakable()
-                q.text("buffer_id = ");
-                q.text("%#x" % self.buffer_id)
-                q.text(","); q.breakable()
-                q.text("out_port = ");
-                q.text(util.pretty_port(self.out_port))
-                q.text(","); q.breakable()
-                q.text("out_group = ");
-                q.text("%#x" % self.out_group)
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-                q.text(","); q.breakable()
-                q.text("instructions = ");
-                q.pp(self.instructions)
-            q.breakable()
-        q.text('}')
-
-flow_mod.subtypes[0] = flow_add
-
-class flow_delete(flow_mod):
-    version = 2
-    type = 14
-    _command = 3
-
-    def __init__(self, xid=None, cookie=None, cookie_mask=None, table_id=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, out_group=None, flags=None, match=None, instructions=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if cookie_mask != None:
-            self.cookie_mask = cookie_mask
-        else:
-            self.cookie_mask = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if idle_timeout != None:
-            self.idle_timeout = idle_timeout
-        else:
-            self.idle_timeout = 0
-        if hard_timeout != None:
-            self.hard_timeout = hard_timeout
-        else:
-            self.hard_timeout = 0
-        if priority != None:
-            self.priority = priority
-        else:
-            self.priority = 0
-        if buffer_id != None:
-            self.buffer_id = buffer_id
-        else:
-            self.buffer_id = 0
-        if out_port != None:
-            self.out_port = out_port
-        else:
-            self.out_port = 0
-        if out_group != None:
-            self.out_group = out_group
-        else:
-            self.out_group = 0
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        if instructions != None:
-            self.instructions = instructions
-        else:
-            self.instructions = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(struct.pack("!Q", self.cookie_mask))
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append(util.pack_fm_cmd(self._command))
-        packed.append(struct.pack("!H", self.idle_timeout))
-        packed.append(struct.pack("!H", self.hard_timeout))
-        packed.append(struct.pack("!H", self.priority))
-        packed.append(struct.pack("!L", self.buffer_id))
-        packed.append(util.pack_port_no(self.out_port))
-        packed.append(struct.pack("!L", self.out_group))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 2)
-        packed.append(self.match.pack())
-        packed.append(loxi.generic_util.pack_list(self.instructions))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_delete()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 14)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.cookie = reader.read("!Q")[0]
-        obj.cookie_mask = reader.read("!Q")[0]
-        obj.table_id = reader.read("!B")[0]
-        __command = util.unpack_fm_cmd(reader)
-        assert(__command == 3)
-        obj.idle_timeout = reader.read("!H")[0]
-        obj.hard_timeout = reader.read("!H")[0]
-        obj.priority = reader.read("!H")[0]
-        obj.buffer_id = reader.read("!L")[0]
-        obj.out_port = util.unpack_port_no(reader)
-        obj.out_group = reader.read("!L")[0]
-        obj.flags = reader.read("!H")[0]
-        reader.skip(2)
-        obj.match = ofp.match.unpack(reader)
-        obj.instructions = loxi.generic_util.unpack_list(reader, ofp.instruction.instruction.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.cookie != other.cookie: return False
-        if self.cookie_mask != other.cookie_mask: return False
-        if self.table_id != other.table_id: return False
-        if self.idle_timeout != other.idle_timeout: return False
-        if self.hard_timeout != other.hard_timeout: return False
-        if self.priority != other.priority: return False
-        if self.buffer_id != other.buffer_id: return False
-        if self.out_port != other.out_port: return False
-        if self.out_group != other.out_group: return False
-        if self.flags != other.flags: return False
-        if self.match != other.match: return False
-        if self.instructions != other.instructions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_delete {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("cookie_mask = ");
-                q.text("%#x" % self.cookie_mask)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("idle_timeout = ");
-                q.text("%#x" % self.idle_timeout)
-                q.text(","); q.breakable()
-                q.text("hard_timeout = ");
-                q.text("%#x" % self.hard_timeout)
-                q.text(","); q.breakable()
-                q.text("priority = ");
-                q.text("%#x" % self.priority)
-                q.text(","); q.breakable()
-                q.text("buffer_id = ");
-                q.text("%#x" % self.buffer_id)
-                q.text(","); q.breakable()
-                q.text("out_port = ");
-                q.text(util.pretty_port(self.out_port))
-                q.text(","); q.breakable()
-                q.text("out_group = ");
-                q.text("%#x" % self.out_group)
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-                q.text(","); q.breakable()
-                q.text("instructions = ");
-                q.pp(self.instructions)
-            q.breakable()
-        q.text('}')
-
-flow_mod.subtypes[3] = flow_delete
-
-class flow_delete_strict(flow_mod):
-    version = 2
-    type = 14
-    _command = 4
-
-    def __init__(self, xid=None, cookie=None, cookie_mask=None, table_id=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, out_group=None, flags=None, match=None, instructions=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if cookie_mask != None:
-            self.cookie_mask = cookie_mask
-        else:
-            self.cookie_mask = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if idle_timeout != None:
-            self.idle_timeout = idle_timeout
-        else:
-            self.idle_timeout = 0
-        if hard_timeout != None:
-            self.hard_timeout = hard_timeout
-        else:
-            self.hard_timeout = 0
-        if priority != None:
-            self.priority = priority
-        else:
-            self.priority = 0
-        if buffer_id != None:
-            self.buffer_id = buffer_id
-        else:
-            self.buffer_id = 0
-        if out_port != None:
-            self.out_port = out_port
-        else:
-            self.out_port = 0
-        if out_group != None:
-            self.out_group = out_group
-        else:
-            self.out_group = 0
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        if instructions != None:
-            self.instructions = instructions
-        else:
-            self.instructions = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(struct.pack("!Q", self.cookie_mask))
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append(util.pack_fm_cmd(self._command))
-        packed.append(struct.pack("!H", self.idle_timeout))
-        packed.append(struct.pack("!H", self.hard_timeout))
-        packed.append(struct.pack("!H", self.priority))
-        packed.append(struct.pack("!L", self.buffer_id))
-        packed.append(util.pack_port_no(self.out_port))
-        packed.append(struct.pack("!L", self.out_group))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 2)
-        packed.append(self.match.pack())
-        packed.append(loxi.generic_util.pack_list(self.instructions))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_delete_strict()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 14)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.cookie = reader.read("!Q")[0]
-        obj.cookie_mask = reader.read("!Q")[0]
-        obj.table_id = reader.read("!B")[0]
-        __command = util.unpack_fm_cmd(reader)
-        assert(__command == 4)
-        obj.idle_timeout = reader.read("!H")[0]
-        obj.hard_timeout = reader.read("!H")[0]
-        obj.priority = reader.read("!H")[0]
-        obj.buffer_id = reader.read("!L")[0]
-        obj.out_port = util.unpack_port_no(reader)
-        obj.out_group = reader.read("!L")[0]
-        obj.flags = reader.read("!H")[0]
-        reader.skip(2)
-        obj.match = ofp.match.unpack(reader)
-        obj.instructions = loxi.generic_util.unpack_list(reader, ofp.instruction.instruction.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.cookie != other.cookie: return False
-        if self.cookie_mask != other.cookie_mask: return False
-        if self.table_id != other.table_id: return False
-        if self.idle_timeout != other.idle_timeout: return False
-        if self.hard_timeout != other.hard_timeout: return False
-        if self.priority != other.priority: return False
-        if self.buffer_id != other.buffer_id: return False
-        if self.out_port != other.out_port: return False
-        if self.out_group != other.out_group: return False
-        if self.flags != other.flags: return False
-        if self.match != other.match: return False
-        if self.instructions != other.instructions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_delete_strict {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("cookie_mask = ");
-                q.text("%#x" % self.cookie_mask)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("idle_timeout = ");
-                q.text("%#x" % self.idle_timeout)
-                q.text(","); q.breakable()
-                q.text("hard_timeout = ");
-                q.text("%#x" % self.hard_timeout)
-                q.text(","); q.breakable()
-                q.text("priority = ");
-                q.text("%#x" % self.priority)
-                q.text(","); q.breakable()
-                q.text("buffer_id = ");
-                q.text("%#x" % self.buffer_id)
-                q.text(","); q.breakable()
-                q.text("out_port = ");
-                q.text(util.pretty_port(self.out_port))
-                q.text(","); q.breakable()
-                q.text("out_group = ");
-                q.text("%#x" % self.out_group)
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-                q.text(","); q.breakable()
-                q.text("instructions = ");
-                q.pp(self.instructions)
-            q.breakable()
-        q.text('}')
-
-flow_mod.subtypes[4] = flow_delete_strict
-
-class flow_mod_failed_error_msg(error_msg):
-    version = 2
-    type = 1
-    err_type = 5
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_mod_failed_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 5)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_mod_failed_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[5] = flow_mod_failed_error_msg
-
-class flow_modify(flow_mod):
-    version = 2
-    type = 14
-    _command = 1
-
-    def __init__(self, xid=None, cookie=None, cookie_mask=None, table_id=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, out_group=None, flags=None, match=None, instructions=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if cookie_mask != None:
-            self.cookie_mask = cookie_mask
-        else:
-            self.cookie_mask = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if idle_timeout != None:
-            self.idle_timeout = idle_timeout
-        else:
-            self.idle_timeout = 0
-        if hard_timeout != None:
-            self.hard_timeout = hard_timeout
-        else:
-            self.hard_timeout = 0
-        if priority != None:
-            self.priority = priority
-        else:
-            self.priority = 0
-        if buffer_id != None:
-            self.buffer_id = buffer_id
-        else:
-            self.buffer_id = 0
-        if out_port != None:
-            self.out_port = out_port
-        else:
-            self.out_port = 0
-        if out_group != None:
-            self.out_group = out_group
-        else:
-            self.out_group = 0
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        if instructions != None:
-            self.instructions = instructions
-        else:
-            self.instructions = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(struct.pack("!Q", self.cookie_mask))
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append(util.pack_fm_cmd(self._command))
-        packed.append(struct.pack("!H", self.idle_timeout))
-        packed.append(struct.pack("!H", self.hard_timeout))
-        packed.append(struct.pack("!H", self.priority))
-        packed.append(struct.pack("!L", self.buffer_id))
-        packed.append(util.pack_port_no(self.out_port))
-        packed.append(struct.pack("!L", self.out_group))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 2)
-        packed.append(self.match.pack())
-        packed.append(loxi.generic_util.pack_list(self.instructions))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_modify()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 14)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.cookie = reader.read("!Q")[0]
-        obj.cookie_mask = reader.read("!Q")[0]
-        obj.table_id = reader.read("!B")[0]
-        __command = util.unpack_fm_cmd(reader)
-        assert(__command == 1)
-        obj.idle_timeout = reader.read("!H")[0]
-        obj.hard_timeout = reader.read("!H")[0]
-        obj.priority = reader.read("!H")[0]
-        obj.buffer_id = reader.read("!L")[0]
-        obj.out_port = util.unpack_port_no(reader)
-        obj.out_group = reader.read("!L")[0]
-        obj.flags = reader.read("!H")[0]
-        reader.skip(2)
-        obj.match = ofp.match.unpack(reader)
-        obj.instructions = loxi.generic_util.unpack_list(reader, ofp.instruction.instruction.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.cookie != other.cookie: return False
-        if self.cookie_mask != other.cookie_mask: return False
-        if self.table_id != other.table_id: return False
-        if self.idle_timeout != other.idle_timeout: return False
-        if self.hard_timeout != other.hard_timeout: return False
-        if self.priority != other.priority: return False
-        if self.buffer_id != other.buffer_id: return False
-        if self.out_port != other.out_port: return False
-        if self.out_group != other.out_group: return False
-        if self.flags != other.flags: return False
-        if self.match != other.match: return False
-        if self.instructions != other.instructions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_modify {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("cookie_mask = ");
-                q.text("%#x" % self.cookie_mask)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("idle_timeout = ");
-                q.text("%#x" % self.idle_timeout)
-                q.text(","); q.breakable()
-                q.text("hard_timeout = ");
-                q.text("%#x" % self.hard_timeout)
-                q.text(","); q.breakable()
-                q.text("priority = ");
-                q.text("%#x" % self.priority)
-                q.text(","); q.breakable()
-                q.text("buffer_id = ");
-                q.text("%#x" % self.buffer_id)
-                q.text(","); q.breakable()
-                q.text("out_port = ");
-                q.text(util.pretty_port(self.out_port))
-                q.text(","); q.breakable()
-                q.text("out_group = ");
-                q.text("%#x" % self.out_group)
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-                q.text(","); q.breakable()
-                q.text("instructions = ");
-                q.pp(self.instructions)
-            q.breakable()
-        q.text('}')
-
-flow_mod.subtypes[1] = flow_modify
-
-class flow_modify_strict(flow_mod):
-    version = 2
-    type = 14
-    _command = 2
-
-    def __init__(self, xid=None, cookie=None, cookie_mask=None, table_id=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, out_group=None, flags=None, match=None, instructions=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if cookie_mask != None:
-            self.cookie_mask = cookie_mask
-        else:
-            self.cookie_mask = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if idle_timeout != None:
-            self.idle_timeout = idle_timeout
-        else:
-            self.idle_timeout = 0
-        if hard_timeout != None:
-            self.hard_timeout = hard_timeout
-        else:
-            self.hard_timeout = 0
-        if priority != None:
-            self.priority = priority
-        else:
-            self.priority = 0
-        if buffer_id != None:
-            self.buffer_id = buffer_id
-        else:
-            self.buffer_id = 0
-        if out_port != None:
-            self.out_port = out_port
-        else:
-            self.out_port = 0
-        if out_group != None:
-            self.out_group = out_group
-        else:
-            self.out_group = 0
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        if instructions != None:
-            self.instructions = instructions
-        else:
-            self.instructions = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(struct.pack("!Q", self.cookie_mask))
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append(util.pack_fm_cmd(self._command))
-        packed.append(struct.pack("!H", self.idle_timeout))
-        packed.append(struct.pack("!H", self.hard_timeout))
-        packed.append(struct.pack("!H", self.priority))
-        packed.append(struct.pack("!L", self.buffer_id))
-        packed.append(util.pack_port_no(self.out_port))
-        packed.append(struct.pack("!L", self.out_group))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 2)
-        packed.append(self.match.pack())
-        packed.append(loxi.generic_util.pack_list(self.instructions))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_modify_strict()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 14)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.cookie = reader.read("!Q")[0]
-        obj.cookie_mask = reader.read("!Q")[0]
-        obj.table_id = reader.read("!B")[0]
-        __command = util.unpack_fm_cmd(reader)
-        assert(__command == 2)
-        obj.idle_timeout = reader.read("!H")[0]
-        obj.hard_timeout = reader.read("!H")[0]
-        obj.priority = reader.read("!H")[0]
-        obj.buffer_id = reader.read("!L")[0]
-        obj.out_port = util.unpack_port_no(reader)
-        obj.out_group = reader.read("!L")[0]
-        obj.flags = reader.read("!H")[0]
-        reader.skip(2)
-        obj.match = ofp.match.unpack(reader)
-        obj.instructions = loxi.generic_util.unpack_list(reader, ofp.instruction.instruction.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.cookie != other.cookie: return False
-        if self.cookie_mask != other.cookie_mask: return False
-        if self.table_id != other.table_id: return False
-        if self.idle_timeout != other.idle_timeout: return False
-        if self.hard_timeout != other.hard_timeout: return False
-        if self.priority != other.priority: return False
-        if self.buffer_id != other.buffer_id: return False
-        if self.out_port != other.out_port: return False
-        if self.out_group != other.out_group: return False
-        if self.flags != other.flags: return False
-        if self.match != other.match: return False
-        if self.instructions != other.instructions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_modify_strict {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("cookie_mask = ");
-                q.text("%#x" % self.cookie_mask)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("idle_timeout = ");
-                q.text("%#x" % self.idle_timeout)
-                q.text(","); q.breakable()
-                q.text("hard_timeout = ");
-                q.text("%#x" % self.hard_timeout)
-                q.text(","); q.breakable()
-                q.text("priority = ");
-                q.text("%#x" % self.priority)
-                q.text(","); q.breakable()
-                q.text("buffer_id = ");
-                q.text("%#x" % self.buffer_id)
-                q.text(","); q.breakable()
-                q.text("out_port = ");
-                q.text(util.pretty_port(self.out_port))
-                q.text(","); q.breakable()
-                q.text("out_group = ");
-                q.text("%#x" % self.out_group)
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-                q.text(","); q.breakable()
-                q.text("instructions = ");
-                q.pp(self.instructions)
-            q.breakable()
-        q.text('}')
-
-flow_mod.subtypes[2] = flow_modify_strict
-
-class flow_removed(message):
-    version = 2
-    type = 11
-
-    def __init__(self, xid=None, cookie=None, priority=None, reason=None, table_id=None, duration_sec=None, duration_nsec=None, idle_timeout=None, packet_count=None, byte_count=None, match=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if priority != None:
-            self.priority = priority
-        else:
-            self.priority = 0
-        if reason != None:
-            self.reason = reason
-        else:
-            self.reason = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if duration_sec != None:
-            self.duration_sec = duration_sec
-        else:
-            self.duration_sec = 0
-        if duration_nsec != None:
-            self.duration_nsec = duration_nsec
-        else:
-            self.duration_nsec = 0
-        if idle_timeout != None:
-            self.idle_timeout = idle_timeout
-        else:
-            self.idle_timeout = 0
-        if packet_count != None:
-            self.packet_count = packet_count
-        else:
-            self.packet_count = 0
-        if byte_count != None:
-            self.byte_count = byte_count
-        else:
-            self.byte_count = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(struct.pack("!H", self.priority))
-        packed.append(struct.pack("!B", self.reason))
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append(struct.pack("!L", self.duration_sec))
-        packed.append(struct.pack("!L", self.duration_nsec))
-        packed.append(struct.pack("!H", self.idle_timeout))
-        packed.append('\x00' * 2)
-        packed.append(struct.pack("!Q", self.packet_count))
-        packed.append(struct.pack("!Q", self.byte_count))
-        packed.append(self.match.pack())
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_removed()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 11)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.cookie = reader.read("!Q")[0]
-        obj.priority = reader.read("!H")[0]
-        obj.reason = reader.read("!B")[0]
-        obj.table_id = reader.read("!B")[0]
-        obj.duration_sec = reader.read("!L")[0]
-        obj.duration_nsec = reader.read("!L")[0]
-        obj.idle_timeout = reader.read("!H")[0]
-        reader.skip(2)
-        obj.packet_count = reader.read("!Q")[0]
-        obj.byte_count = reader.read("!Q")[0]
-        obj.match = ofp.match.unpack(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.cookie != other.cookie: return False
-        if self.priority != other.priority: return False
-        if self.reason != other.reason: return False
-        if self.table_id != other.table_id: return False
-        if self.duration_sec != other.duration_sec: return False
-        if self.duration_nsec != other.duration_nsec: return False
-        if self.idle_timeout != other.idle_timeout: return False
-        if self.packet_count != other.packet_count: return False
-        if self.byte_count != other.byte_count: return False
-        if self.match != other.match: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_removed {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("priority = ");
-                q.text("%#x" % self.priority)
-                q.text(","); q.breakable()
-                q.text("reason = ");
-                q.text("%#x" % self.reason)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("duration_sec = ");
-                q.text("%#x" % self.duration_sec)
-                q.text(","); q.breakable()
-                q.text("duration_nsec = ");
-                q.text("%#x" % self.duration_nsec)
-                q.text(","); q.breakable()
-                q.text("idle_timeout = ");
-                q.text("%#x" % self.idle_timeout)
-                q.text(","); q.breakable()
-                q.text("packet_count = ");
-                q.text("%#x" % self.packet_count)
-                q.text(","); q.breakable()
-                q.text("byte_count = ");
-                q.text("%#x" % self.byte_count)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[11] = flow_removed
-
-class flow_stats_reply(stats_reply):
-    version = 2
-    type = 19
-    stats_type = 1
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 1)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.flow_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[1] = flow_stats_reply
-
-class flow_stats_request(stats_request):
-    version = 2
-    type = 18
-    stats_type = 1
-
-    def __init__(self, xid=None, flags=None, table_id=None, out_port=None, out_group=None, cookie=None, cookie_mask=None, match=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if out_port != None:
-            self.out_port = out_port
-        else:
-            self.out_port = 0
-        if out_group != None:
-            self.out_group = out_group
-        else:
-            self.out_group = 0
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if cookie_mask != None:
-            self.cookie_mask = cookie_mask
-        else:
-            self.cookie_mask = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append('\x00' * 3)
-        packed.append(util.pack_port_no(self.out_port))
-        packed.append(struct.pack("!L", self.out_group))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(struct.pack("!Q", self.cookie_mask))
-        packed.append(self.match.pack())
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 1)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.table_id = reader.read("!B")[0]
-        reader.skip(3)
-        obj.out_port = util.unpack_port_no(reader)
-        obj.out_group = reader.read("!L")[0]
-        reader.skip(4)
-        obj.cookie = reader.read("!Q")[0]
-        obj.cookie_mask = reader.read("!Q")[0]
-        obj.match = ofp.match.unpack(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.table_id != other.table_id: return False
-        if self.out_port != other.out_port: return False
-        if self.out_group != other.out_group: return False
-        if self.cookie != other.cookie: return False
-        if self.cookie_mask != other.cookie_mask: return False
-        if self.match != other.match: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("out_port = ");
-                q.text(util.pretty_port(self.out_port))
-                q.text(","); q.breakable()
-                q.text("out_group = ");
-                q.text("%#x" % self.out_group)
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("cookie_mask = ");
-                q.text("%#x" % self.cookie_mask)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[1] = flow_stats_request
-
-class get_config_reply(message):
-    version = 2
-    type = 8
-
-    def __init__(self, xid=None, flags=None, miss_send_len=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if miss_send_len != None:
-            self.miss_send_len = miss_send_len
-        else:
-            self.miss_send_len = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append(struct.pack("!H", self.miss_send_len))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = get_config_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 8)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.flags = reader.read("!H")[0]
-        obj.miss_send_len = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.miss_send_len != other.miss_send_len: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("get_config_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("miss_send_len = ");
-                q.text("%#x" % self.miss_send_len)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[8] = get_config_reply
-
-class get_config_request(message):
-    version = 2
-    type = 7
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = get_config_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 7)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("get_config_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-message.subtypes[7] = get_config_request
-
-class group_mod(message):
-    subtypes = {}
-
-    version = 2
-    type = 15
-
-    def __init__(self, xid=None, command=None, group_type=None, group_id=None, buckets=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if command != None:
-            self.command = command
-        else:
-            self.command = 0
-        if group_type != None:
-            self.group_type = group_type
-        else:
-            self.group_type = 0
-        if group_id != None:
-            self.group_id = group_id
-        else:
-            self.group_id = 0
-        if buckets != None:
-            self.buckets = buckets
-        else:
-            self.buckets = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.command))
-        packed.append(struct.pack("!B", self.group_type))
-        packed.append('\x00' * 1)
-        packed.append(struct.pack("!L", self.group_id))
-        packed.append(loxi.generic_util.pack_list(self.buckets))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 8)
-        subclass = group_mod.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = group_mod()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 15)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.command = reader.read("!H")[0]
-        obj.group_type = reader.read("!B")[0]
-        reader.skip(1)
-        obj.group_id = reader.read("!L")[0]
-        obj.buckets = loxi.generic_util.unpack_list(reader, ofp.common.bucket.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.command != other.command: return False
-        if self.group_type != other.group_type: return False
-        if self.group_id != other.group_id: return False
-        if self.buckets != other.buckets: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_mod {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("group_type = ");
-                q.text("%#x" % self.group_type)
-                q.text(","); q.breakable()
-                q.text("group_id = ");
-                q.text("%#x" % self.group_id)
-                q.text(","); q.breakable()
-                q.text("buckets = ");
-                q.pp(self.buckets)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[15] = group_mod
-
-class group_add(group_mod):
-    version = 2
-    type = 15
-    command = 0
-
-    def __init__(self, xid=None, group_type=None, group_id=None, buckets=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if group_type != None:
-            self.group_type = group_type
-        else:
-            self.group_type = 0
-        if group_id != None:
-            self.group_id = group_id
-        else:
-            self.group_id = 0
-        if buckets != None:
-            self.buckets = buckets
-        else:
-            self.buckets = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.command))
-        packed.append(struct.pack("!B", self.group_type))
-        packed.append('\x00' * 1)
-        packed.append(struct.pack("!L", self.group_id))
-        packed.append(loxi.generic_util.pack_list(self.buckets))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group_add()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 15)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _command = reader.read("!H")[0]
-        assert(_command == 0)
-        obj.group_type = reader.read("!B")[0]
-        reader.skip(1)
-        obj.group_id = reader.read("!L")[0]
-        obj.buckets = loxi.generic_util.unpack_list(reader, ofp.common.bucket.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.group_type != other.group_type: return False
-        if self.group_id != other.group_id: return False
-        if self.buckets != other.buckets: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_add {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("group_type = ");
-                q.text("%#x" % self.group_type)
-                q.text(","); q.breakable()
-                q.text("group_id = ");
-                q.text("%#x" % self.group_id)
-                q.text(","); q.breakable()
-                q.text("buckets = ");
-                q.pp(self.buckets)
-            q.breakable()
-        q.text('}')
-
-group_mod.subtypes[0] = group_add
-
-class group_delete(group_mod):
-    version = 2
-    type = 15
-    command = 2
-
-    def __init__(self, xid=None, group_type=None, group_id=None, buckets=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if group_type != None:
-            self.group_type = group_type
-        else:
-            self.group_type = 0
-        if group_id != None:
-            self.group_id = group_id
-        else:
-            self.group_id = 0
-        if buckets != None:
-            self.buckets = buckets
-        else:
-            self.buckets = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.command))
-        packed.append(struct.pack("!B", self.group_type))
-        packed.append('\x00' * 1)
-        packed.append(struct.pack("!L", self.group_id))
-        packed.append(loxi.generic_util.pack_list(self.buckets))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group_delete()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 15)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _command = reader.read("!H")[0]
-        assert(_command == 2)
-        obj.group_type = reader.read("!B")[0]
-        reader.skip(1)
-        obj.group_id = reader.read("!L")[0]
-        obj.buckets = loxi.generic_util.unpack_list(reader, ofp.common.bucket.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.group_type != other.group_type: return False
-        if self.group_id != other.group_id: return False
-        if self.buckets != other.buckets: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_delete {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("group_type = ");
-                q.text("%#x" % self.group_type)
-                q.text(","); q.breakable()
-                q.text("group_id = ");
-                q.text("%#x" % self.group_id)
-                q.text(","); q.breakable()
-                q.text("buckets = ");
-                q.pp(self.buckets)
-            q.breakable()
-        q.text('}')
-
-group_mod.subtypes[2] = group_delete
-
-class group_desc_stats_reply(stats_reply):
-    version = 2
-    type = 19
-    stats_type = 7
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group_desc_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 7)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.group_desc_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_desc_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[7] = group_desc_stats_reply
-
-class group_desc_stats_request(stats_request):
-    version = 2
-    type = 18
-    stats_type = 7
-
-    def __init__(self, xid=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group_desc_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 7)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_desc_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[7] = group_desc_stats_request
-
-class group_mod_failed_error_msg(error_msg):
-    version = 2
-    type = 1
-    err_type = 6
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group_mod_failed_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 6)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_mod_failed_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[6] = group_mod_failed_error_msg
-
-class group_modify(group_mod):
-    version = 2
-    type = 15
-    command = 1
-
-    def __init__(self, xid=None, group_type=None, group_id=None, buckets=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if group_type != None:
-            self.group_type = group_type
-        else:
-            self.group_type = 0
-        if group_id != None:
-            self.group_id = group_id
-        else:
-            self.group_id = 0
-        if buckets != None:
-            self.buckets = buckets
-        else:
-            self.buckets = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.command))
-        packed.append(struct.pack("!B", self.group_type))
-        packed.append('\x00' * 1)
-        packed.append(struct.pack("!L", self.group_id))
-        packed.append(loxi.generic_util.pack_list(self.buckets))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group_modify()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 15)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _command = reader.read("!H")[0]
-        assert(_command == 1)
-        obj.group_type = reader.read("!B")[0]
-        reader.skip(1)
-        obj.group_id = reader.read("!L")[0]
-        obj.buckets = loxi.generic_util.unpack_list(reader, ofp.common.bucket.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.group_type != other.group_type: return False
-        if self.group_id != other.group_id: return False
-        if self.buckets != other.buckets: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_modify {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("group_type = ");
-                q.text("%#x" % self.group_type)
-                q.text(","); q.breakable()
-                q.text("group_id = ");
-                q.text("%#x" % self.group_id)
-                q.text(","); q.breakable()
-                q.text("buckets = ");
-                q.pp(self.buckets)
-            q.breakable()
-        q.text('}')
-
-group_mod.subtypes[1] = group_modify
-
-class group_stats_reply(stats_reply):
-    version = 2
-    type = 19
-    stats_type = 6
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 6)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.group_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[6] = group_stats_reply
-
-class group_stats_request(stats_request):
-    version = 2
-    type = 18
-    stats_type = 6
-
-    def __init__(self, xid=None, flags=None, group_id=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if group_id != None:
-            self.group_id = group_id
-        else:
-            self.group_id = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.group_id))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 6)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.group_id = reader.read("!L")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.group_id != other.group_id: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("group_id = ");
-                q.text("%#x" % self.group_id)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[6] = group_stats_request
-
-class hello(message):
-    version = 2
-    type = 0
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = hello()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 0)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("hello {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-message.subtypes[0] = hello
-
-class hello_failed_error_msg(error_msg):
-    version = 2
-    type = 1
-    err_type = 0
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = hello_failed_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 0)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("hello_failed_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[0] = hello_failed_error_msg
-
-class nicira_header(experimenter):
-    subtypes = {}
-
-    version = 2
-    type = 4
-    experimenter = 8992
-
-    def __init__(self, xid=None, subtype=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 12)
-        subclass = nicira_header.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = nicira_header()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 8992)
-        obj.subtype = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.subtype != other.subtype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("nicira_header {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-experimenter.subtypes[8992] = nicira_header
-
-class packet_in(message):
-    version = 2
-    type = 10
-
-    def __init__(self, xid=None, buffer_id=None, in_port=None, in_phy_port=None, total_len=None, reason=None, table_id=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if buffer_id != None:
-            self.buffer_id = buffer_id
-        else:
-            self.buffer_id = 0
-        if in_port != None:
-            self.in_port = in_port
-        else:
-            self.in_port = 0
-        if in_phy_port != None:
-            self.in_phy_port = in_phy_port
-        else:
-            self.in_phy_port = 0
-        if total_len != None:
-            self.total_len = total_len
-        else:
-            self.total_len = 0
-        if reason != None:
-            self.reason = reason
-        else:
-            self.reason = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.buffer_id))
-        packed.append(util.pack_port_no(self.in_port))
-        packed.append(util.pack_port_no(self.in_phy_port))
-        packed.append(struct.pack("!H", self.total_len))
-        packed.append(struct.pack("!B", self.reason))
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = packet_in()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 10)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.buffer_id = reader.read("!L")[0]
-        obj.in_port = util.unpack_port_no(reader)
-        obj.in_phy_port = util.unpack_port_no(reader)
-        obj.total_len = reader.read("!H")[0]
-        obj.reason = reader.read("!B")[0]
-        obj.table_id = reader.read("!B")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.buffer_id != other.buffer_id: return False
-        if self.in_port != other.in_port: return False
-        if self.in_phy_port != other.in_phy_port: return False
-        if self.total_len != other.total_len: return False
-        if self.reason != other.reason: return False
-        if self.table_id != other.table_id: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("packet_in {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("buffer_id = ");
-                q.text("%#x" % self.buffer_id)
-                q.text(","); q.breakable()
-                q.text("in_port = ");
-                q.text(util.pretty_port(self.in_port))
-                q.text(","); q.breakable()
-                q.text("in_phy_port = ");
-                q.text(util.pretty_port(self.in_phy_port))
-                q.text(","); q.breakable()
-                q.text("total_len = ");
-                q.text("%#x" % self.total_len)
-                q.text(","); q.breakable()
-                q.text("reason = ");
-                q.text("%#x" % self.reason)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[10] = packet_in
-
-class packet_out(message):
-    version = 2
-    type = 13
-
-    def __init__(self, xid=None, buffer_id=None, in_port=None, actions=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if buffer_id != None:
-            self.buffer_id = buffer_id
-        else:
-            self.buffer_id = 0
-        if in_port != None:
-            self.in_port = in_port
-        else:
-            self.in_port = 0
-        if actions != None:
-            self.actions = actions
-        else:
-            self.actions = []
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.buffer_id))
-        packed.append(util.pack_port_no(self.in_port))
-        packed.append(struct.pack("!H", 0)) # placeholder for actions_len at index 6
-        packed.append('\x00' * 6)
-        packed.append(loxi.generic_util.pack_list(self.actions))
-        packed[6] = struct.pack("!H", len(packed[-1]))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = packet_out()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 13)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.buffer_id = reader.read("!L")[0]
-        obj.in_port = util.unpack_port_no(reader)
-        _actions_len = reader.read("!H")[0]
-        reader.skip(6)
-        obj.actions = loxi.generic_util.unpack_list(reader.slice(_actions_len), ofp.action.action.unpack)
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.buffer_id != other.buffer_id: return False
-        if self.in_port != other.in_port: return False
-        if self.actions != other.actions: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("packet_out {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("buffer_id = ");
-                q.text("%#x" % self.buffer_id)
-                q.text(","); q.breakable()
-                q.text("in_port = ");
-                q.text(util.pretty_port(self.in_port))
-                q.text(","); q.breakable()
-                q.text("actions = ");
-                q.pp(self.actions)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[13] = packet_out
-
-class port_mod(message):
-    version = 2
-    type = 16
-
-    def __init__(self, xid=None, port_no=None, hw_addr=None, config=None, mask=None, advertise=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if hw_addr != None:
-            self.hw_addr = hw_addr
-        else:
-            self.hw_addr = [0,0,0,0,0,0]
-        if config != None:
-            self.config = config
-        else:
-            self.config = 0
-        if mask != None:
-            self.mask = mask
-        else:
-            self.mask = 0
-        if advertise != None:
-            self.advertise = advertise
-        else:
-            self.advertise = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!6B", *self.hw_addr))
-        packed.append('\x00' * 2)
-        packed.append(struct.pack("!L", self.config))
-        packed.append(struct.pack("!L", self.mask))
-        packed.append(struct.pack("!L", self.advertise))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = port_mod()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 16)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.port_no = util.unpack_port_no(reader)
-        reader.skip(4)
-        obj.hw_addr = list(reader.read('!6B'))
-        reader.skip(2)
-        obj.config = reader.read("!L")[0]
-        obj.mask = reader.read("!L")[0]
-        obj.advertise = reader.read("!L")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.port_no != other.port_no: return False
-        if self.hw_addr != other.hw_addr: return False
-        if self.config != other.config: return False
-        if self.mask != other.mask: return False
-        if self.advertise != other.advertise: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port_mod {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("hw_addr = ");
-                q.text(util.pretty_mac(self.hw_addr))
-                q.text(","); q.breakable()
-                q.text("config = ");
-                q.text("%#x" % self.config)
-                q.text(","); q.breakable()
-                q.text("mask = ");
-                q.text("%#x" % self.mask)
-                q.text(","); q.breakable()
-                q.text("advertise = ");
-                q.text("%#x" % self.advertise)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[16] = port_mod
-
-class port_mod_failed_error_msg(error_msg):
-    version = 2
-    type = 1
-    err_type = 7
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = port_mod_failed_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 7)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port_mod_failed_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[7] = port_mod_failed_error_msg
-
-class port_stats_reply(stats_reply):
-    version = 2
-    type = 19
-    stats_type = 4
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = port_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 4)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.port_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[4] = port_stats_reply
-
-class port_stats_request(stats_request):
-    version = 2
-    type = 18
-    stats_type = 4
-
-    def __init__(self, xid=None, flags=None, port_no=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = port_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 4)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.port_no = util.unpack_port_no(reader)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.port_no != other.port_no: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[4] = port_stats_request
-
-class port_status(message):
-    version = 2
-    type = 12
-
-    def __init__(self, xid=None, reason=None, desc=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if reason != None:
-            self.reason = reason
-        else:
-            self.reason = 0
-        if desc != None:
-            self.desc = desc
-        else:
-            self.desc = ofp.port_desc()
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!B", self.reason))
-        packed.append('\x00' * 7)
-        packed.append(self.desc.pack())
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = port_status()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 12)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.reason = reader.read("!B")[0]
-        reader.skip(7)
-        obj.desc = ofp.port_desc.unpack(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.reason != other.reason: return False
-        if self.desc != other.desc: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port_status {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("reason = ");
-                q.text("%#x" % self.reason)
-                q.text(","); q.breakable()
-                q.text("desc = ");
-                q.pp(self.desc)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[12] = port_status
-
-class queue_get_config_reply(message):
-    version = 2
-    type = 23
-
-    def __init__(self, xid=None, port=None, queues=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if port != None:
-            self.port = port
-        else:
-            self.port = 0
-        if queues != None:
-            self.queues = queues
-        else:
-            self.queues = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(util.pack_port_no(self.port))
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.queues))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = queue_get_config_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 23)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.port = util.unpack_port_no(reader)
-        reader.skip(4)
-        obj.queues = loxi.generic_util.unpack_list(reader, ofp.common.packet_queue.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.port != other.port: return False
-        if self.queues != other.queues: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_get_config_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("port = ");
-                q.text(util.pretty_port(self.port))
-                q.text(","); q.breakable()
-                q.text("queues = ");
-                q.pp(self.queues)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[23] = queue_get_config_reply
-
-class queue_get_config_request(message):
-    version = 2
-    type = 22
-
-    def __init__(self, xid=None, port=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if port != None:
-            self.port = port
-        else:
-            self.port = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(util.pack_port_no(self.port))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = queue_get_config_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 22)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.port = util.unpack_port_no(reader)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.port != other.port: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_get_config_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("port = ");
-                q.text(util.pretty_port(self.port))
-            q.breakable()
-        q.text('}')
-
-message.subtypes[22] = queue_get_config_request
-
-class queue_op_failed_error_msg(error_msg):
-    version = 2
-    type = 1
-    err_type = 9
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = queue_op_failed_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 9)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_op_failed_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[9] = queue_op_failed_error_msg
-
-class queue_stats_reply(stats_reply):
-    version = 2
-    type = 19
-    stats_type = 5
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = queue_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 5)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.queue_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[5] = queue_stats_reply
-
-class queue_stats_request(stats_request):
-    version = 2
-    type = 18
-    stats_type = 5
-
-    def __init__(self, xid=None, flags=None, port_no=None, queue_id=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if queue_id != None:
-            self.queue_id = queue_id
-        else:
-            self.queue_id = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(struct.pack("!L", self.queue_id))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = queue_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 5)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.port_no = util.unpack_port_no(reader)
-        obj.queue_id = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.port_no != other.port_no: return False
-        if self.queue_id != other.queue_id: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("queue_id = ");
-                q.text("%#x" % self.queue_id)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[5] = queue_stats_request
-
-class set_config(message):
-    version = 2
-    type = 9
-
-    def __init__(self, xid=None, flags=None, miss_send_len=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if miss_send_len != None:
-            self.miss_send_len = miss_send_len
-        else:
-            self.miss_send_len = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append(struct.pack("!H", self.miss_send_len))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_config()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 9)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.flags = reader.read("!H")[0]
-        obj.miss_send_len = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.miss_send_len != other.miss_send_len: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_config {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("miss_send_len = ");
-                q.text("%#x" % self.miss_send_len)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[9] = set_config
-
-class switch_config_failed_error_msg(error_msg):
-    version = 2
-    type = 1
-    err_type = 10
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = switch_config_failed_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 10)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("switch_config_failed_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[10] = switch_config_failed_error_msg
-
-class table_mod(message):
-    version = 2
-    type = 17
-
-    def __init__(self, xid=None, table_id=None, config=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if config != None:
-            self.config = config
-        else:
-            self.config = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append('\x00' * 3)
-        packed.append(struct.pack("!L", self.config))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_mod()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 17)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.table_id = reader.read("!B")[0]
-        reader.skip(3)
-        obj.config = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.table_id != other.table_id: return False
-        if self.config != other.config: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_mod {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("config = ");
-                q.text("%#x" % self.config)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[17] = table_mod
-
-class table_mod_failed_error_msg(error_msg):
-    version = 2
-    type = 1
-    err_type = 8
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_mod_failed_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 8)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_mod_failed_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[8] = table_mod_failed_error_msg
-
-class table_stats_reply(stats_reply):
-    version = 2
-    type = 19
-    stats_type = 3
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 3)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.table_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[3] = table_stats_reply
-
-class table_stats_request(stats_request):
-    version = 2
-    type = 18
-    stats_type = 3
-
-    def __init__(self, xid=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 2)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 3)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[3] = table_stats_request
-
-
-def parse_header(buf):
-    if len(buf) < 8:
-        raise loxi.ProtocolError("too short to be an OpenFlow message")
-    return struct.unpack_from("!BBHL", buf)
-
-def parse_message(buf):
-    msg_ver, msg_type, msg_len, msg_xid = parse_header(buf)
-    if msg_ver != ofp.OFP_VERSION and msg_type != ofp.OFPT_HELLO:
-        raise loxi.ProtocolError("wrong OpenFlow version (expected %d, got %d)" % (ofp.OFP_VERSION, msg_ver))
-    if len(buf) != msg_len:
-        raise loxi.ProtocolError("incorrect message size")
-    return message.unpack(loxi.generic_util.OFReader(buf))
diff --git a/python/ofagent/loxi/of11/util.py b/python/ofagent/loxi/of11/util.py
deleted file mode 100644
index f5dd743..0000000
--- a/python/ofagent/loxi/of11/util.py
+++ /dev/null
@@ -1,140 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-# Automatically generated by LOXI from template util.py
-# Do not modify
-
-import struct
-import loxi
-import const
-import common
-import action
-import instruction
-
-def pretty_mac(mac):
-    return ':'.join(["%02x" % x for x in mac])
-
-def pretty_ipv4(v):
-    return "%d.%d.%d.%d" % ((v >> 24) & 0xFF, (v >> 16) & 0xFF, (v >> 8) & 0xFF, v & 0xFF)
-
-def pretty_flags(v, flag_names):
-    set_flags = []
-    for flag_name in flag_names:
-        flag_value = getattr(const, flag_name)
-        if v & flag_value == flag_value:
-            set_flags.append(flag_name)
-        elif v & flag_value:
-            set_flags.append('%s&%#x' % (flag_name, v & flag_value))
-        v &= ~flag_value
-    if v:
-        set_flags.append("%#x" % v)
-    return '|'.join(set_flags) or '0'
-
-def pretty_wildcards(v):
-    if v == const.OFPFW_ALL:
-        return 'OFPFW_ALL'
-    flag_names = ['OFPFW_IN_PORT', 'OFPFW_DL_VLAN', 'OFPFW_DL_SRC', 'OFPFW_DL_DST',
-                  'OFPFW_DL_TYPE', 'OFPFW_NW_PROTO', 'OFPFW_TP_SRC', 'OFPFW_TP_DST',
-                  'OFPFW_NW_SRC_MASK', 'OFPFW_NW_DST_MASK', 'OFPFW_DL_VLAN_PCP',
-                  'OFPFW_NW_TOS']
-    return pretty_flags(v, flag_names)
-
-def pretty_port(v):
-    named_ports = [(k,v2) for (k,v2) in const.__dict__.iteritems() if k.startswith('OFPP_')]
-    for (k, v2) in named_ports:
-        if v == v2:
-            return k
-    return v
-
-def pack_port_no(value):
-    return struct.pack("!L", value)
-
-def unpack_port_no(reader):
-    return reader.read("!L")[0]
-
-def pack_fm_cmd(value):
-    return struct.pack("!B", value)
-
-def unpack_fm_cmd(reader):
-    return reader.read("!B")[0]
-
-def init_wc_bmap():
-    return const.OFPFW_ALL
-
-def pack_wc_bmap(value):
-    return struct.pack("!L", value)
-
-def unpack_wc_bmap(reader):
-    return reader.read("!L")[0]
-
-def init_match_bmap():
-    return const.OFPFW_ALL
-
-def pack_match_bmap(value):
-    return struct.pack("!L", value)
-
-def unpack_match_bmap(reader):
-    return reader.read("!L")[0]
-
-MASK64 = (1 << 64) - 1
-
-def pack_bitmap_128(value):
-    x = 0l
-    for y in value:
-        x |= 1 << y
-    return struct.pack("!QQ", (x >> 64) & MASK64, x & MASK64)
-
-def unpack_bitmap_128(reader):
-    hi, lo = reader.read("!QQ")
-    x = (hi << 64) | lo
-    i = 0
-    value = set()
-    while x != 0:
-        if x & 1 == 1:
-            value.add(i)
-        i += 1
-        x >>= 1
-    return value
-
-def pack_bitmap_512(value):
-    words = [0] * 8
-    for v in value:
-        assert v < 512
-        words[7-v/64] |= 1 << (v % 64)
-    return struct.pack("!8Q", *words)
-
-def unpack_bitmap_512(reader):
-    words = reader.read("!8Q")
-    x = 0l
-    for word in words:
-        x <<= 64
-        x |= word
-    i = 0
-    value = set()
-    while x != 0:
-        if x & 1 == 1:
-            value.add(i)
-        i += 1
-        x >>= 1
-    return value
-
-def pack_checksum_128(value):
-    return struct.pack("!QQ", (value >> 64) & MASK64, value & MASK64)
-
-def unpack_checksum_128(reader):
-    hi, lo = reader.read("!QQ")
-    return (hi << 64) | lo
diff --git a/python/ofagent/loxi/of12/__init__.py b/python/ofagent/loxi/of12/__init__.py
deleted file mode 100644
index 675a44c..0000000
--- a/python/ofagent/loxi/of12/__init__.py
+++ /dev/null
@@ -1,30 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template init.py
-# Do not modify
-
-import const
-import action
-import oxm
-import message
-import instruction
-import common
-from const import *
-from common import *
-from loxi import ProtocolError
diff --git a/python/ofagent/loxi/of12/action.py b/python/ofagent/loxi/of12/action.py
deleted file mode 100644
index da7ee0b..0000000
--- a/python/ofagent/loxi/of12/action.py
+++ /dev/null
@@ -1,1144 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template module.py
-# Do not modify
-
-import struct
-import loxi
-import util
-import loxi.generic_util
-
-import sys
-ofp = sys.modules['loxi.of12']
-
-class action(loxi.OFObject):
-    subtypes = {}
-
-
-    def __init__(self, type=None):
-        if type != None:
-            self.type = type
-        else:
-            self.type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 0)
-        subclass = action.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = action()
-        obj.type = reader.read("!H")[0]
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type != other.type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("action {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-
-class experimenter(action):
-    subtypes = {}
-
-    type = 65535
-
-    def __init__(self, experimenter=None, data=None):
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed.append(loxi.generic_util.pad_to(8, length))
-        length += len(packed[-1])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 4)
-        subclass = experimenter.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = experimenter()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.experimenter = reader.read("!L")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.experimenter != other.experimenter: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("experimenter {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[65535] = experimenter
-
-class bsn(experimenter):
-    subtypes = {}
-
-    type = 65535
-    experimenter = 6035143
-
-    def __init__(self, subtype=None):
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 8)
-        subclass = bsn.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = bsn()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        obj.subtype = reader.read("!L")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.subtype != other.subtype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-experimenter.subtypes[6035143] = bsn
-
-class bsn_checksum(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 4
-
-    def __init__(self, checksum=None):
-        if checksum != None:
-            self.checksum = checksum
-        else:
-            self.checksum = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(util.pack_checksum_128(self.checksum))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_checksum()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 4)
-        obj.checksum = util.unpack_checksum_128(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.checksum != other.checksum: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_checksum {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("checksum = ");
-                q.pp(self.checksum)
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[4] = bsn_checksum
-
-class bsn_mirror(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 1
-
-    def __init__(self, dest_port=None, vlan_tag=None, copy_stage=None):
-        if dest_port != None:
-            self.dest_port = dest_port
-        else:
-            self.dest_port = 0
-        if vlan_tag != None:
-            self.vlan_tag = vlan_tag
-        else:
-            self.vlan_tag = 0
-        if copy_stage != None:
-            self.copy_stage = copy_stage
-        else:
-            self.copy_stage = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.dest_port))
-        packed.append(struct.pack("!L", self.vlan_tag))
-        packed.append(struct.pack("!B", self.copy_stage))
-        packed.append('\x00' * 3)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_mirror()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 1)
-        obj.dest_port = reader.read("!L")[0]
-        obj.vlan_tag = reader.read("!L")[0]
-        obj.copy_stage = reader.read("!B")[0]
-        reader.skip(3)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.dest_port != other.dest_port: return False
-        if self.vlan_tag != other.vlan_tag: return False
-        if self.copy_stage != other.copy_stage: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_mirror {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("dest_port = ");
-                q.text("%#x" % self.dest_port)
-                q.text(","); q.breakable()
-                q.text("vlan_tag = ");
-                q.text("%#x" % self.vlan_tag)
-                q.text(","); q.breakable()
-                q.text("copy_stage = ");
-                q.text("%#x" % self.copy_stage)
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[1] = bsn_mirror
-
-class bsn_set_tunnel_dst(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 2
-
-    def __init__(self, dst=None):
-        if dst != None:
-            self.dst = dst
-        else:
-            self.dst = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.dst))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_set_tunnel_dst()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 2)
-        obj.dst = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.dst != other.dst: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_set_tunnel_dst {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("dst = ");
-                q.text("%#x" % self.dst)
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[2] = bsn_set_tunnel_dst
-
-class copy_ttl_in(action):
-    type = 12
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = copy_ttl_in()
-        _type = reader.read("!H")[0]
-        assert(_type == 12)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("copy_ttl_in {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action.subtypes[12] = copy_ttl_in
-
-class copy_ttl_out(action):
-    type = 11
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = copy_ttl_out()
-        _type = reader.read("!H")[0]
-        assert(_type == 11)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("copy_ttl_out {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action.subtypes[11] = copy_ttl_out
-
-class dec_mpls_ttl(action):
-    type = 16
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = dec_mpls_ttl()
-        _type = reader.read("!H")[0]
-        assert(_type == 16)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("dec_mpls_ttl {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action.subtypes[16] = dec_mpls_ttl
-
-class dec_nw_ttl(action):
-    type = 24
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = dec_nw_ttl()
-        _type = reader.read("!H")[0]
-        assert(_type == 24)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("dec_nw_ttl {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action.subtypes[24] = dec_nw_ttl
-
-class group(action):
-    type = 22
-
-    def __init__(self, group_id=None):
-        if group_id != None:
-            self.group_id = group_id
-        else:
-            self.group_id = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.group_id))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group()
-        _type = reader.read("!H")[0]
-        assert(_type == 22)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.group_id = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.group_id != other.group_id: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("group_id = ");
-                q.text("%#x" % self.group_id)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[22] = group
-
-class nicira(experimenter):
-    subtypes = {}
-
-    type = 65535
-    experimenter = 8992
-
-    def __init__(self, subtype=None):
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!H", self.subtype))
-        packed.append('\x00' * 2)
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 8)
-        subclass = nicira.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = nicira()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 8992)
-        obj.subtype = reader.read("!H")[0]
-        reader.skip(2)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.subtype != other.subtype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("nicira {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-experimenter.subtypes[8992] = nicira
-
-class nicira_dec_ttl(nicira):
-    type = 65535
-    experimenter = 8992
-    subtype = 18
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!H", self.subtype))
-        packed.append('\x00' * 2)
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = nicira_dec_ttl()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 8992)
-        _subtype = reader.read("!H")[0]
-        assert(_subtype == 18)
-        reader.skip(2)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("nicira_dec_ttl {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-nicira.subtypes[18] = nicira_dec_ttl
-
-class output(action):
-    type = 0
-
-    def __init__(self, port=None, max_len=None):
-        if port != None:
-            self.port = port
-        else:
-            self.port = 0
-        if max_len != None:
-            self.max_len = max_len
-        else:
-            self.max_len = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(util.pack_port_no(self.port))
-        packed.append(struct.pack("!H", self.max_len))
-        packed.append('\x00' * 6)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = output()
-        _type = reader.read("!H")[0]
-        assert(_type == 0)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.port = util.unpack_port_no(reader)
-        obj.max_len = reader.read("!H")[0]
-        reader.skip(6)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.port != other.port: return False
-        if self.max_len != other.max_len: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("output {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("port = ");
-                q.text(util.pretty_port(self.port))
-                q.text(","); q.breakable()
-                q.text("max_len = ");
-                q.text("%#x" % self.max_len)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[0] = output
-
-class pop_mpls(action):
-    type = 20
-
-    def __init__(self, ethertype=None):
-        if ethertype != None:
-            self.ethertype = ethertype
-        else:
-            self.ethertype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!H", self.ethertype))
-        packed.append('\x00' * 2)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = pop_mpls()
-        _type = reader.read("!H")[0]
-        assert(_type == 20)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.ethertype = reader.read("!H")[0]
-        reader.skip(2)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.ethertype != other.ethertype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("pop_mpls {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("ethertype = ");
-                q.text("%#x" % self.ethertype)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[20] = pop_mpls
-
-class pop_vlan(action):
-    type = 18
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = pop_vlan()
-        _type = reader.read("!H")[0]
-        assert(_type == 18)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("pop_vlan {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action.subtypes[18] = pop_vlan
-
-class push_mpls(action):
-    type = 19
-
-    def __init__(self, ethertype=None):
-        if ethertype != None:
-            self.ethertype = ethertype
-        else:
-            self.ethertype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!H", self.ethertype))
-        packed.append('\x00' * 2)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = push_mpls()
-        _type = reader.read("!H")[0]
-        assert(_type == 19)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.ethertype = reader.read("!H")[0]
-        reader.skip(2)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.ethertype != other.ethertype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("push_mpls {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("ethertype = ");
-                q.text("%#x" % self.ethertype)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[19] = push_mpls
-
-class push_vlan(action):
-    type = 17
-
-    def __init__(self, ethertype=None):
-        if ethertype != None:
-            self.ethertype = ethertype
-        else:
-            self.ethertype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!H", self.ethertype))
-        packed.append('\x00' * 2)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = push_vlan()
-        _type = reader.read("!H")[0]
-        assert(_type == 17)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.ethertype = reader.read("!H")[0]
-        reader.skip(2)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.ethertype != other.ethertype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("push_vlan {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("ethertype = ");
-                q.text("%#x" % self.ethertype)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[17] = push_vlan
-
-class set_field(action):
-    type = 25
-
-    def __init__(self, field=None):
-        if field != None:
-            self.field = field
-        else:
-            self.field = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(self.field.pack())
-        length = sum([len(x) for x in packed])
-        packed.append(loxi.generic_util.pad_to(8, length))
-        length += len(packed[-1])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_field()
-        _type = reader.read("!H")[0]
-        assert(_type == 25)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.field = ofp.oxm.oxm.unpack(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.field != other.field: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_field {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("field = ");
-                q.pp(self.field)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[25] = set_field
-
-class set_mpls_ttl(action):
-    type = 15
-
-    def __init__(self, mpls_ttl=None):
-        if mpls_ttl != None:
-            self.mpls_ttl = mpls_ttl
-        else:
-            self.mpls_ttl = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!B", self.mpls_ttl))
-        packed.append('\x00' * 3)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_mpls_ttl()
-        _type = reader.read("!H")[0]
-        assert(_type == 15)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.mpls_ttl = reader.read("!B")[0]
-        reader.skip(3)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.mpls_ttl != other.mpls_ttl: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_mpls_ttl {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("mpls_ttl = ");
-                q.text("%#x" % self.mpls_ttl)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[15] = set_mpls_ttl
-
-class set_nw_ttl(action):
-    type = 23
-
-    def __init__(self, nw_ttl=None):
-        if nw_ttl != None:
-            self.nw_ttl = nw_ttl
-        else:
-            self.nw_ttl = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!B", self.nw_ttl))
-        packed.append('\x00' * 3)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_nw_ttl()
-        _type = reader.read("!H")[0]
-        assert(_type == 23)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.nw_ttl = reader.read("!B")[0]
-        reader.skip(3)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.nw_ttl != other.nw_ttl: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_nw_ttl {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("nw_ttl = ");
-                q.text("%#x" % self.nw_ttl)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[23] = set_nw_ttl
-
-class set_queue(action):
-    type = 21
-
-    def __init__(self, queue_id=None):
-        if queue_id != None:
-            self.queue_id = queue_id
-        else:
-            self.queue_id = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.queue_id))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_queue()
-        _type = reader.read("!H")[0]
-        assert(_type == 21)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.queue_id = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.queue_id != other.queue_id: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_queue {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("queue_id = ");
-                q.text("%#x" % self.queue_id)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[21] = set_queue
-
-
diff --git a/python/ofagent/loxi/of12/common.py b/python/ofagent/loxi/of12/common.py
deleted file mode 100644
index 2ce4918..0000000
--- a/python/ofagent/loxi/of12/common.py
+++ /dev/null
@@ -1,1708 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template module.py
-# Do not modify
-
-import struct
-import loxi
-import util
-import loxi.generic_util
-
-import sys
-ofp = sys.modules['loxi.of12']
-
-class bsn_interface(loxi.OFObject):
-
-    def __init__(self, hw_addr=None, name=None, ipv4_addr=None, ipv4_netmask=None):
-        if hw_addr != None:
-            self.hw_addr = hw_addr
-        else:
-            self.hw_addr = [0,0,0,0,0,0]
-        if name != None:
-            self.name = name
-        else:
-            self.name = ""
-        if ipv4_addr != None:
-            self.ipv4_addr = ipv4_addr
-        else:
-            self.ipv4_addr = 0
-        if ipv4_netmask != None:
-            self.ipv4_netmask = ipv4_netmask
-        else:
-            self.ipv4_netmask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!6B", *self.hw_addr))
-        packed.append('\x00' * 2)
-        packed.append(struct.pack("!16s", self.name))
-        packed.append(struct.pack("!L", self.ipv4_addr))
-        packed.append(struct.pack("!L", self.ipv4_netmask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_interface()
-        obj.hw_addr = list(reader.read('!6B'))
-        reader.skip(2)
-        obj.name = reader.read("!16s")[0].rstrip("\x00")
-        obj.ipv4_addr = reader.read("!L")[0]
-        obj.ipv4_netmask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.hw_addr != other.hw_addr: return False
-        if self.name != other.name: return False
-        if self.ipv4_addr != other.ipv4_addr: return False
-        if self.ipv4_netmask != other.ipv4_netmask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_interface {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("hw_addr = ");
-                q.text(util.pretty_mac(self.hw_addr))
-                q.text(","); q.breakable()
-                q.text("name = ");
-                q.pp(self.name)
-                q.text(","); q.breakable()
-                q.text("ipv4_addr = ");
-                q.text(util.pretty_ipv4(self.ipv4_addr))
-                q.text(","); q.breakable()
-                q.text("ipv4_netmask = ");
-                q.text(util.pretty_ipv4(self.ipv4_netmask))
-            q.breakable()
-        q.text('}')
-
-
-class bsn_vport(loxi.OFObject):
-    subtypes = {}
-
-
-    def __init__(self, type=None):
-        if type != None:
-            self.type = type
-        else:
-            self.type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 0)
-        subclass = bsn_vport.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = bsn_vport()
-        obj.type = reader.read("!H")[0]
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type != other.type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vport {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-
-class bsn_vport_l2gre(bsn_vport):
-    type = 1
-
-    def __init__(self, flags=None, port_no=None, loopback_port_no=None, local_mac=None, nh_mac=None, src_ip=None, dst_ip=None, dscp=None, ttl=None, vpn=None, rate_limit=None, if_name=None):
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if loopback_port_no != None:
-            self.loopback_port_no = loopback_port_no
-        else:
-            self.loopback_port_no = 0
-        if local_mac != None:
-            self.local_mac = local_mac
-        else:
-            self.local_mac = [0,0,0,0,0,0]
-        if nh_mac != None:
-            self.nh_mac = nh_mac
-        else:
-            self.nh_mac = [0,0,0,0,0,0]
-        if src_ip != None:
-            self.src_ip = src_ip
-        else:
-            self.src_ip = 0
-        if dst_ip != None:
-            self.dst_ip = dst_ip
-        else:
-            self.dst_ip = 0
-        if dscp != None:
-            self.dscp = dscp
-        else:
-            self.dscp = 0
-        if ttl != None:
-            self.ttl = ttl
-        else:
-            self.ttl = 0
-        if vpn != None:
-            self.vpn = vpn
-        else:
-            self.vpn = 0
-        if rate_limit != None:
-            self.rate_limit = rate_limit
-        else:
-            self.rate_limit = 0
-        if if_name != None:
-            self.if_name = if_name
-        else:
-            self.if_name = ""
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.flags))
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(util.pack_port_no(self.loopback_port_no))
-        packed.append(struct.pack("!6B", *self.local_mac))
-        packed.append(struct.pack("!6B", *self.nh_mac))
-        packed.append(struct.pack("!L", self.src_ip))
-        packed.append(struct.pack("!L", self.dst_ip))
-        packed.append(struct.pack("!B", self.dscp))
-        packed.append(struct.pack("!B", self.ttl))
-        packed.append('\x00' * 2)
-        packed.append(struct.pack("!L", self.vpn))
-        packed.append(struct.pack("!L", self.rate_limit))
-        packed.append(struct.pack("!16s", self.if_name))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_vport_l2gre()
-        _type = reader.read("!H")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.flags = reader.read("!L")[0]
-        obj.port_no = util.unpack_port_no(reader)
-        obj.loopback_port_no = util.unpack_port_no(reader)
-        obj.local_mac = list(reader.read('!6B'))
-        obj.nh_mac = list(reader.read('!6B'))
-        obj.src_ip = reader.read("!L")[0]
-        obj.dst_ip = reader.read("!L")[0]
-        obj.dscp = reader.read("!B")[0]
-        obj.ttl = reader.read("!B")[0]
-        reader.skip(2)
-        obj.vpn = reader.read("!L")[0]
-        obj.rate_limit = reader.read("!L")[0]
-        obj.if_name = reader.read("!16s")[0].rstrip("\x00")
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.flags != other.flags: return False
-        if self.port_no != other.port_no: return False
-        if self.loopback_port_no != other.loopback_port_no: return False
-        if self.local_mac != other.local_mac: return False
-        if self.nh_mac != other.nh_mac: return False
-        if self.src_ip != other.src_ip: return False
-        if self.dst_ip != other.dst_ip: return False
-        if self.dscp != other.dscp: return False
-        if self.ttl != other.ttl: return False
-        if self.vpn != other.vpn: return False
-        if self.rate_limit != other.rate_limit: return False
-        if self.if_name != other.if_name: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vport_l2gre {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("loopback_port_no = ");
-                q.text(util.pretty_port(self.loopback_port_no))
-                q.text(","); q.breakable()
-                q.text("local_mac = ");
-                q.text(util.pretty_mac(self.local_mac))
-                q.text(","); q.breakable()
-                q.text("nh_mac = ");
-                q.text(util.pretty_mac(self.nh_mac))
-                q.text(","); q.breakable()
-                q.text("src_ip = ");
-                q.text(util.pretty_ipv4(self.src_ip))
-                q.text(","); q.breakable()
-                q.text("dst_ip = ");
-                q.text(util.pretty_ipv4(self.dst_ip))
-                q.text(","); q.breakable()
-                q.text("dscp = ");
-                q.text("%#x" % self.dscp)
-                q.text(","); q.breakable()
-                q.text("ttl = ");
-                q.text("%#x" % self.ttl)
-                q.text(","); q.breakable()
-                q.text("vpn = ");
-                q.text("%#x" % self.vpn)
-                q.text(","); q.breakable()
-                q.text("rate_limit = ");
-                q.text("%#x" % self.rate_limit)
-                q.text(","); q.breakable()
-                q.text("if_name = ");
-                q.pp(self.if_name)
-            q.breakable()
-        q.text('}')
-
-bsn_vport.subtypes[1] = bsn_vport_l2gre
-
-class bsn_vport_q_in_q(bsn_vport):
-    type = 0
-
-    def __init__(self, port_no=None, ingress_tpid=None, ingress_vlan_id=None, egress_tpid=None, egress_vlan_id=None, if_name=None):
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if ingress_tpid != None:
-            self.ingress_tpid = ingress_tpid
-        else:
-            self.ingress_tpid = 0
-        if ingress_vlan_id != None:
-            self.ingress_vlan_id = ingress_vlan_id
-        else:
-            self.ingress_vlan_id = 0
-        if egress_tpid != None:
-            self.egress_tpid = egress_tpid
-        else:
-            self.egress_tpid = 0
-        if egress_vlan_id != None:
-            self.egress_vlan_id = egress_vlan_id
-        else:
-            self.egress_vlan_id = 0
-        if if_name != None:
-            self.if_name = if_name
-        else:
-            self.if_name = ""
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.port_no))
-        packed.append(struct.pack("!H", self.ingress_tpid))
-        packed.append(struct.pack("!H", self.ingress_vlan_id))
-        packed.append(struct.pack("!H", self.egress_tpid))
-        packed.append(struct.pack("!H", self.egress_vlan_id))
-        packed.append(struct.pack("!16s", self.if_name))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_vport_q_in_q()
-        _type = reader.read("!H")[0]
-        assert(_type == 0)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.port_no = reader.read("!L")[0]
-        obj.ingress_tpid = reader.read("!H")[0]
-        obj.ingress_vlan_id = reader.read("!H")[0]
-        obj.egress_tpid = reader.read("!H")[0]
-        obj.egress_vlan_id = reader.read("!H")[0]
-        obj.if_name = reader.read("!16s")[0].rstrip("\x00")
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.port_no != other.port_no: return False
-        if self.ingress_tpid != other.ingress_tpid: return False
-        if self.ingress_vlan_id != other.ingress_vlan_id: return False
-        if self.egress_tpid != other.egress_tpid: return False
-        if self.egress_vlan_id != other.egress_vlan_id: return False
-        if self.if_name != other.if_name: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vport_q_in_q {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("port_no = ");
-                q.text("%#x" % self.port_no)
-                q.text(","); q.breakable()
-                q.text("ingress_tpid = ");
-                q.text("%#x" % self.ingress_tpid)
-                q.text(","); q.breakable()
-                q.text("ingress_vlan_id = ");
-                q.text("%#x" % self.ingress_vlan_id)
-                q.text(","); q.breakable()
-                q.text("egress_tpid = ");
-                q.text("%#x" % self.egress_tpid)
-                q.text(","); q.breakable()
-                q.text("egress_vlan_id = ");
-                q.text("%#x" % self.egress_vlan_id)
-                q.text(","); q.breakable()
-                q.text("if_name = ");
-                q.pp(self.if_name)
-            q.breakable()
-        q.text('}')
-
-bsn_vport.subtypes[0] = bsn_vport_q_in_q
-
-class bucket(loxi.OFObject):
-
-    def __init__(self, weight=None, watch_port=None, watch_group=None, actions=None):
-        if weight != None:
-            self.weight = weight
-        else:
-            self.weight = 0
-        if watch_port != None:
-            self.watch_port = watch_port
-        else:
-            self.watch_port = 0
-        if watch_group != None:
-            self.watch_group = watch_group
-        else:
-            self.watch_group = 0
-        if actions != None:
-            self.actions = actions
-        else:
-            self.actions = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 0
-        packed.append(struct.pack("!H", self.weight))
-        packed.append(util.pack_port_no(self.watch_port))
-        packed.append(struct.pack("!L", self.watch_group))
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.actions))
-        length = sum([len(x) for x in packed])
-        packed[0] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bucket()
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 2)
-        obj.weight = reader.read("!H")[0]
-        obj.watch_port = util.unpack_port_no(reader)
-        obj.watch_group = reader.read("!L")[0]
-        reader.skip(4)
-        obj.actions = loxi.generic_util.unpack_list(reader, ofp.action.action.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.weight != other.weight: return False
-        if self.watch_port != other.watch_port: return False
-        if self.watch_group != other.watch_group: return False
-        if self.actions != other.actions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bucket {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("weight = ");
-                q.text("%#x" % self.weight)
-                q.text(","); q.breakable()
-                q.text("watch_port = ");
-                q.text(util.pretty_port(self.watch_port))
-                q.text(","); q.breakable()
-                q.text("watch_group = ");
-                q.text("%#x" % self.watch_group)
-                q.text(","); q.breakable()
-                q.text("actions = ");
-                q.pp(self.actions)
-            q.breakable()
-        q.text('}')
-
-
-class bucket_counter(loxi.OFObject):
-
-    def __init__(self, packet_count=None, byte_count=None):
-        if packet_count != None:
-            self.packet_count = packet_count
-        else:
-            self.packet_count = 0
-        if byte_count != None:
-            self.byte_count = byte_count
-        else:
-            self.byte_count = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!Q", self.packet_count))
-        packed.append(struct.pack("!Q", self.byte_count))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bucket_counter()
-        obj.packet_count = reader.read("!Q")[0]
-        obj.byte_count = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.packet_count != other.packet_count: return False
-        if self.byte_count != other.byte_count: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bucket_counter {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("packet_count = ");
-                q.text("%#x" % self.packet_count)
-                q.text(","); q.breakable()
-                q.text("byte_count = ");
-                q.text("%#x" % self.byte_count)
-            q.breakable()
-        q.text('}')
-
-
-class flow_stats_entry(loxi.OFObject):
-
-    def __init__(self, table_id=None, duration_sec=None, duration_nsec=None, priority=None, idle_timeout=None, hard_timeout=None, cookie=None, packet_count=None, byte_count=None, match=None, instructions=None):
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if duration_sec != None:
-            self.duration_sec = duration_sec
-        else:
-            self.duration_sec = 0
-        if duration_nsec != None:
-            self.duration_nsec = duration_nsec
-        else:
-            self.duration_nsec = 0
-        if priority != None:
-            self.priority = priority
-        else:
-            self.priority = 0
-        if idle_timeout != None:
-            self.idle_timeout = idle_timeout
-        else:
-            self.idle_timeout = 0
-        if hard_timeout != None:
-            self.hard_timeout = hard_timeout
-        else:
-            self.hard_timeout = 0
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if packet_count != None:
-            self.packet_count = packet_count
-        else:
-            self.packet_count = 0
-        if byte_count != None:
-            self.byte_count = byte_count
-        else:
-            self.byte_count = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        if instructions != None:
-            self.instructions = instructions
-        else:
-            self.instructions = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 0
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append('\x00' * 1)
-        packed.append(struct.pack("!L", self.duration_sec))
-        packed.append(struct.pack("!L", self.duration_nsec))
-        packed.append(struct.pack("!H", self.priority))
-        packed.append(struct.pack("!H", self.idle_timeout))
-        packed.append(struct.pack("!H", self.hard_timeout))
-        packed.append('\x00' * 6)
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(struct.pack("!Q", self.packet_count))
-        packed.append(struct.pack("!Q", self.byte_count))
-        packed.append(self.match.pack())
-        packed.append(loxi.generic_util.pack_list(self.instructions))
-        length = sum([len(x) for x in packed])
-        packed[0] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_stats_entry()
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 2)
-        obj.table_id = reader.read("!B")[0]
-        reader.skip(1)
-        obj.duration_sec = reader.read("!L")[0]
-        obj.duration_nsec = reader.read("!L")[0]
-        obj.priority = reader.read("!H")[0]
-        obj.idle_timeout = reader.read("!H")[0]
-        obj.hard_timeout = reader.read("!H")[0]
-        reader.skip(6)
-        obj.cookie = reader.read("!Q")[0]
-        obj.packet_count = reader.read("!Q")[0]
-        obj.byte_count = reader.read("!Q")[0]
-        obj.match = ofp.match.unpack(reader)
-        obj.instructions = loxi.generic_util.unpack_list(reader, ofp.instruction.instruction.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.table_id != other.table_id: return False
-        if self.duration_sec != other.duration_sec: return False
-        if self.duration_nsec != other.duration_nsec: return False
-        if self.priority != other.priority: return False
-        if self.idle_timeout != other.idle_timeout: return False
-        if self.hard_timeout != other.hard_timeout: return False
-        if self.cookie != other.cookie: return False
-        if self.packet_count != other.packet_count: return False
-        if self.byte_count != other.byte_count: return False
-        if self.match != other.match: return False
-        if self.instructions != other.instructions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("duration_sec = ");
-                q.text("%#x" % self.duration_sec)
-                q.text(","); q.breakable()
-                q.text("duration_nsec = ");
-                q.text("%#x" % self.duration_nsec)
-                q.text(","); q.breakable()
-                q.text("priority = ");
-                q.text("%#x" % self.priority)
-                q.text(","); q.breakable()
-                q.text("idle_timeout = ");
-                q.text("%#x" % self.idle_timeout)
-                q.text(","); q.breakable()
-                q.text("hard_timeout = ");
-                q.text("%#x" % self.hard_timeout)
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("packet_count = ");
-                q.text("%#x" % self.packet_count)
-                q.text(","); q.breakable()
-                q.text("byte_count = ");
-                q.text("%#x" % self.byte_count)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-                q.text(","); q.breakable()
-                q.text("instructions = ");
-                q.pp(self.instructions)
-            q.breakable()
-        q.text('}')
-
-
-class group_desc_stats_entry(loxi.OFObject):
-
-    def __init__(self, group_type=None, group_id=None, buckets=None):
-        if group_type != None:
-            self.group_type = group_type
-        else:
-            self.group_type = 0
-        if group_id != None:
-            self.group_id = group_id
-        else:
-            self.group_id = 0
-        if buckets != None:
-            self.buckets = buckets
-        else:
-            self.buckets = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 0
-        packed.append(struct.pack("!B", self.group_type))
-        packed.append('\x00' * 1)
-        packed.append(struct.pack("!L", self.group_id))
-        packed.append(loxi.generic_util.pack_list(self.buckets))
-        length = sum([len(x) for x in packed])
-        packed[0] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group_desc_stats_entry()
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 2)
-        obj.group_type = reader.read("!B")[0]
-        reader.skip(1)
-        obj.group_id = reader.read("!L")[0]
-        obj.buckets = loxi.generic_util.unpack_list(reader, ofp.common.bucket.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.group_type != other.group_type: return False
-        if self.group_id != other.group_id: return False
-        if self.buckets != other.buckets: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_desc_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("group_type = ");
-                q.text("%#x" % self.group_type)
-                q.text(","); q.breakable()
-                q.text("group_id = ");
-                q.text("%#x" % self.group_id)
-                q.text(","); q.breakable()
-                q.text("buckets = ");
-                q.pp(self.buckets)
-            q.breakable()
-        q.text('}')
-
-
-class group_stats_entry(loxi.OFObject):
-
-    def __init__(self, group_id=None, ref_count=None, packet_count=None, byte_count=None, bucket_stats=None):
-        if group_id != None:
-            self.group_id = group_id
-        else:
-            self.group_id = 0
-        if ref_count != None:
-            self.ref_count = ref_count
-        else:
-            self.ref_count = 0
-        if packet_count != None:
-            self.packet_count = packet_count
-        else:
-            self.packet_count = 0
-        if byte_count != None:
-            self.byte_count = byte_count
-        else:
-            self.byte_count = 0
-        if bucket_stats != None:
-            self.bucket_stats = bucket_stats
-        else:
-            self.bucket_stats = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 0
-        packed.append('\x00' * 2)
-        packed.append(struct.pack("!L", self.group_id))
-        packed.append(struct.pack("!L", self.ref_count))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!Q", self.packet_count))
-        packed.append(struct.pack("!Q", self.byte_count))
-        packed.append(loxi.generic_util.pack_list(self.bucket_stats))
-        length = sum([len(x) for x in packed])
-        packed[0] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group_stats_entry()
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 2)
-        reader.skip(2)
-        obj.group_id = reader.read("!L")[0]
-        obj.ref_count = reader.read("!L")[0]
-        reader.skip(4)
-        obj.packet_count = reader.read("!Q")[0]
-        obj.byte_count = reader.read("!Q")[0]
-        obj.bucket_stats = loxi.generic_util.unpack_list(reader, ofp.common.bucket_counter.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.group_id != other.group_id: return False
-        if self.ref_count != other.ref_count: return False
-        if self.packet_count != other.packet_count: return False
-        if self.byte_count != other.byte_count: return False
-        if self.bucket_stats != other.bucket_stats: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("group_id = ");
-                q.text("%#x" % self.group_id)
-                q.text(","); q.breakable()
-                q.text("ref_count = ");
-                q.text("%#x" % self.ref_count)
-                q.text(","); q.breakable()
-                q.text("packet_count = ");
-                q.text("%#x" % self.packet_count)
-                q.text(","); q.breakable()
-                q.text("byte_count = ");
-                q.text("%#x" % self.byte_count)
-                q.text(","); q.breakable()
-                q.text("bucket_stats = ");
-                q.pp(self.bucket_stats)
-            q.breakable()
-        q.text('}')
-
-
-class match_v3(loxi.OFObject):
-    type = 1
-
-    def __init__(self, oxm_list=None):
-        if oxm_list != None:
-            self.oxm_list = oxm_list
-        else:
-            self.oxm_list = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(loxi.generic_util.pack_list(self.oxm_list))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        packed.append(loxi.generic_util.pad_to(8, length))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = match_v3()
-        _type = reader.read("!H")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.oxm_list = loxi.generic_util.unpack_list(reader, ofp.oxm.oxm.unpack)
-        orig_reader.skip_align()
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.oxm_list != other.oxm_list: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("match_v3 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("oxm_list = ");
-                q.pp(self.oxm_list)
-            q.breakable()
-        q.text('}')
-
-
-class packet_queue(loxi.OFObject):
-
-    def __init__(self, queue_id=None, port=None, properties=None):
-        if queue_id != None:
-            self.queue_id = queue_id
-        else:
-            self.queue_id = 0
-        if port != None:
-            self.port = port
-        else:
-            self.port = 0
-        if properties != None:
-            self.properties = properties
-        else:
-            self.properties = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.queue_id))
-        packed.append(util.pack_port_no(self.port))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 2
-        packed.append('\x00' * 6)
-        packed.append(loxi.generic_util.pack_list(self.properties))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = packet_queue()
-        obj.queue_id = reader.read("!L")[0]
-        obj.port = util.unpack_port_no(reader)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 10)
-        reader.skip(6)
-        obj.properties = loxi.generic_util.unpack_list(reader, ofp.common.queue_prop.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.queue_id != other.queue_id: return False
-        if self.port != other.port: return False
-        if self.properties != other.properties: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("packet_queue {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("queue_id = ");
-                q.text("%#x" % self.queue_id)
-                q.text(","); q.breakable()
-                q.text("port = ");
-                q.text(util.pretty_port(self.port))
-                q.text(","); q.breakable()
-                q.text("properties = ");
-                q.pp(self.properties)
-            q.breakable()
-        q.text('}')
-
-
-class port_desc(loxi.OFObject):
-
-    def __init__(self, port_no=None, hw_addr=None, name=None, config=None, state=None, curr=None, advertised=None, supported=None, peer=None, curr_speed=None, max_speed=None):
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if hw_addr != None:
-            self.hw_addr = hw_addr
-        else:
-            self.hw_addr = [0,0,0,0,0,0]
-        if name != None:
-            self.name = name
-        else:
-            self.name = ""
-        if config != None:
-            self.config = config
-        else:
-            self.config = 0
-        if state != None:
-            self.state = state
-        else:
-            self.state = 0
-        if curr != None:
-            self.curr = curr
-        else:
-            self.curr = 0
-        if advertised != None:
-            self.advertised = advertised
-        else:
-            self.advertised = 0
-        if supported != None:
-            self.supported = supported
-        else:
-            self.supported = 0
-        if peer != None:
-            self.peer = peer
-        else:
-            self.peer = 0
-        if curr_speed != None:
-            self.curr_speed = curr_speed
-        else:
-            self.curr_speed = 0
-        if max_speed != None:
-            self.max_speed = max_speed
-        else:
-            self.max_speed = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!6B", *self.hw_addr))
-        packed.append('\x00' * 2)
-        packed.append(struct.pack("!16s", self.name))
-        packed.append(struct.pack("!L", self.config))
-        packed.append(struct.pack("!L", self.state))
-        packed.append(struct.pack("!L", self.curr))
-        packed.append(struct.pack("!L", self.advertised))
-        packed.append(struct.pack("!L", self.supported))
-        packed.append(struct.pack("!L", self.peer))
-        packed.append(struct.pack("!L", self.curr_speed))
-        packed.append(struct.pack("!L", self.max_speed))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = port_desc()
-        obj.port_no = util.unpack_port_no(reader)
-        reader.skip(4)
-        obj.hw_addr = list(reader.read('!6B'))
-        reader.skip(2)
-        obj.name = reader.read("!16s")[0].rstrip("\x00")
-        obj.config = reader.read("!L")[0]
-        obj.state = reader.read("!L")[0]
-        obj.curr = reader.read("!L")[0]
-        obj.advertised = reader.read("!L")[0]
-        obj.supported = reader.read("!L")[0]
-        obj.peer = reader.read("!L")[0]
-        obj.curr_speed = reader.read("!L")[0]
-        obj.max_speed = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.port_no != other.port_no: return False
-        if self.hw_addr != other.hw_addr: return False
-        if self.name != other.name: return False
-        if self.config != other.config: return False
-        if self.state != other.state: return False
-        if self.curr != other.curr: return False
-        if self.advertised != other.advertised: return False
-        if self.supported != other.supported: return False
-        if self.peer != other.peer: return False
-        if self.curr_speed != other.curr_speed: return False
-        if self.max_speed != other.max_speed: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port_desc {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("hw_addr = ");
-                q.text(util.pretty_mac(self.hw_addr))
-                q.text(","); q.breakable()
-                q.text("name = ");
-                q.pp(self.name)
-                q.text(","); q.breakable()
-                q.text("config = ");
-                q.text("%#x" % self.config)
-                q.text(","); q.breakable()
-                q.text("state = ");
-                q.text("%#x" % self.state)
-                q.text(","); q.breakable()
-                q.text("curr = ");
-                q.text("%#x" % self.curr)
-                q.text(","); q.breakable()
-                q.text("advertised = ");
-                q.text("%#x" % self.advertised)
-                q.text(","); q.breakable()
-                q.text("supported = ");
-                q.text("%#x" % self.supported)
-                q.text(","); q.breakable()
-                q.text("peer = ");
-                q.text("%#x" % self.peer)
-                q.text(","); q.breakable()
-                q.text("curr_speed = ");
-                q.text("%#x" % self.curr_speed)
-                q.text(","); q.breakable()
-                q.text("max_speed = ");
-                q.text("%#x" % self.max_speed)
-            q.breakable()
-        q.text('}')
-
-
-class port_stats_entry(loxi.OFObject):
-
-    def __init__(self, port_no=None, rx_packets=None, tx_packets=None, rx_bytes=None, tx_bytes=None, rx_dropped=None, tx_dropped=None, rx_errors=None, tx_errors=None, rx_frame_err=None, rx_over_err=None, rx_crc_err=None, collisions=None):
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if rx_packets != None:
-            self.rx_packets = rx_packets
-        else:
-            self.rx_packets = 0
-        if tx_packets != None:
-            self.tx_packets = tx_packets
-        else:
-            self.tx_packets = 0
-        if rx_bytes != None:
-            self.rx_bytes = rx_bytes
-        else:
-            self.rx_bytes = 0
-        if tx_bytes != None:
-            self.tx_bytes = tx_bytes
-        else:
-            self.tx_bytes = 0
-        if rx_dropped != None:
-            self.rx_dropped = rx_dropped
-        else:
-            self.rx_dropped = 0
-        if tx_dropped != None:
-            self.tx_dropped = tx_dropped
-        else:
-            self.tx_dropped = 0
-        if rx_errors != None:
-            self.rx_errors = rx_errors
-        else:
-            self.rx_errors = 0
-        if tx_errors != None:
-            self.tx_errors = tx_errors
-        else:
-            self.tx_errors = 0
-        if rx_frame_err != None:
-            self.rx_frame_err = rx_frame_err
-        else:
-            self.rx_frame_err = 0
-        if rx_over_err != None:
-            self.rx_over_err = rx_over_err
-        else:
-            self.rx_over_err = 0
-        if rx_crc_err != None:
-            self.rx_crc_err = rx_crc_err
-        else:
-            self.rx_crc_err = 0
-        if collisions != None:
-            self.collisions = collisions
-        else:
-            self.collisions = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!Q", self.rx_packets))
-        packed.append(struct.pack("!Q", self.tx_packets))
-        packed.append(struct.pack("!Q", self.rx_bytes))
-        packed.append(struct.pack("!Q", self.tx_bytes))
-        packed.append(struct.pack("!Q", self.rx_dropped))
-        packed.append(struct.pack("!Q", self.tx_dropped))
-        packed.append(struct.pack("!Q", self.rx_errors))
-        packed.append(struct.pack("!Q", self.tx_errors))
-        packed.append(struct.pack("!Q", self.rx_frame_err))
-        packed.append(struct.pack("!Q", self.rx_over_err))
-        packed.append(struct.pack("!Q", self.rx_crc_err))
-        packed.append(struct.pack("!Q", self.collisions))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = port_stats_entry()
-        obj.port_no = util.unpack_port_no(reader)
-        reader.skip(4)
-        obj.rx_packets = reader.read("!Q")[0]
-        obj.tx_packets = reader.read("!Q")[0]
-        obj.rx_bytes = reader.read("!Q")[0]
-        obj.tx_bytes = reader.read("!Q")[0]
-        obj.rx_dropped = reader.read("!Q")[0]
-        obj.tx_dropped = reader.read("!Q")[0]
-        obj.rx_errors = reader.read("!Q")[0]
-        obj.tx_errors = reader.read("!Q")[0]
-        obj.rx_frame_err = reader.read("!Q")[0]
-        obj.rx_over_err = reader.read("!Q")[0]
-        obj.rx_crc_err = reader.read("!Q")[0]
-        obj.collisions = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.port_no != other.port_no: return False
-        if self.rx_packets != other.rx_packets: return False
-        if self.tx_packets != other.tx_packets: return False
-        if self.rx_bytes != other.rx_bytes: return False
-        if self.tx_bytes != other.tx_bytes: return False
-        if self.rx_dropped != other.rx_dropped: return False
-        if self.tx_dropped != other.tx_dropped: return False
-        if self.rx_errors != other.rx_errors: return False
-        if self.tx_errors != other.tx_errors: return False
-        if self.rx_frame_err != other.rx_frame_err: return False
-        if self.rx_over_err != other.rx_over_err: return False
-        if self.rx_crc_err != other.rx_crc_err: return False
-        if self.collisions != other.collisions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("rx_packets = ");
-                q.text("%#x" % self.rx_packets)
-                q.text(","); q.breakable()
-                q.text("tx_packets = ");
-                q.text("%#x" % self.tx_packets)
-                q.text(","); q.breakable()
-                q.text("rx_bytes = ");
-                q.text("%#x" % self.rx_bytes)
-                q.text(","); q.breakable()
-                q.text("tx_bytes = ");
-                q.text("%#x" % self.tx_bytes)
-                q.text(","); q.breakable()
-                q.text("rx_dropped = ");
-                q.text("%#x" % self.rx_dropped)
-                q.text(","); q.breakable()
-                q.text("tx_dropped = ");
-                q.text("%#x" % self.tx_dropped)
-                q.text(","); q.breakable()
-                q.text("rx_errors = ");
-                q.text("%#x" % self.rx_errors)
-                q.text(","); q.breakable()
-                q.text("tx_errors = ");
-                q.text("%#x" % self.tx_errors)
-                q.text(","); q.breakable()
-                q.text("rx_frame_err = ");
-                q.text("%#x" % self.rx_frame_err)
-                q.text(","); q.breakable()
-                q.text("rx_over_err = ");
-                q.text("%#x" % self.rx_over_err)
-                q.text(","); q.breakable()
-                q.text("rx_crc_err = ");
-                q.text("%#x" % self.rx_crc_err)
-                q.text(","); q.breakable()
-                q.text("collisions = ");
-                q.text("%#x" % self.collisions)
-            q.breakable()
-        q.text('}')
-
-
-class queue_prop(loxi.OFObject):
-    subtypes = {}
-
-
-    def __init__(self, type=None):
-        if type != None:
-            self.type = type
-        else:
-            self.type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 0)
-        subclass = queue_prop.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = queue_prop()
-        obj.type = reader.read("!H")[0]
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type != other.type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_prop {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-
-class queue_prop_experimenter(queue_prop):
-    subtypes = {}
-
-    type = 65535
-
-    def __init__(self, experimenter=None, data=None):
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append('\x00' * 4)
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 8)
-        subclass = queue_prop_experimenter.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = queue_prop_experimenter()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        obj.experimenter = reader.read("!L")[0]
-        reader.skip(4)
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.experimenter != other.experimenter: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_prop_experimenter {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-queue_prop.subtypes[65535] = queue_prop_experimenter
-
-class queue_prop_max_rate(queue_prop):
-    type = 2
-
-    def __init__(self, rate=None):
-        if rate != None:
-            self.rate = rate
-        else:
-            self.rate = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!H", self.rate))
-        packed.append('\x00' * 6)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = queue_prop_max_rate()
-        _type = reader.read("!H")[0]
-        assert(_type == 2)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        obj.rate = reader.read("!H")[0]
-        reader.skip(6)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.rate != other.rate: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_prop_max_rate {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("rate = ");
-                q.text("%#x" % self.rate)
-            q.breakable()
-        q.text('}')
-
-queue_prop.subtypes[2] = queue_prop_max_rate
-
-class queue_prop_min_rate(queue_prop):
-    type = 1
-
-    def __init__(self, rate=None):
-        if rate != None:
-            self.rate = rate
-        else:
-            self.rate = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!H", self.rate))
-        packed.append('\x00' * 6)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = queue_prop_min_rate()
-        _type = reader.read("!H")[0]
-        assert(_type == 1)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        obj.rate = reader.read("!H")[0]
-        reader.skip(6)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.rate != other.rate: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_prop_min_rate {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("rate = ");
-                q.text("%#x" % self.rate)
-            q.breakable()
-        q.text('}')
-
-queue_prop.subtypes[1] = queue_prop_min_rate
-
-class queue_stats_entry(loxi.OFObject):
-
-    def __init__(self, port_no=None, queue_id=None, tx_bytes=None, tx_packets=None, tx_errors=None):
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if queue_id != None:
-            self.queue_id = queue_id
-        else:
-            self.queue_id = 0
-        if tx_bytes != None:
-            self.tx_bytes = tx_bytes
-        else:
-            self.tx_bytes = 0
-        if tx_packets != None:
-            self.tx_packets = tx_packets
-        else:
-            self.tx_packets = 0
-        if tx_errors != None:
-            self.tx_errors = tx_errors
-        else:
-            self.tx_errors = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(struct.pack("!L", self.queue_id))
-        packed.append(struct.pack("!Q", self.tx_bytes))
-        packed.append(struct.pack("!Q", self.tx_packets))
-        packed.append(struct.pack("!Q", self.tx_errors))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = queue_stats_entry()
-        obj.port_no = util.unpack_port_no(reader)
-        obj.queue_id = reader.read("!L")[0]
-        obj.tx_bytes = reader.read("!Q")[0]
-        obj.tx_packets = reader.read("!Q")[0]
-        obj.tx_errors = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.port_no != other.port_no: return False
-        if self.queue_id != other.queue_id: return False
-        if self.tx_bytes != other.tx_bytes: return False
-        if self.tx_packets != other.tx_packets: return False
-        if self.tx_errors != other.tx_errors: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("queue_id = ");
-                q.text("%#x" % self.queue_id)
-                q.text(","); q.breakable()
-                q.text("tx_bytes = ");
-                q.text("%#x" % self.tx_bytes)
-                q.text(","); q.breakable()
-                q.text("tx_packets = ");
-                q.text("%#x" % self.tx_packets)
-                q.text(","); q.breakable()
-                q.text("tx_errors = ");
-                q.text("%#x" % self.tx_errors)
-            q.breakable()
-        q.text('}')
-
-
-class table_stats_entry(loxi.OFObject):
-
-    def __init__(self, table_id=None, name=None, match=None, wildcards=None, write_actions=None, apply_actions=None, write_setfields=None, apply_setfields=None, metadata_match=None, metadata_write=None, instructions=None, config=None, max_entries=None, active_count=None, lookup_count=None, matched_count=None):
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if name != None:
-            self.name = name
-        else:
-            self.name = ""
-        if match != None:
-            self.match = match
-        else:
-            self.match = util.init_match_bmap()
-        if wildcards != None:
-            self.wildcards = wildcards
-        else:
-            self.wildcards = util.init_wc_bmap()
-        if write_actions != None:
-            self.write_actions = write_actions
-        else:
-            self.write_actions = 0
-        if apply_actions != None:
-            self.apply_actions = apply_actions
-        else:
-            self.apply_actions = 0
-        if write_setfields != None:
-            self.write_setfields = write_setfields
-        else:
-            self.write_setfields = 0
-        if apply_setfields != None:
-            self.apply_setfields = apply_setfields
-        else:
-            self.apply_setfields = 0
-        if metadata_match != None:
-            self.metadata_match = metadata_match
-        else:
-            self.metadata_match = 0
-        if metadata_write != None:
-            self.metadata_write = metadata_write
-        else:
-            self.metadata_write = 0
-        if instructions != None:
-            self.instructions = instructions
-        else:
-            self.instructions = 0
-        if config != None:
-            self.config = config
-        else:
-            self.config = 0
-        if max_entries != None:
-            self.max_entries = max_entries
-        else:
-            self.max_entries = 0
-        if active_count != None:
-            self.active_count = active_count
-        else:
-            self.active_count = 0
-        if lookup_count != None:
-            self.lookup_count = lookup_count
-        else:
-            self.lookup_count = 0
-        if matched_count != None:
-            self.matched_count = matched_count
-        else:
-            self.matched_count = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append('\x00' * 7)
-        packed.append(struct.pack("!32s", self.name))
-        packed.append(util.pack_match_bmap(self.match))
-        packed.append(util.pack_wc_bmap(self.wildcards))
-        packed.append(struct.pack("!L", self.write_actions))
-        packed.append(struct.pack("!L", self.apply_actions))
-        packed.append(struct.pack("!Q", self.write_setfields))
-        packed.append(struct.pack("!Q", self.apply_setfields))
-        packed.append(struct.pack("!Q", self.metadata_match))
-        packed.append(struct.pack("!Q", self.metadata_write))
-        packed.append(struct.pack("!L", self.instructions))
-        packed.append(struct.pack("!L", self.config))
-        packed.append(struct.pack("!L", self.max_entries))
-        packed.append(struct.pack("!L", self.active_count))
-        packed.append(struct.pack("!Q", self.lookup_count))
-        packed.append(struct.pack("!Q", self.matched_count))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_stats_entry()
-        obj.table_id = reader.read("!B")[0]
-        reader.skip(7)
-        obj.name = reader.read("!32s")[0].rstrip("\x00")
-        obj.match = util.unpack_match_bmap(reader)
-        obj.wildcards = util.unpack_wc_bmap(reader)
-        obj.write_actions = reader.read("!L")[0]
-        obj.apply_actions = reader.read("!L")[0]
-        obj.write_setfields = reader.read("!Q")[0]
-        obj.apply_setfields = reader.read("!Q")[0]
-        obj.metadata_match = reader.read("!Q")[0]
-        obj.metadata_write = reader.read("!Q")[0]
-        obj.instructions = reader.read("!L")[0]
-        obj.config = reader.read("!L")[0]
-        obj.max_entries = reader.read("!L")[0]
-        obj.active_count = reader.read("!L")[0]
-        obj.lookup_count = reader.read("!Q")[0]
-        obj.matched_count = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.table_id != other.table_id: return False
-        if self.name != other.name: return False
-        if self.match != other.match: return False
-        if self.wildcards != other.wildcards: return False
-        if self.write_actions != other.write_actions: return False
-        if self.apply_actions != other.apply_actions: return False
-        if self.write_setfields != other.write_setfields: return False
-        if self.apply_setfields != other.apply_setfields: return False
-        if self.metadata_match != other.metadata_match: return False
-        if self.metadata_write != other.metadata_write: return False
-        if self.instructions != other.instructions: return False
-        if self.config != other.config: return False
-        if self.max_entries != other.max_entries: return False
-        if self.active_count != other.active_count: return False
-        if self.lookup_count != other.lookup_count: return False
-        if self.matched_count != other.matched_count: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("name = ");
-                q.pp(self.name)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-                q.text(","); q.breakable()
-                q.text("wildcards = ");
-                q.pp(self.wildcards)
-                q.text(","); q.breakable()
-                q.text("write_actions = ");
-                q.text("%#x" % self.write_actions)
-                q.text(","); q.breakable()
-                q.text("apply_actions = ");
-                q.text("%#x" % self.apply_actions)
-                q.text(","); q.breakable()
-                q.text("write_setfields = ");
-                q.text("%#x" % self.write_setfields)
-                q.text(","); q.breakable()
-                q.text("apply_setfields = ");
-                q.text("%#x" % self.apply_setfields)
-                q.text(","); q.breakable()
-                q.text("metadata_match = ");
-                q.text("%#x" % self.metadata_match)
-                q.text(","); q.breakable()
-                q.text("metadata_write = ");
-                q.text("%#x" % self.metadata_write)
-                q.text(","); q.breakable()
-                q.text("instructions = ");
-                q.text("%#x" % self.instructions)
-                q.text(","); q.breakable()
-                q.text("config = ");
-                q.text("%#x" % self.config)
-                q.text(","); q.breakable()
-                q.text("max_entries = ");
-                q.text("%#x" % self.max_entries)
-                q.text(","); q.breakable()
-                q.text("active_count = ");
-                q.text("%#x" % self.active_count)
-                q.text(","); q.breakable()
-                q.text("lookup_count = ");
-                q.text("%#x" % self.lookup_count)
-                q.text(","); q.breakable()
-                q.text("matched_count = ");
-                q.text("%#x" % self.matched_count)
-            q.breakable()
-        q.text('}')
-
-
-
-match = match_v3
diff --git a/python/ofagent/loxi/of12/const.py b/python/ofagent/loxi/of12/const.py
deleted file mode 100644
index d1df449..0000000
--- a/python/ofagent/loxi/of12/const.py
+++ /dev/null
@@ -1,837 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template const.py
-# Do not modify
-
-OFP_VERSION = 3
-
-# Identifiers from group macro_definitions
-OFP_MAX_TABLE_NAME_LEN = 32
-OFP_MAX_PORT_NAME_LEN = 16
-OFP_TCP_PORT = 6653
-OFP_SSL_PORT = 6653
-OFP_ETH_ALEN = 6
-OFP_DEFAULT_MISS_SEND_LEN = 128
-OFP_VLAN_NONE = 0
-OFP_FLOW_PERMANENT = 0
-OFP_DEFAULT_PRIORITY = 32768
-OFP_NO_BUFFER = 4294967295
-DESC_STR_LEN = 256
-SERIAL_NUM_LEN = 32
-OFPQ_ALL = 4294967295
-OFPQ_MIN_RATE_UNCFG = 65535
-OFPQ_MAX_RATE_UNCFG = 65535
-
-# Identifiers from group of_bsn_pdu_slot_num
-BSN_PDU_SLOT_NUM_ANY = 255
-
-of_bsn_pdu_slot_num_map = {
-    255: 'BSN_PDU_SLOT_NUM_ANY',
-}
-
-# Identifiers from group ofp_action_type
-OFPAT_OUTPUT = 0
-OFPAT_COPY_TTL_OUT = 11
-OFPAT_COPY_TTL_IN = 12
-OFPAT_SET_MPLS_TTL = 15
-OFPAT_DEC_MPLS_TTL = 16
-OFPAT_PUSH_VLAN = 17
-OFPAT_POP_VLAN = 18
-OFPAT_PUSH_MPLS = 19
-OFPAT_POP_MPLS = 20
-OFPAT_SET_QUEUE = 21
-OFPAT_GROUP = 22
-OFPAT_SET_NW_TTL = 23
-OFPAT_DEC_NW_TTL = 24
-OFPAT_SET_FIELD = 25
-OFPAT_EXPERIMENTER = 65535
-
-ofp_action_type_map = {
-    0: 'OFPAT_OUTPUT',
-    11: 'OFPAT_COPY_TTL_OUT',
-    12: 'OFPAT_COPY_TTL_IN',
-    15: 'OFPAT_SET_MPLS_TTL',
-    16: 'OFPAT_DEC_MPLS_TTL',
-    17: 'OFPAT_PUSH_VLAN',
-    18: 'OFPAT_POP_VLAN',
-    19: 'OFPAT_PUSH_MPLS',
-    20: 'OFPAT_POP_MPLS',
-    21: 'OFPAT_SET_QUEUE',
-    22: 'OFPAT_GROUP',
-    23: 'OFPAT_SET_NW_TTL',
-    24: 'OFPAT_DEC_NW_TTL',
-    25: 'OFPAT_SET_FIELD',
-    65535: 'OFPAT_EXPERIMENTER',
-}
-
-# Identifiers from group ofp_bad_action_code
-OFPBAC_BAD_TYPE = 0
-OFPBAC_BAD_LEN = 1
-OFPBAC_BAD_EXPERIMENTER = 2
-OFPBAC_BAD_EXPERIMENTER_TYPE = 3
-OFPBAC_BAD_OUT_PORT = 4
-OFPBAC_BAD_ARGUMENT = 5
-OFPBAC_EPERM = 6
-OFPBAC_TOO_MANY = 7
-OFPBAC_BAD_QUEUE = 8
-OFPBAC_BAD_OUT_GROUP = 9
-OFPBAC_MATCH_INCONSISTENT = 10
-OFPBAC_UNSUPPORTED_ORDER = 11
-OFPBAC_BAD_TAG = 12
-OFPBAC_BAD_SET_TYPE = 13
-OFPBAC_BAD_SET_LEN = 14
-OFPBAC_BAD_SET_ARGUMENT = 15
-
-ofp_bad_action_code_map = {
-    0: 'OFPBAC_BAD_TYPE',
-    1: 'OFPBAC_BAD_LEN',
-    2: 'OFPBAC_BAD_EXPERIMENTER',
-    3: 'OFPBAC_BAD_EXPERIMENTER_TYPE',
-    4: 'OFPBAC_BAD_OUT_PORT',
-    5: 'OFPBAC_BAD_ARGUMENT',
-    6: 'OFPBAC_EPERM',
-    7: 'OFPBAC_TOO_MANY',
-    8: 'OFPBAC_BAD_QUEUE',
-    9: 'OFPBAC_BAD_OUT_GROUP',
-    10: 'OFPBAC_MATCH_INCONSISTENT',
-    11: 'OFPBAC_UNSUPPORTED_ORDER',
-    12: 'OFPBAC_BAD_TAG',
-    13: 'OFPBAC_BAD_SET_TYPE',
-    14: 'OFPBAC_BAD_SET_LEN',
-    15: 'OFPBAC_BAD_SET_ARGUMENT',
-}
-
-# Identifiers from group ofp_bad_instruction_code
-OFPBIC_UNKNOWN_INST = 0
-OFPBIC_UNSUP_INST = 1
-OFPBIC_BAD_TABLE_ID = 2
-OFPBIC_UNSUP_METADATA = 3
-OFPBIC_UNSUP_METADATA_MASK = 4
-OFPBIC_BAD_EXPERIMENTER = 5
-OFPBIC_BAD_EXPERIMENTER_TYPE = 6
-OFPBIC_BAD_LEN = 7
-OFPBIC_EPERM = 8
-
-ofp_bad_instruction_code_map = {
-    0: 'OFPBIC_UNKNOWN_INST',
-    1: 'OFPBIC_UNSUP_INST',
-    2: 'OFPBIC_BAD_TABLE_ID',
-    3: 'OFPBIC_UNSUP_METADATA',
-    4: 'OFPBIC_UNSUP_METADATA_MASK',
-    5: 'OFPBIC_BAD_EXPERIMENTER',
-    6: 'OFPBIC_BAD_EXPERIMENTER_TYPE',
-    7: 'OFPBIC_BAD_LEN',
-    8: 'OFPBIC_EPERM',
-}
-
-# Identifiers from group ofp_bad_match_code
-OFPBMC_BAD_TYPE = 0
-OFPBMC_BAD_LEN = 1
-OFPBMC_BAD_TAG = 2
-OFPBMC_BAD_DL_ADDR_MASK = 3
-OFPBMC_BAD_NW_ADDR_MASK = 4
-OFPBMC_BAD_WILDCARDS = 5
-OFPBMC_BAD_FIELD = 6
-OFPBMC_BAD_VALUE = 7
-OFPBMC_BAD_MASK = 8
-OFPBMC_BAD_PREREQ = 9
-OFPBMC_DUP_FIELD = 10
-OFPBMC_EPERM = 11
-
-ofp_bad_match_code_map = {
-    0: 'OFPBMC_BAD_TYPE',
-    1: 'OFPBMC_BAD_LEN',
-    2: 'OFPBMC_BAD_TAG',
-    3: 'OFPBMC_BAD_DL_ADDR_MASK',
-    4: 'OFPBMC_BAD_NW_ADDR_MASK',
-    5: 'OFPBMC_BAD_WILDCARDS',
-    6: 'OFPBMC_BAD_FIELD',
-    7: 'OFPBMC_BAD_VALUE',
-    8: 'OFPBMC_BAD_MASK',
-    9: 'OFPBMC_BAD_PREREQ',
-    10: 'OFPBMC_DUP_FIELD',
-    11: 'OFPBMC_EPERM',
-}
-
-# Identifiers from group ofp_bad_request_code
-OFPBRC_BAD_VERSION = 0
-OFPBRC_BAD_TYPE = 1
-OFPBRC_BAD_STAT = 2
-OFPBRC_BAD_EXPERIMENTER = 3
-OFPBRC_BAD_EXPERIMENTER_TYPE = 4
-OFPBRC_EPERM = 5
-OFPBRC_BAD_LEN = 6
-OFPBRC_BUFFER_EMPTY = 7
-OFPBRC_BUFFER_UNKNOWN = 8
-OFPBRC_BAD_TABLE_ID = 9
-OFPBRC_IS_SLAVE = 10
-OFPBRC_BAD_PORT = 11
-OFPBRC_BAD_PACKET = 12
-
-ofp_bad_request_code_map = {
-    0: 'OFPBRC_BAD_VERSION',
-    1: 'OFPBRC_BAD_TYPE',
-    2: 'OFPBRC_BAD_STAT',
-    3: 'OFPBRC_BAD_EXPERIMENTER',
-    4: 'OFPBRC_BAD_EXPERIMENTER_TYPE',
-    5: 'OFPBRC_EPERM',
-    6: 'OFPBRC_BAD_LEN',
-    7: 'OFPBRC_BUFFER_EMPTY',
-    8: 'OFPBRC_BUFFER_UNKNOWN',
-    9: 'OFPBRC_BAD_TABLE_ID',
-    10: 'OFPBRC_IS_SLAVE',
-    11: 'OFPBRC_BAD_PORT',
-    12: 'OFPBRC_BAD_PACKET',
-}
-
-# Identifiers from group ofp_bsn_tcp_flag
-OFP_BSN_TCP_FLAG_FIN = 1
-OFP_BSN_TCP_FLAG_SYN = 2
-OFP_BSN_TCP_FLAG_RST = 4
-OFP_BSN_TCP_FLAG_PSH = 8
-OFP_BSN_TCP_FLAG_ACK = 16
-OFP_BSN_TCP_FLAG_URG = 32
-OFP_BSN_TCP_FLAG_ECE = 64
-OFP_BSN_TCP_FLAG_CWR = 128
-OFP_BSN_TCP_FLAG_NS = 256
-
-ofp_bsn_tcp_flag_map = {
-    1: 'OFP_BSN_TCP_FLAG_FIN',
-    2: 'OFP_BSN_TCP_FLAG_SYN',
-    4: 'OFP_BSN_TCP_FLAG_RST',
-    8: 'OFP_BSN_TCP_FLAG_PSH',
-    16: 'OFP_BSN_TCP_FLAG_ACK',
-    32: 'OFP_BSN_TCP_FLAG_URG',
-    64: 'OFP_BSN_TCP_FLAG_ECE',
-    128: 'OFP_BSN_TCP_FLAG_CWR',
-    256: 'OFP_BSN_TCP_FLAG_NS',
-}
-
-# Identifiers from group ofp_bsn_vport_l2gre_flags
-OF_BSN_VPORT_L2GRE_LOCAL_MAC_IS_VALID = 1
-OF_BSN_VPORT_L2GRE_DSCP_ASSIGN = 2
-OF_BSN_VPORT_L2GRE_DSCP_COPY = 4
-OF_BSN_VPORT_L2GRE_LOOPBACK_IS_VALID = 8
-OF_BSN_VPORT_L2GRE_RATE_LIMIT_IS_VALID = 16
-
-ofp_bsn_vport_l2gre_flags_map = {
-    1: 'OF_BSN_VPORT_L2GRE_LOCAL_MAC_IS_VALID',
-    2: 'OF_BSN_VPORT_L2GRE_DSCP_ASSIGN',
-    4: 'OF_BSN_VPORT_L2GRE_DSCP_COPY',
-    8: 'OF_BSN_VPORT_L2GRE_LOOPBACK_IS_VALID',
-    16: 'OF_BSN_VPORT_L2GRE_RATE_LIMIT_IS_VALID',
-}
-
-# Identifiers from group ofp_bsn_vport_q_in_q_untagged
-OF_BSN_VPORT_Q_IN_Q_UNTAGGED = 65535
-
-ofp_bsn_vport_q_in_q_untagged_map = {
-    65535: 'OF_BSN_VPORT_Q_IN_Q_UNTAGGED',
-}
-
-# Identifiers from group ofp_bsn_vport_status
-OF_BSN_VPORT_STATUS_OK = 0
-OF_BSN_VPORT_STATUS_FAILED = 1
-
-ofp_bsn_vport_status_map = {
-    0: 'OF_BSN_VPORT_STATUS_OK',
-    1: 'OF_BSN_VPORT_STATUS_FAILED',
-}
-
-# Identifiers from group ofp_capabilities
-OFPC_FLOW_STATS = 1
-OFPC_TABLE_STATS = 2
-OFPC_PORT_STATS = 4
-OFPC_GROUP_STATS = 8
-OFPC_IP_REASM = 32
-OFPC_QUEUE_STATS = 64
-OFPC_PORT_BLOCKED = 256
-
-ofp_capabilities_map = {
-    1: 'OFPC_FLOW_STATS',
-    2: 'OFPC_TABLE_STATS',
-    4: 'OFPC_PORT_STATS',
-    8: 'OFPC_GROUP_STATS',
-    32: 'OFPC_IP_REASM',
-    64: 'OFPC_QUEUE_STATS',
-    256: 'OFPC_PORT_BLOCKED',
-}
-
-# Identifiers from group ofp_config_flags
-OFPC_FRAG_NORMAL = 0
-OFPC_FRAG_DROP = 1
-OFPC_FRAG_REASM = 2
-OFPC_FRAG_MASK = 3
-OFPC_INVALID_TTL_TO_CONTROLLER = 4
-
-ofp_config_flags_map = {
-    0: 'OFPC_FRAG_NORMAL',
-    1: 'OFPC_FRAG_DROP',
-    2: 'OFPC_FRAG_REASM',
-    3: 'OFPC_FRAG_MASK',
-    4: 'OFPC_INVALID_TTL_TO_CONTROLLER',
-}
-
-# Identifiers from group ofp_controller_max_len
-OFPCML_MAX = 65509
-OFPCML_NO_BUFFER = 65535
-
-ofp_controller_max_len_map = {
-    65509: 'OFPCML_MAX',
-    65535: 'OFPCML_NO_BUFFER',
-}
-
-# Identifiers from group ofp_controller_role
-OFPCR_ROLE_NOCHANGE = 0
-OFPCR_ROLE_EQUAL = 1
-OFPCR_ROLE_MASTER = 2
-OFPCR_ROLE_SLAVE = 3
-
-ofp_controller_role_map = {
-    0: 'OFPCR_ROLE_NOCHANGE',
-    1: 'OFPCR_ROLE_EQUAL',
-    2: 'OFPCR_ROLE_MASTER',
-    3: 'OFPCR_ROLE_SLAVE',
-}
-
-# Identifiers from group ofp_error_type
-OFPET_HELLO_FAILED = 0
-OFPET_BAD_REQUEST = 1
-OFPET_BAD_ACTION = 2
-OFPET_BAD_INSTRUCTION = 3
-OFPET_BAD_MATCH = 4
-OFPET_FLOW_MOD_FAILED = 5
-OFPET_GROUP_MOD_FAILED = 6
-OFPET_PORT_MOD_FAILED = 7
-OFPET_TABLE_MOD_FAILED = 8
-OFPET_QUEUE_OP_FAILED = 9
-OFPET_SWITCH_CONFIG_FAILED = 10
-OFPET_ROLE_REQUEST_FAILED = 11
-OFPET_EXPERIMENTER = 65535
-
-ofp_error_type_map = {
-    0: 'OFPET_HELLO_FAILED',
-    1: 'OFPET_BAD_REQUEST',
-    2: 'OFPET_BAD_ACTION',
-    3: 'OFPET_BAD_INSTRUCTION',
-    4: 'OFPET_BAD_MATCH',
-    5: 'OFPET_FLOW_MOD_FAILED',
-    6: 'OFPET_GROUP_MOD_FAILED',
-    7: 'OFPET_PORT_MOD_FAILED',
-    8: 'OFPET_TABLE_MOD_FAILED',
-    9: 'OFPET_QUEUE_OP_FAILED',
-    10: 'OFPET_SWITCH_CONFIG_FAILED',
-    11: 'OFPET_ROLE_REQUEST_FAILED',
-    65535: 'OFPET_EXPERIMENTER',
-}
-
-# Identifiers from group ofp_flow_mod_command
-OFPFC_ADD = 0
-OFPFC_MODIFY = 1
-OFPFC_MODIFY_STRICT = 2
-OFPFC_DELETE = 3
-OFPFC_DELETE_STRICT = 4
-
-ofp_flow_mod_command_map = {
-    0: 'OFPFC_ADD',
-    1: 'OFPFC_MODIFY',
-    2: 'OFPFC_MODIFY_STRICT',
-    3: 'OFPFC_DELETE',
-    4: 'OFPFC_DELETE_STRICT',
-}
-
-# Identifiers from group ofp_flow_mod_failed_code
-OFPFMFC_UNKNOWN = 0
-OFPFMFC_TABLE_FULL = 1
-OFPFMFC_BAD_TABLE_ID = 2
-OFPFMFC_OVERLAP = 3
-OFPFMFC_EPERM = 4
-OFPFMFC_BAD_TIMEOUT = 5
-OFPFMFC_BAD_COMMAND = 6
-OFPFMFC_BAD_FLAGS = 7
-
-ofp_flow_mod_failed_code_map = {
-    0: 'OFPFMFC_UNKNOWN',
-    1: 'OFPFMFC_TABLE_FULL',
-    2: 'OFPFMFC_BAD_TABLE_ID',
-    3: 'OFPFMFC_OVERLAP',
-    4: 'OFPFMFC_EPERM',
-    5: 'OFPFMFC_BAD_TIMEOUT',
-    6: 'OFPFMFC_BAD_COMMAND',
-    7: 'OFPFMFC_BAD_FLAGS',
-}
-
-# Identifiers from group ofp_flow_mod_flags
-OFPFF_SEND_FLOW_REM = 1
-OFPFF_CHECK_OVERLAP = 2
-OFPFF_RESET_COUNTS = 4
-
-ofp_flow_mod_flags_map = {
-    1: 'OFPFF_SEND_FLOW_REM',
-    2: 'OFPFF_CHECK_OVERLAP',
-    4: 'OFPFF_RESET_COUNTS',
-}
-
-# Identifiers from group ofp_flow_removed_reason
-OFPRR_IDLE_TIMEOUT = 0
-OFPRR_HARD_TIMEOUT = 1
-OFPRR_DELETE = 2
-OFPRR_GROUP_DELETE = 3
-
-ofp_flow_removed_reason_map = {
-    0: 'OFPRR_IDLE_TIMEOUT',
-    1: 'OFPRR_HARD_TIMEOUT',
-    2: 'OFPRR_DELETE',
-    3: 'OFPRR_GROUP_DELETE',
-}
-
-# Identifiers from group ofp_group
-OFPG_MAX = 4294967040
-OFPG_ALL = 4294967292
-OFPG_ANY = 4294967295
-
-ofp_group_map = {
-    4294967040: 'OFPG_MAX',
-    4294967292: 'OFPG_ALL',
-    4294967295: 'OFPG_ANY',
-}
-
-# Identifiers from group ofp_group_capabilities
-OFPGFC_SELECT_WEIGHT = 1
-OFPGFC_SELECT_LIVENESS = 2
-OFPGFC_CHAINING = 4
-OFPGFC_CHAINING_CHECKS = 8
-
-ofp_group_capabilities_map = {
-    1: 'OFPGFC_SELECT_WEIGHT',
-    2: 'OFPGFC_SELECT_LIVENESS',
-    4: 'OFPGFC_CHAINING',
-    8: 'OFPGFC_CHAINING_CHECKS',
-}
-
-# Identifiers from group ofp_group_mod_command
-OFPGC_ADD = 0
-OFPGC_MODIFY = 1
-OFPGC_DELETE = 2
-
-ofp_group_mod_command_map = {
-    0: 'OFPGC_ADD',
-    1: 'OFPGC_MODIFY',
-    2: 'OFPGC_DELETE',
-}
-
-# Identifiers from group ofp_group_mod_failed_code
-OFPGMFC_GROUP_EXISTS = 0
-OFPGMFC_INVALID_GROUP = 1
-OFPGMFC_WEIGHT_UNSUPPORTED = 2
-OFPGMFC_OUT_OF_GROUPS = 3
-OFPGMFC_OUT_OF_BUCKETS = 4
-OFPGMFC_CHAINING_UNSUPPORTED = 5
-OFPGMFC_WATCH_UNSUPPORTED = 6
-OFPGMFC_LOOP = 7
-OFPGMFC_UNKNOWN_GROUP = 8
-OFPGMFC_CHAINED_GROUP = 9
-OFPGMFC_BAD_TYPE = 10
-OFPGMFC_BAD_COMMAND = 11
-OFPGMFC_BAD_BUCKET = 12
-OFPGMFC_BAD_WATCH = 13
-OFPGMFC_EPERM = 14
-
-ofp_group_mod_failed_code_map = {
-    0: 'OFPGMFC_GROUP_EXISTS',
-    1: 'OFPGMFC_INVALID_GROUP',
-    2: 'OFPGMFC_WEIGHT_UNSUPPORTED',
-    3: 'OFPGMFC_OUT_OF_GROUPS',
-    4: 'OFPGMFC_OUT_OF_BUCKETS',
-    5: 'OFPGMFC_CHAINING_UNSUPPORTED',
-    6: 'OFPGMFC_WATCH_UNSUPPORTED',
-    7: 'OFPGMFC_LOOP',
-    8: 'OFPGMFC_UNKNOWN_GROUP',
-    9: 'OFPGMFC_CHAINED_GROUP',
-    10: 'OFPGMFC_BAD_TYPE',
-    11: 'OFPGMFC_BAD_COMMAND',
-    12: 'OFPGMFC_BAD_BUCKET',
-    13: 'OFPGMFC_BAD_WATCH',
-    14: 'OFPGMFC_EPERM',
-}
-
-# Identifiers from group ofp_group_type
-OFPGT_ALL = 0
-OFPGT_SELECT = 1
-OFPGT_INDIRECT = 2
-OFPGT_FF = 3
-
-ofp_group_type_map = {
-    0: 'OFPGT_ALL',
-    1: 'OFPGT_SELECT',
-    2: 'OFPGT_INDIRECT',
-    3: 'OFPGT_FF',
-}
-
-# Identifiers from group ofp_hello_failed_code
-OFPHFC_INCOMPATIBLE = 0
-OFPHFC_EPERM = 1
-
-ofp_hello_failed_code_map = {
-    0: 'OFPHFC_INCOMPATIBLE',
-    1: 'OFPHFC_EPERM',
-}
-
-# Identifiers from group ofp_instruction_type
-OFPIT_GOTO_TABLE = 1
-OFPIT_WRITE_METADATA = 2
-OFPIT_WRITE_ACTIONS = 3
-OFPIT_APPLY_ACTIONS = 4
-OFPIT_CLEAR_ACTIONS = 5
-OFPIT_EXPERIMENTER = 65535
-
-ofp_instruction_type_map = {
-    1: 'OFPIT_GOTO_TABLE',
-    2: 'OFPIT_WRITE_METADATA',
-    3: 'OFPIT_WRITE_ACTIONS',
-    4: 'OFPIT_APPLY_ACTIONS',
-    5: 'OFPIT_CLEAR_ACTIONS',
-    65535: 'OFPIT_EXPERIMENTER',
-}
-
-# Identifiers from group ofp_match_type
-OFPMT_STANDARD = 0
-OFPMT_OXM = 1
-
-ofp_match_type_map = {
-    0: 'OFPMT_STANDARD',
-    1: 'OFPMT_OXM',
-}
-
-# Identifiers from group ofp_oxm_class
-OFPXMC_NXM_0 = 0
-OFPXMC_NXM_1 = 1
-OFPXMC_OPENFLOW_BASIC = 32768
-OFPXMC_EXPERIMENTER = 65535
-
-ofp_oxm_class_map = {
-    0: 'OFPXMC_NXM_0',
-    1: 'OFPXMC_NXM_1',
-    32768: 'OFPXMC_OPENFLOW_BASIC',
-    65535: 'OFPXMC_EXPERIMENTER',
-}
-
-# Identifiers from group ofp_packet_in_reason
-OFPR_NO_MATCH = 0
-OFPR_ACTION = 1
-OFPR_INVALID_TTL = 2
-
-ofp_packet_in_reason_map = {
-    0: 'OFPR_NO_MATCH',
-    1: 'OFPR_ACTION',
-    2: 'OFPR_INVALID_TTL',
-}
-
-# Identifiers from group ofp_port
-OFPP_MAX = 4294967040
-OFPP_IN_PORT = 4294967288
-OFPP_TABLE = 4294967289
-OFPP_NORMAL = 4294967290
-OFPP_FLOOD = 4294967291
-OFPP_ALL = 4294967292
-OFPP_CONTROLLER = 4294967293
-OFPP_LOCAL = 4294967294
-OFPP_ANY = 4294967295
-
-ofp_port_map = {
-    4294967040: 'OFPP_MAX',
-    4294967288: 'OFPP_IN_PORT',
-    4294967289: 'OFPP_TABLE',
-    4294967290: 'OFPP_NORMAL',
-    4294967291: 'OFPP_FLOOD',
-    4294967292: 'OFPP_ALL',
-    4294967293: 'OFPP_CONTROLLER',
-    4294967294: 'OFPP_LOCAL',
-    4294967295: 'OFPP_ANY',
-}
-
-# Identifiers from group ofp_port_config
-OFPPC_PORT_DOWN = 1
-OFPPC_NO_RECV = 4
-OFPPC_NO_FWD = 32
-OFPPC_NO_PACKET_IN = 64
-OFPPC_BSN_MIRROR_DEST = 2147483648
-
-ofp_port_config_map = {
-    1: 'OFPPC_PORT_DOWN',
-    4: 'OFPPC_NO_RECV',
-    32: 'OFPPC_NO_FWD',
-    64: 'OFPPC_NO_PACKET_IN',
-    2147483648: 'OFPPC_BSN_MIRROR_DEST',
-}
-
-# Identifiers from group ofp_port_features
-OFPPF_10MB_HD = 1
-OFPPF_10MB_FD = 2
-OFPPF_100MB_HD = 4
-OFPPF_100MB_FD = 8
-OFPPF_1GB_HD = 16
-OFPPF_1GB_FD = 32
-OFPPF_10GB_FD = 64
-OFPPF_40GB_FD = 128
-OFPPF_100GB_FD = 256
-OFPPF_1TB_FD = 512
-OFPPF_OTHER = 1024
-OFPPF_COPPER = 2048
-OFPPF_FIBER = 4096
-OFPPF_AUTONEG = 8192
-OFPPF_PAUSE = 16384
-OFPPF_PAUSE_ASYM = 32768
-
-ofp_port_features_map = {
-    1: 'OFPPF_10MB_HD',
-    2: 'OFPPF_10MB_FD',
-    4: 'OFPPF_100MB_HD',
-    8: 'OFPPF_100MB_FD',
-    16: 'OFPPF_1GB_HD',
-    32: 'OFPPF_1GB_FD',
-    64: 'OFPPF_10GB_FD',
-    128: 'OFPPF_40GB_FD',
-    256: 'OFPPF_100GB_FD',
-    512: 'OFPPF_1TB_FD',
-    1024: 'OFPPF_OTHER',
-    2048: 'OFPPF_COPPER',
-    4096: 'OFPPF_FIBER',
-    8192: 'OFPPF_AUTONEG',
-    16384: 'OFPPF_PAUSE',
-    32768: 'OFPPF_PAUSE_ASYM',
-}
-
-# Identifiers from group ofp_port_mod_failed_code
-OFPPMFC_BAD_PORT = 0
-OFPPMFC_BAD_HW_ADDR = 1
-OFPPMFC_BAD_CONFIG = 2
-OFPPMFC_BAD_ADVERTISE = 3
-OFPPMFC_EPERM = 4
-
-ofp_port_mod_failed_code_map = {
-    0: 'OFPPMFC_BAD_PORT',
-    1: 'OFPPMFC_BAD_HW_ADDR',
-    2: 'OFPPMFC_BAD_CONFIG',
-    3: 'OFPPMFC_BAD_ADVERTISE',
-    4: 'OFPPMFC_EPERM',
-}
-
-# Identifiers from group ofp_port_reason
-OFPPR_ADD = 0
-OFPPR_DELETE = 1
-OFPPR_MODIFY = 2
-
-ofp_port_reason_map = {
-    0: 'OFPPR_ADD',
-    1: 'OFPPR_DELETE',
-    2: 'OFPPR_MODIFY',
-}
-
-# Identifiers from group ofp_port_state
-OFPPS_LINK_DOWN = 1
-OFPPS_BLOCKED = 2
-OFPPS_LIVE = 4
-
-ofp_port_state_map = {
-    1: 'OFPPS_LINK_DOWN',
-    2: 'OFPPS_BLOCKED',
-    4: 'OFPPS_LIVE',
-}
-
-# Identifiers from group ofp_queue_op_failed_code
-OFPQOFC_BAD_PORT = 0
-OFPQOFC_BAD_QUEUE = 1
-OFPQOFC_EPERM = 2
-
-ofp_queue_op_failed_code_map = {
-    0: 'OFPQOFC_BAD_PORT',
-    1: 'OFPQOFC_BAD_QUEUE',
-    2: 'OFPQOFC_EPERM',
-}
-
-# Identifiers from group ofp_queue_properties
-OFPQT_MIN_RATE = 1
-OFPQT_MAX_RATE = 2
-OFPQT_EXPERIMENTER = 65535
-
-ofp_queue_properties_map = {
-    1: 'OFPQT_MIN_RATE',
-    2: 'OFPQT_MAX_RATE',
-    65535: 'OFPQT_EXPERIMENTER',
-}
-
-# Identifiers from group ofp_role_request_failed_code
-OFPRRFC_STALE = 0
-OFPRRFC_UNSUP = 1
-OFPRRFC_BAD_ROLE = 2
-
-ofp_role_request_failed_code_map = {
-    0: 'OFPRRFC_STALE',
-    1: 'OFPRRFC_UNSUP',
-    2: 'OFPRRFC_BAD_ROLE',
-}
-
-# Identifiers from group ofp_stats_reply_flags
-OFPSF_REPLY_MORE = 1
-
-ofp_stats_reply_flags_map = {
-    1: 'OFPSF_REPLY_MORE',
-}
-
-# Identifiers from group ofp_stats_request_flags
-
-ofp_stats_request_flags_map = {
-}
-
-# Identifiers from group ofp_stats_type
-OFPST_DESC = 0
-OFPST_FLOW = 1
-OFPST_AGGREGATE = 2
-OFPST_TABLE = 3
-OFPST_PORT = 4
-OFPST_QUEUE = 5
-OFPST_GROUP = 6
-OFPST_GROUP_DESC = 7
-OFPST_GROUP_FEATURES = 8
-OFPST_EXPERIMENTER = 65535
-
-ofp_stats_type_map = {
-    0: 'OFPST_DESC',
-    1: 'OFPST_FLOW',
-    2: 'OFPST_AGGREGATE',
-    3: 'OFPST_TABLE',
-    4: 'OFPST_PORT',
-    5: 'OFPST_QUEUE',
-    6: 'OFPST_GROUP',
-    7: 'OFPST_GROUP_DESC',
-    8: 'OFPST_GROUP_FEATURES',
-    65535: 'OFPST_EXPERIMENTER',
-}
-
-# Identifiers from group ofp_switch_config_failed_code
-OFPSCFC_BAD_FLAGS = 0
-OFPSCFC_BAD_LEN = 1
-OFPSCFC_EPERM = 2
-
-ofp_switch_config_failed_code_map = {
-    0: 'OFPSCFC_BAD_FLAGS',
-    1: 'OFPSCFC_BAD_LEN',
-    2: 'OFPSCFC_EPERM',
-}
-
-# Identifiers from group ofp_table
-OFPTT_MAX = 254
-OFPTT_ALL = 255
-
-ofp_table_map = {
-    254: 'OFPTT_MAX',
-    255: 'OFPTT_ALL',
-}
-
-# Identifiers from group ofp_table_config
-OFPTC_TABLE_MISS_CONTROLLER = 0
-OFPTC_TABLE_MISS_CONTINUE = 1
-OFPTC_TABLE_MISS_DROP = 2
-OFPTC_TABLE_MISS_MASK = 3
-
-ofp_table_config_map = {
-    0: 'OFPTC_TABLE_MISS_CONTROLLER',
-    1: 'OFPTC_TABLE_MISS_CONTINUE',
-    2: 'OFPTC_TABLE_MISS_DROP',
-    3: 'OFPTC_TABLE_MISS_MASK',
-}
-
-# Identifiers from group ofp_table_mod_failed_code
-OFPTMFC_BAD_TABLE = 0
-OFPTMFC_BAD_CONFIG = 1
-OFPTMFC_EPERM = 2
-
-ofp_table_mod_failed_code_map = {
-    0: 'OFPTMFC_BAD_TABLE',
-    1: 'OFPTMFC_BAD_CONFIG',
-    2: 'OFPTMFC_EPERM',
-}
-
-# Identifiers from group ofp_type
-OFPT_HELLO = 0
-OFPT_ERROR = 1
-OFPT_ECHO_REQUEST = 2
-OFPT_ECHO_REPLY = 3
-OFPT_EXPERIMENTER = 4
-OFPT_FEATURES_REQUEST = 5
-OFPT_FEATURES_REPLY = 6
-OFPT_GET_CONFIG_REQUEST = 7
-OFPT_GET_CONFIG_REPLY = 8
-OFPT_SET_CONFIG = 9
-OFPT_PACKET_IN = 10
-OFPT_FLOW_REMOVED = 11
-OFPT_PORT_STATUS = 12
-OFPT_PACKET_OUT = 13
-OFPT_FLOW_MOD = 14
-OFPT_GROUP_MOD = 15
-OFPT_PORT_MOD = 16
-OFPT_TABLE_MOD = 17
-OFPT_STATS_REQUEST = 18
-OFPT_STATS_REPLY = 19
-OFPT_BARRIER_REQUEST = 20
-OFPT_BARRIER_REPLY = 21
-OFPT_QUEUE_GET_CONFIG_REQUEST = 22
-OFPT_QUEUE_GET_CONFIG_REPLY = 23
-OFPT_ROLE_REQUEST = 24
-OFPT_ROLE_REPLY = 25
-
-ofp_type_map = {
-    0: 'OFPT_HELLO',
-    1: 'OFPT_ERROR',
-    2: 'OFPT_ECHO_REQUEST',
-    3: 'OFPT_ECHO_REPLY',
-    4: 'OFPT_EXPERIMENTER',
-    5: 'OFPT_FEATURES_REQUEST',
-    6: 'OFPT_FEATURES_REPLY',
-    7: 'OFPT_GET_CONFIG_REQUEST',
-    8: 'OFPT_GET_CONFIG_REPLY',
-    9: 'OFPT_SET_CONFIG',
-    10: 'OFPT_PACKET_IN',
-    11: 'OFPT_FLOW_REMOVED',
-    12: 'OFPT_PORT_STATUS',
-    13: 'OFPT_PACKET_OUT',
-    14: 'OFPT_FLOW_MOD',
-    15: 'OFPT_GROUP_MOD',
-    16: 'OFPT_PORT_MOD',
-    17: 'OFPT_TABLE_MOD',
-    18: 'OFPT_STATS_REQUEST',
-    19: 'OFPT_STATS_REPLY',
-    20: 'OFPT_BARRIER_REQUEST',
-    21: 'OFPT_BARRIER_REPLY',
-    22: 'OFPT_QUEUE_GET_CONFIG_REQUEST',
-    23: 'OFPT_QUEUE_GET_CONFIG_REPLY',
-    24: 'OFPT_ROLE_REQUEST',
-    25: 'OFPT_ROLE_REPLY',
-}
-
-# Identifiers from group ofp_vlan_id
-OFPVID_NONE = 0
-OFPVID_PRESENT = 4096
-
-ofp_vlan_id_map = {
-    0: 'OFPVID_NONE',
-    4096: 'OFPVID_PRESENT',
-}
-
diff --git a/python/ofagent/loxi/of12/instruction.py b/python/ofagent/loxi/of12/instruction.py
deleted file mode 100644
index 1e7cb62..0000000
--- a/python/ofagent/loxi/of12/instruction.py
+++ /dev/null
@@ -1,386 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template module.py
-# Do not modify
-
-import struct
-import loxi
-import util
-import loxi.generic_util
-
-import sys
-ofp = sys.modules['loxi.of12']
-
-class instruction(loxi.OFObject):
-    subtypes = {}
-
-
-    def __init__(self, type=None):
-        if type != None:
-            self.type = type
-        else:
-            self.type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 0)
-        subclass = instruction.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = instruction()
-        obj.type = reader.read("!H")[0]
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type != other.type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("instruction {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-
-class apply_actions(instruction):
-    type = 4
-
-    def __init__(self, actions=None):
-        if actions != None:
-            self.actions = actions
-        else:
-            self.actions = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.actions))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = apply_actions()
-        _type = reader.read("!H")[0]
-        assert(_type == 4)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        obj.actions = loxi.generic_util.unpack_list(reader, ofp.action.action.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.actions != other.actions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("apply_actions {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("actions = ");
-                q.pp(self.actions)
-            q.breakable()
-        q.text('}')
-
-instruction.subtypes[4] = apply_actions
-
-class clear_actions(instruction):
-    type = 5
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = clear_actions()
-        _type = reader.read("!H")[0]
-        assert(_type == 5)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("clear_actions {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-instruction.subtypes[5] = clear_actions
-
-class experimenter(instruction):
-    subtypes = {}
-
-    type = 65535
-
-    def __init__(self, experimenter=None, data=None):
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 4)
-        subclass = experimenter.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = experimenter()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.experimenter = reader.read("!L")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.experimenter != other.experimenter: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("experimenter {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-instruction.subtypes[65535] = experimenter
-
-class goto_table(instruction):
-    type = 1
-
-    def __init__(self, table_id=None):
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append('\x00' * 3)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = goto_table()
-        _type = reader.read("!H")[0]
-        assert(_type == 1)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.table_id = reader.read("!B")[0]
-        reader.skip(3)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.table_id != other.table_id: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("goto_table {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-            q.breakable()
-        q.text('}')
-
-instruction.subtypes[1] = goto_table
-
-class write_actions(instruction):
-    type = 3
-
-    def __init__(self, actions=None):
-        if actions != None:
-            self.actions = actions
-        else:
-            self.actions = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.actions))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = write_actions()
-        _type = reader.read("!H")[0]
-        assert(_type == 3)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        obj.actions = loxi.generic_util.unpack_list(reader, ofp.action.action.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.actions != other.actions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("write_actions {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("actions = ");
-                q.pp(self.actions)
-            q.breakable()
-        q.text('}')
-
-instruction.subtypes[3] = write_actions
-
-class write_metadata(instruction):
-    type = 2
-
-    def __init__(self, metadata=None, metadata_mask=None):
-        if metadata != None:
-            self.metadata = metadata
-        else:
-            self.metadata = 0
-        if metadata_mask != None:
-            self.metadata_mask = metadata_mask
-        else:
-            self.metadata_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!Q", self.metadata))
-        packed.append(struct.pack("!Q", self.metadata_mask))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = write_metadata()
-        _type = reader.read("!H")[0]
-        assert(_type == 2)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        obj.metadata = reader.read("!Q")[0]
-        obj.metadata_mask = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.metadata != other.metadata: return False
-        if self.metadata_mask != other.metadata_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("write_metadata {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("metadata = ");
-                q.text("%#x" % self.metadata)
-                q.text(","); q.breakable()
-                q.text("metadata_mask = ");
-                q.text("%#x" % self.metadata_mask)
-            q.breakable()
-        q.text('}')
-
-instruction.subtypes[2] = write_metadata
-
-
diff --git a/python/ofagent/loxi/of12/message.py b/python/ofagent/loxi/of12/message.py
deleted file mode 100644
index 9c0da0d..0000000
--- a/python/ofagent/loxi/of12/message.py
+++ /dev/null
@@ -1,8444 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template module.py
-# Do not modify
-
-import struct
-import loxi
-import util
-import loxi.generic_util
-
-import sys
-ofp = sys.modules['loxi.of12']
-
-class message(loxi.OFObject):
-    subtypes = {}
-
-    version = 3
-
-    def __init__(self, type=None, xid=None):
-        if type != None:
-            self.type = type
-        else:
-            self.type = 0
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('B', 1)
-        subclass = message.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = message()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        obj.type = reader.read("!B")[0]
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type != other.type: return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("message {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-
-class stats_reply(message):
-    subtypes = {}
-
-    version = 3
-    type = 19
-
-    def __init__(self, xid=None, stats_type=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if stats_type != None:
-            self.stats_type = stats_type
-        else:
-            self.stats_type = 0
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 8)
-        subclass = stats_reply.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.stats_type = reader.read("!H")[0]
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.stats_type != other.stats_type: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[19] = stats_reply
-
-class aggregate_stats_reply(stats_reply):
-    version = 3
-    type = 19
-    stats_type = 2
-
-    def __init__(self, xid=None, flags=None, packet_count=None, byte_count=None, flow_count=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if packet_count != None:
-            self.packet_count = packet_count
-        else:
-            self.packet_count = 0
-        if byte_count != None:
-            self.byte_count = byte_count
-        else:
-            self.byte_count = 0
-        if flow_count != None:
-            self.flow_count = flow_count
-        else:
-            self.flow_count = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!Q", self.packet_count))
-        packed.append(struct.pack("!Q", self.byte_count))
-        packed.append(struct.pack("!L", self.flow_count))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = aggregate_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 2)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.packet_count = reader.read("!Q")[0]
-        obj.byte_count = reader.read("!Q")[0]
-        obj.flow_count = reader.read("!L")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.packet_count != other.packet_count: return False
-        if self.byte_count != other.byte_count: return False
-        if self.flow_count != other.flow_count: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("aggregate_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("packet_count = ");
-                q.text("%#x" % self.packet_count)
-                q.text(","); q.breakable()
-                q.text("byte_count = ");
-                q.text("%#x" % self.byte_count)
-                q.text(","); q.breakable()
-                q.text("flow_count = ");
-                q.text("%#x" % self.flow_count)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[2] = aggregate_stats_reply
-
-class stats_request(message):
-    subtypes = {}
-
-    version = 3
-    type = 18
-
-    def __init__(self, xid=None, stats_type=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if stats_type != None:
-            self.stats_type = stats_type
-        else:
-            self.stats_type = 0
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 8)
-        subclass = stats_request.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.stats_type = reader.read("!H")[0]
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.stats_type != other.stats_type: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[18] = stats_request
-
-class aggregate_stats_request(stats_request):
-    version = 3
-    type = 18
-    stats_type = 2
-
-    def __init__(self, xid=None, flags=None, table_id=None, out_port=None, out_group=None, cookie=None, cookie_mask=None, match=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if out_port != None:
-            self.out_port = out_port
-        else:
-            self.out_port = 0
-        if out_group != None:
-            self.out_group = out_group
-        else:
-            self.out_group = 0
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if cookie_mask != None:
-            self.cookie_mask = cookie_mask
-        else:
-            self.cookie_mask = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append('\x00' * 3)
-        packed.append(util.pack_port_no(self.out_port))
-        packed.append(struct.pack("!L", self.out_group))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(struct.pack("!Q", self.cookie_mask))
-        packed.append(self.match.pack())
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = aggregate_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 2)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.table_id = reader.read("!B")[0]
-        reader.skip(3)
-        obj.out_port = util.unpack_port_no(reader)
-        obj.out_group = reader.read("!L")[0]
-        reader.skip(4)
-        obj.cookie = reader.read("!Q")[0]
-        obj.cookie_mask = reader.read("!Q")[0]
-        obj.match = ofp.match.unpack(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.table_id != other.table_id: return False
-        if self.out_port != other.out_port: return False
-        if self.out_group != other.out_group: return False
-        if self.cookie != other.cookie: return False
-        if self.cookie_mask != other.cookie_mask: return False
-        if self.match != other.match: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("aggregate_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("out_port = ");
-                q.text(util.pretty_port(self.out_port))
-                q.text(","); q.breakable()
-                q.text("out_group = ");
-                q.text("%#x" % self.out_group)
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("cookie_mask = ");
-                q.text("%#x" % self.cookie_mask)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[2] = aggregate_stats_request
-
-class error_msg(message):
-    subtypes = {}
-
-    version = 3
-    type = 1
-
-    def __init__(self, xid=None, err_type=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if err_type != None:
-            self.err_type = err_type
-        else:
-            self.err_type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 8)
-        subclass = error_msg.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.err_type = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.err_type != other.err_type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-message.subtypes[1] = error_msg
-
-class bad_action_error_msg(error_msg):
-    version = 3
-    type = 1
-    err_type = 2
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bad_action_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 2)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bad_action_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[2] = bad_action_error_msg
-
-class bad_instruction_error_msg(error_msg):
-    version = 3
-    type = 1
-    err_type = 3
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bad_instruction_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 3)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bad_instruction_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[3] = bad_instruction_error_msg
-
-class bad_match_error_msg(error_msg):
-    version = 3
-    type = 1
-    err_type = 4
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bad_match_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 4)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bad_match_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[4] = bad_match_error_msg
-
-class bad_request_error_msg(error_msg):
-    version = 3
-    type = 1
-    err_type = 1
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bad_request_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 1)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bad_request_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[1] = bad_request_error_msg
-
-class barrier_reply(message):
-    version = 3
-    type = 21
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = barrier_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 21)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("barrier_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-message.subtypes[21] = barrier_reply
-
-class barrier_request(message):
-    version = 3
-    type = 20
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = barrier_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 20)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("barrier_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-message.subtypes[20] = barrier_request
-
-class experimenter(message):
-    subtypes = {}
-
-    version = 3
-    type = 4
-
-    def __init__(self, xid=None, experimenter=None, subtype=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 8)
-        subclass = experimenter.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = experimenter()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.experimenter = reader.read("!L")[0]
-        obj.subtype = reader.read("!L")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.experimenter != other.experimenter: return False
-        if self.subtype != other.subtype: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("experimenter {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("subtype = ");
-                q.text("%#x" % self.subtype)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[4] = experimenter
-
-class bsn_header(experimenter):
-    subtypes = {}
-
-    version = 3
-    type = 4
-    experimenter = 6035143
-
-    def __init__(self, xid=None, subtype=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 12)
-        subclass = bsn_header.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = bsn_header()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        obj.subtype = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.subtype != other.subtype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_header {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-experimenter.subtypes[6035143] = bsn_header
-
-class bsn_bw_clear_data_reply(bsn_header):
-    version = 3
-    type = 4
-    experimenter = 6035143
-    subtype = 22
-
-    def __init__(self, xid=None, status=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if status != None:
-            self.status = status
-        else:
-            self.status = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.status))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_bw_clear_data_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 22)
-        obj.status = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.status != other.status: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_bw_clear_data_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("status = ");
-                q.text("%#x" % self.status)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[22] = bsn_bw_clear_data_reply
-
-class bsn_bw_clear_data_request(bsn_header):
-    version = 3
-    type = 4
-    experimenter = 6035143
-    subtype = 21
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_bw_clear_data_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 21)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_bw_clear_data_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[21] = bsn_bw_clear_data_request
-
-class bsn_bw_enable_get_reply(bsn_header):
-    version = 3
-    type = 4
-    experimenter = 6035143
-    subtype = 20
-
-    def __init__(self, xid=None, enabled=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if enabled != None:
-            self.enabled = enabled
-        else:
-            self.enabled = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.enabled))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_bw_enable_get_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 20)
-        obj.enabled = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.enabled != other.enabled: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_bw_enable_get_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("enabled = ");
-                q.text("%#x" % self.enabled)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[20] = bsn_bw_enable_get_reply
-
-class bsn_bw_enable_get_request(bsn_header):
-    version = 3
-    type = 4
-    experimenter = 6035143
-    subtype = 19
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_bw_enable_get_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 19)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_bw_enable_get_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[19] = bsn_bw_enable_get_request
-
-class bsn_bw_enable_set_reply(bsn_header):
-    version = 3
-    type = 4
-    experimenter = 6035143
-    subtype = 23
-
-    def __init__(self, xid=None, enable=None, status=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if enable != None:
-            self.enable = enable
-        else:
-            self.enable = 0
-        if status != None:
-            self.status = status
-        else:
-            self.status = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.enable))
-        packed.append(struct.pack("!L", self.status))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_bw_enable_set_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 23)
-        obj.enable = reader.read("!L")[0]
-        obj.status = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.enable != other.enable: return False
-        if self.status != other.status: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_bw_enable_set_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("enable = ");
-                q.text("%#x" % self.enable)
-                q.text(","); q.breakable()
-                q.text("status = ");
-                q.text("%#x" % self.status)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[23] = bsn_bw_enable_set_reply
-
-class bsn_bw_enable_set_request(bsn_header):
-    version = 3
-    type = 4
-    experimenter = 6035143
-    subtype = 18
-
-    def __init__(self, xid=None, enable=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if enable != None:
-            self.enable = enable
-        else:
-            self.enable = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.enable))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_bw_enable_set_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 18)
-        obj.enable = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.enable != other.enable: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_bw_enable_set_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("enable = ");
-                q.text("%#x" % self.enable)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[18] = bsn_bw_enable_set_request
-
-class bsn_get_interfaces_reply(bsn_header):
-    version = 3
-    type = 4
-    experimenter = 6035143
-    subtype = 10
-
-    def __init__(self, xid=None, interfaces=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if interfaces != None:
-            self.interfaces = interfaces
-        else:
-            self.interfaces = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(loxi.generic_util.pack_list(self.interfaces))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_get_interfaces_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 10)
-        obj.interfaces = loxi.generic_util.unpack_list(reader, ofp.common.bsn_interface.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.interfaces != other.interfaces: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_get_interfaces_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("interfaces = ");
-                q.pp(self.interfaces)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[10] = bsn_get_interfaces_reply
-
-class bsn_get_interfaces_request(bsn_header):
-    version = 3
-    type = 4
-    experimenter = 6035143
-    subtype = 9
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_get_interfaces_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 9)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_get_interfaces_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[9] = bsn_get_interfaces_request
-
-class bsn_get_mirroring_reply(bsn_header):
-    version = 3
-    type = 4
-    experimenter = 6035143
-    subtype = 5
-
-    def __init__(self, xid=None, report_mirror_ports=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if report_mirror_ports != None:
-            self.report_mirror_ports = report_mirror_ports
-        else:
-            self.report_mirror_ports = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!B", self.report_mirror_ports))
-        packed.append('\x00' * 3)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_get_mirroring_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 5)
-        obj.report_mirror_ports = reader.read("!B")[0]
-        reader.skip(3)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.report_mirror_ports != other.report_mirror_ports: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_get_mirroring_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("report_mirror_ports = ");
-                q.text("%#x" % self.report_mirror_ports)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[5] = bsn_get_mirroring_reply
-
-class bsn_get_mirroring_request(bsn_header):
-    version = 3
-    type = 4
-    experimenter = 6035143
-    subtype = 4
-
-    def __init__(self, xid=None, report_mirror_ports=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if report_mirror_ports != None:
-            self.report_mirror_ports = report_mirror_ports
-        else:
-            self.report_mirror_ports = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!B", self.report_mirror_ports))
-        packed.append('\x00' * 3)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_get_mirroring_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 4)
-        obj.report_mirror_ports = reader.read("!B")[0]
-        reader.skip(3)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.report_mirror_ports != other.report_mirror_ports: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_get_mirroring_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("report_mirror_ports = ");
-                q.text("%#x" % self.report_mirror_ports)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[4] = bsn_get_mirroring_request
-
-class bsn_pdu_rx_reply(bsn_header):
-    version = 3
-    type = 4
-    experimenter = 6035143
-    subtype = 34
-
-    def __init__(self, xid=None, status=None, port_no=None, slot_num=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if status != None:
-            self.status = status
-        else:
-            self.status = 0
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if slot_num != None:
-            self.slot_num = slot_num
-        else:
-            self.slot_num = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.status))
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(struct.pack("!B", self.slot_num))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_pdu_rx_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 34)
-        obj.status = reader.read("!L")[0]
-        obj.port_no = util.unpack_port_no(reader)
-        obj.slot_num = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.status != other.status: return False
-        if self.port_no != other.port_no: return False
-        if self.slot_num != other.slot_num: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_pdu_rx_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("status = ");
-                q.text("%#x" % self.status)
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("slot_num = ");
-                q.text("%#x" % self.slot_num)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[34] = bsn_pdu_rx_reply
-
-class bsn_pdu_rx_request(bsn_header):
-    version = 3
-    type = 4
-    experimenter = 6035143
-    subtype = 33
-
-    def __init__(self, xid=None, timeout_ms=None, port_no=None, slot_num=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if timeout_ms != None:
-            self.timeout_ms = timeout_ms
-        else:
-            self.timeout_ms = 0
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if slot_num != None:
-            self.slot_num = slot_num
-        else:
-            self.slot_num = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.timeout_ms))
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(struct.pack("!B", self.slot_num))
-        packed.append('\x00' * 3)
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_pdu_rx_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 33)
-        obj.timeout_ms = reader.read("!L")[0]
-        obj.port_no = util.unpack_port_no(reader)
-        obj.slot_num = reader.read("!B")[0]
-        reader.skip(3)
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.timeout_ms != other.timeout_ms: return False
-        if self.port_no != other.port_no: return False
-        if self.slot_num != other.slot_num: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_pdu_rx_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("timeout_ms = ");
-                q.text("%#x" % self.timeout_ms)
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("slot_num = ");
-                q.text("%#x" % self.slot_num)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[33] = bsn_pdu_rx_request
-
-class bsn_pdu_rx_timeout(bsn_header):
-    version = 3
-    type = 4
-    experimenter = 6035143
-    subtype = 35
-
-    def __init__(self, xid=None, port_no=None, slot_num=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if slot_num != None:
-            self.slot_num = slot_num
-        else:
-            self.slot_num = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(struct.pack("!B", self.slot_num))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_pdu_rx_timeout()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 35)
-        obj.port_no = util.unpack_port_no(reader)
-        obj.slot_num = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.port_no != other.port_no: return False
-        if self.slot_num != other.slot_num: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_pdu_rx_timeout {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("slot_num = ");
-                q.text("%#x" % self.slot_num)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[35] = bsn_pdu_rx_timeout
-
-class bsn_pdu_tx_reply(bsn_header):
-    version = 3
-    type = 4
-    experimenter = 6035143
-    subtype = 32
-
-    def __init__(self, xid=None, status=None, port_no=None, slot_num=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if status != None:
-            self.status = status
-        else:
-            self.status = 0
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if slot_num != None:
-            self.slot_num = slot_num
-        else:
-            self.slot_num = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.status))
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(struct.pack("!B", self.slot_num))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_pdu_tx_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 32)
-        obj.status = reader.read("!L")[0]
-        obj.port_no = util.unpack_port_no(reader)
-        obj.slot_num = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.status != other.status: return False
-        if self.port_no != other.port_no: return False
-        if self.slot_num != other.slot_num: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_pdu_tx_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("status = ");
-                q.text("%#x" % self.status)
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("slot_num = ");
-                q.text("%#x" % self.slot_num)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[32] = bsn_pdu_tx_reply
-
-class bsn_pdu_tx_request(bsn_header):
-    version = 3
-    type = 4
-    experimenter = 6035143
-    subtype = 31
-
-    def __init__(self, xid=None, tx_interval_ms=None, port_no=None, slot_num=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if tx_interval_ms != None:
-            self.tx_interval_ms = tx_interval_ms
-        else:
-            self.tx_interval_ms = 0
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if slot_num != None:
-            self.slot_num = slot_num
-        else:
-            self.slot_num = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.tx_interval_ms))
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(struct.pack("!B", self.slot_num))
-        packed.append('\x00' * 3)
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_pdu_tx_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 31)
-        obj.tx_interval_ms = reader.read("!L")[0]
-        obj.port_no = util.unpack_port_no(reader)
-        obj.slot_num = reader.read("!B")[0]
-        reader.skip(3)
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.tx_interval_ms != other.tx_interval_ms: return False
-        if self.port_no != other.port_no: return False
-        if self.slot_num != other.slot_num: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_pdu_tx_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("tx_interval_ms = ");
-                q.text("%#x" % self.tx_interval_ms)
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("slot_num = ");
-                q.text("%#x" % self.slot_num)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[31] = bsn_pdu_tx_request
-
-class bsn_set_mirroring(bsn_header):
-    version = 3
-    type = 4
-    experimenter = 6035143
-    subtype = 3
-
-    def __init__(self, xid=None, report_mirror_ports=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if report_mirror_ports != None:
-            self.report_mirror_ports = report_mirror_ports
-        else:
-            self.report_mirror_ports = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!B", self.report_mirror_ports))
-        packed.append('\x00' * 3)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_set_mirroring()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 3)
-        obj.report_mirror_ports = reader.read("!B")[0]
-        reader.skip(3)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.report_mirror_ports != other.report_mirror_ports: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_set_mirroring {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("report_mirror_ports = ");
-                q.text("%#x" % self.report_mirror_ports)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[3] = bsn_set_mirroring
-
-class bsn_set_pktin_suppression_reply(bsn_header):
-    version = 3
-    type = 4
-    experimenter = 6035143
-    subtype = 25
-
-    def __init__(self, xid=None, status=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if status != None:
-            self.status = status
-        else:
-            self.status = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.status))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_set_pktin_suppression_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 25)
-        obj.status = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.status != other.status: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_set_pktin_suppression_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("status = ");
-                q.text("%#x" % self.status)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[25] = bsn_set_pktin_suppression_reply
-
-class bsn_set_pktin_suppression_request(bsn_header):
-    version = 3
-    type = 4
-    experimenter = 6035143
-    subtype = 11
-
-    def __init__(self, xid=None, enabled=None, idle_timeout=None, hard_timeout=None, priority=None, cookie=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if enabled != None:
-            self.enabled = enabled
-        else:
-            self.enabled = 0
-        if idle_timeout != None:
-            self.idle_timeout = idle_timeout
-        else:
-            self.idle_timeout = 0
-        if hard_timeout != None:
-            self.hard_timeout = hard_timeout
-        else:
-            self.hard_timeout = 0
-        if priority != None:
-            self.priority = priority
-        else:
-            self.priority = 0
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!B", self.enabled))
-        packed.append('\x00' * 1)
-        packed.append(struct.pack("!H", self.idle_timeout))
-        packed.append(struct.pack("!H", self.hard_timeout))
-        packed.append(struct.pack("!H", self.priority))
-        packed.append(struct.pack("!Q", self.cookie))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_set_pktin_suppression_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 11)
-        obj.enabled = reader.read("!B")[0]
-        reader.skip(1)
-        obj.idle_timeout = reader.read("!H")[0]
-        obj.hard_timeout = reader.read("!H")[0]
-        obj.priority = reader.read("!H")[0]
-        obj.cookie = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.enabled != other.enabled: return False
-        if self.idle_timeout != other.idle_timeout: return False
-        if self.hard_timeout != other.hard_timeout: return False
-        if self.priority != other.priority: return False
-        if self.cookie != other.cookie: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_set_pktin_suppression_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("enabled = ");
-                q.text("%#x" % self.enabled)
-                q.text(","); q.breakable()
-                q.text("idle_timeout = ");
-                q.text("%#x" % self.idle_timeout)
-                q.text(","); q.breakable()
-                q.text("hard_timeout = ");
-                q.text("%#x" % self.hard_timeout)
-                q.text(","); q.breakable()
-                q.text("priority = ");
-                q.text("%#x" % self.priority)
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[11] = bsn_set_pktin_suppression_request
-
-class experimenter_stats_reply(stats_reply):
-    subtypes = {}
-
-    version = 3
-    type = 19
-    stats_type = 65535
-
-    def __init__(self, xid=None, flags=None, experimenter=None, subtype=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 16)
-        subclass = experimenter_stats_reply.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = experimenter_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.experimenter = reader.read("!L")[0]
-        obj.subtype = reader.read("!L")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.experimenter != other.experimenter: return False
-        if self.subtype != other.subtype: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("experimenter_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("subtype = ");
-                q.text("%#x" % self.subtype)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[65535] = experimenter_stats_reply
-
-class bsn_stats_reply(experimenter_stats_reply):
-    subtypes = {}
-
-    version = 3
-    type = 19
-    stats_type = 65535
-    experimenter = 6035143
-
-    def __init__(self, xid=None, flags=None, subtype=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 20)
-        subclass = bsn_stats_reply.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = bsn_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        obj.subtype = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.subtype != other.subtype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-experimenter_stats_reply.subtypes[6035143] = bsn_stats_reply
-
-class experimenter_stats_request(stats_request):
-    subtypes = {}
-
-    version = 3
-    type = 18
-    stats_type = 65535
-
-    def __init__(self, xid=None, flags=None, experimenter=None, subtype=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 16)
-        subclass = experimenter_stats_request.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = experimenter_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.experimenter = reader.read("!L")[0]
-        obj.subtype = reader.read("!L")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.experimenter != other.experimenter: return False
-        if self.subtype != other.subtype: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("experimenter_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("subtype = ");
-                q.text("%#x" % self.subtype)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[65535] = experimenter_stats_request
-
-class bsn_stats_request(experimenter_stats_request):
-    subtypes = {}
-
-    version = 3
-    type = 18
-    stats_type = 65535
-    experimenter = 6035143
-
-    def __init__(self, xid=None, flags=None, subtype=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 20)
-        subclass = bsn_stats_request.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = bsn_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        obj.subtype = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.subtype != other.subtype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-experimenter_stats_request.subtypes[6035143] = bsn_stats_request
-
-class bsn_virtual_port_create_reply(bsn_header):
-    version = 3
-    type = 4
-    experimenter = 6035143
-    subtype = 16
-
-    def __init__(self, xid=None, status=None, vport_no=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if status != None:
-            self.status = status
-        else:
-            self.status = 0
-        if vport_no != None:
-            self.vport_no = vport_no
-        else:
-            self.vport_no = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.status))
-        packed.append(struct.pack("!L", self.vport_no))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_virtual_port_create_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 16)
-        obj.status = reader.read("!L")[0]
-        obj.vport_no = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.status != other.status: return False
-        if self.vport_no != other.vport_no: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_virtual_port_create_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("status = ");
-                q.text("%#x" % self.status)
-                q.text(","); q.breakable()
-                q.text("vport_no = ");
-                q.text("%#x" % self.vport_no)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[16] = bsn_virtual_port_create_reply
-
-class bsn_virtual_port_create_request(bsn_header):
-    version = 3
-    type = 4
-    experimenter = 6035143
-    subtype = 15
-
-    def __init__(self, xid=None, vport=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if vport != None:
-            self.vport = vport
-        else:
-            self.vport = ofp.bsn_vport()
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(self.vport.pack())
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_virtual_port_create_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 15)
-        obj.vport = ofp.bsn_vport.unpack(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.vport != other.vport: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_virtual_port_create_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("vport = ");
-                q.pp(self.vport)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[15] = bsn_virtual_port_create_request
-
-class bsn_virtual_port_remove_reply(bsn_header):
-    version = 3
-    type = 4
-    experimenter = 6035143
-    subtype = 26
-
-    def __init__(self, xid=None, status=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if status != None:
-            self.status = status
-        else:
-            self.status = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.status))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_virtual_port_remove_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 26)
-        obj.status = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.status != other.status: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_virtual_port_remove_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("status = ");
-                q.text("%#x" % self.status)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[26] = bsn_virtual_port_remove_reply
-
-class bsn_virtual_port_remove_request(bsn_header):
-    version = 3
-    type = 4
-    experimenter = 6035143
-    subtype = 17
-
-    def __init__(self, xid=None, vport_no=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if vport_no != None:
-            self.vport_no = vport_no
-        else:
-            self.vport_no = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.vport_no))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_virtual_port_remove_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 17)
-        obj.vport_no = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.vport_no != other.vport_no: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_virtual_port_remove_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("vport_no = ");
-                q.text("%#x" % self.vport_no)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[17] = bsn_virtual_port_remove_request
-
-class desc_stats_reply(stats_reply):
-    version = 3
-    type = 19
-    stats_type = 0
-
-    def __init__(self, xid=None, flags=None, mfr_desc=None, hw_desc=None, sw_desc=None, serial_num=None, dp_desc=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if mfr_desc != None:
-            self.mfr_desc = mfr_desc
-        else:
-            self.mfr_desc = ""
-        if hw_desc != None:
-            self.hw_desc = hw_desc
-        else:
-            self.hw_desc = ""
-        if sw_desc != None:
-            self.sw_desc = sw_desc
-        else:
-            self.sw_desc = ""
-        if serial_num != None:
-            self.serial_num = serial_num
-        else:
-            self.serial_num = ""
-        if dp_desc != None:
-            self.dp_desc = dp_desc
-        else:
-            self.dp_desc = ""
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!256s", self.mfr_desc))
-        packed.append(struct.pack("!256s", self.hw_desc))
-        packed.append(struct.pack("!256s", self.sw_desc))
-        packed.append(struct.pack("!32s", self.serial_num))
-        packed.append(struct.pack("!256s", self.dp_desc))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = desc_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 0)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.mfr_desc = reader.read("!256s")[0].rstrip("\x00")
-        obj.hw_desc = reader.read("!256s")[0].rstrip("\x00")
-        obj.sw_desc = reader.read("!256s")[0].rstrip("\x00")
-        obj.serial_num = reader.read("!32s")[0].rstrip("\x00")
-        obj.dp_desc = reader.read("!256s")[0].rstrip("\x00")
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.mfr_desc != other.mfr_desc: return False
-        if self.hw_desc != other.hw_desc: return False
-        if self.sw_desc != other.sw_desc: return False
-        if self.serial_num != other.serial_num: return False
-        if self.dp_desc != other.dp_desc: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("desc_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("mfr_desc = ");
-                q.pp(self.mfr_desc)
-                q.text(","); q.breakable()
-                q.text("hw_desc = ");
-                q.pp(self.hw_desc)
-                q.text(","); q.breakable()
-                q.text("sw_desc = ");
-                q.pp(self.sw_desc)
-                q.text(","); q.breakable()
-                q.text("serial_num = ");
-                q.pp(self.serial_num)
-                q.text(","); q.breakable()
-                q.text("dp_desc = ");
-                q.pp(self.dp_desc)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[0] = desc_stats_reply
-
-class desc_stats_request(stats_request):
-    version = 3
-    type = 18
-    stats_type = 0
-
-    def __init__(self, xid=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = desc_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 0)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("desc_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[0] = desc_stats_request
-
-class echo_reply(message):
-    version = 3
-    type = 3
-
-    def __init__(self, xid=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = echo_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 3)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("echo_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[3] = echo_reply
-
-class echo_request(message):
-    version = 3
-    type = 2
-
-    def __init__(self, xid=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = echo_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 2)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("echo_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[2] = echo_request
-
-class experimenter_error_msg(error_msg):
-    subtypes = {}
-
-    version = 3
-    type = 1
-    err_type = 65535
-
-    def __init__(self, xid=None, subtype=None, experimenter=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.subtype))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 12)
-        subclass = experimenter_error_msg.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = experimenter_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 65535)
-        obj.subtype = reader.read("!H")[0]
-        obj.experimenter = reader.read("!L")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.subtype != other.subtype: return False
-        if self.experimenter != other.experimenter: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("experimenter_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("subtype = ");
-                q.text("%#x" % self.subtype)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[65535] = experimenter_error_msg
-
-class features_reply(message):
-    version = 3
-    type = 6
-
-    def __init__(self, xid=None, datapath_id=None, n_buffers=None, n_tables=None, capabilities=None, reserved=None, ports=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if datapath_id != None:
-            self.datapath_id = datapath_id
-        else:
-            self.datapath_id = 0
-        if n_buffers != None:
-            self.n_buffers = n_buffers
-        else:
-            self.n_buffers = 0
-        if n_tables != None:
-            self.n_tables = n_tables
-        else:
-            self.n_tables = 0
-        if capabilities != None:
-            self.capabilities = capabilities
-        else:
-            self.capabilities = 0
-        if reserved != None:
-            self.reserved = reserved
-        else:
-            self.reserved = 0
-        if ports != None:
-            self.ports = ports
-        else:
-            self.ports = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!Q", self.datapath_id))
-        packed.append(struct.pack("!L", self.n_buffers))
-        packed.append(struct.pack("!B", self.n_tables))
-        packed.append('\x00' * 3)
-        packed.append(struct.pack("!L", self.capabilities))
-        packed.append(struct.pack("!L", self.reserved))
-        packed.append(loxi.generic_util.pack_list(self.ports))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = features_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 6)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.datapath_id = reader.read("!Q")[0]
-        obj.n_buffers = reader.read("!L")[0]
-        obj.n_tables = reader.read("!B")[0]
-        reader.skip(3)
-        obj.capabilities = reader.read("!L")[0]
-        obj.reserved = reader.read("!L")[0]
-        obj.ports = loxi.generic_util.unpack_list(reader, ofp.common.port_desc.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.datapath_id != other.datapath_id: return False
-        if self.n_buffers != other.n_buffers: return False
-        if self.n_tables != other.n_tables: return False
-        if self.capabilities != other.capabilities: return False
-        if self.reserved != other.reserved: return False
-        if self.ports != other.ports: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("features_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("datapath_id = ");
-                q.text("%#x" % self.datapath_id)
-                q.text(","); q.breakable()
-                q.text("n_buffers = ");
-                q.text("%#x" % self.n_buffers)
-                q.text(","); q.breakable()
-                q.text("n_tables = ");
-                q.text("%#x" % self.n_tables)
-                q.text(","); q.breakable()
-                q.text("capabilities = ");
-                q.text("%#x" % self.capabilities)
-                q.text(","); q.breakable()
-                q.text("reserved = ");
-                q.text("%#x" % self.reserved)
-                q.text(","); q.breakable()
-                q.text("ports = ");
-                q.pp(self.ports)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[6] = features_reply
-
-class features_request(message):
-    version = 3
-    type = 5
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = features_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 5)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("features_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-message.subtypes[5] = features_request
-
-class flow_mod(message):
-    subtypes = {}
-
-    version = 3
-    type = 14
-
-    def __init__(self, xid=None, cookie=None, cookie_mask=None, table_id=None, _command=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, out_group=None, flags=None, match=None, instructions=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if cookie_mask != None:
-            self.cookie_mask = cookie_mask
-        else:
-            self.cookie_mask = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if _command != None:
-            self._command = _command
-        else:
-            self._command = 0
-        if idle_timeout != None:
-            self.idle_timeout = idle_timeout
-        else:
-            self.idle_timeout = 0
-        if hard_timeout != None:
-            self.hard_timeout = hard_timeout
-        else:
-            self.hard_timeout = 0
-        if priority != None:
-            self.priority = priority
-        else:
-            self.priority = 0
-        if buffer_id != None:
-            self.buffer_id = buffer_id
-        else:
-            self.buffer_id = 0
-        if out_port != None:
-            self.out_port = out_port
-        else:
-            self.out_port = 0
-        if out_group != None:
-            self.out_group = out_group
-        else:
-            self.out_group = 0
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        if instructions != None:
-            self.instructions = instructions
-        else:
-            self.instructions = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(struct.pack("!Q", self.cookie_mask))
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append(util.pack_fm_cmd(self._command))
-        packed.append(struct.pack("!H", self.idle_timeout))
-        packed.append(struct.pack("!H", self.hard_timeout))
-        packed.append(struct.pack("!H", self.priority))
-        packed.append(struct.pack("!L", self.buffer_id))
-        packed.append(util.pack_port_no(self.out_port))
-        packed.append(struct.pack("!L", self.out_group))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 2)
-        packed.append(self.match.pack())
-        packed.append(loxi.generic_util.pack_list(self.instructions))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('B', 25)
-        subclass = flow_mod.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = flow_mod()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 14)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.cookie = reader.read("!Q")[0]
-        obj.cookie_mask = reader.read("!Q")[0]
-        obj.table_id = reader.read("!B")[0]
-        obj._command = util.unpack_fm_cmd(reader)
-        obj.idle_timeout = reader.read("!H")[0]
-        obj.hard_timeout = reader.read("!H")[0]
-        obj.priority = reader.read("!H")[0]
-        obj.buffer_id = reader.read("!L")[0]
-        obj.out_port = util.unpack_port_no(reader)
-        obj.out_group = reader.read("!L")[0]
-        obj.flags = reader.read("!H")[0]
-        reader.skip(2)
-        obj.match = ofp.match.unpack(reader)
-        obj.instructions = loxi.generic_util.unpack_list(reader, ofp.instruction.instruction.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.cookie != other.cookie: return False
-        if self.cookie_mask != other.cookie_mask: return False
-        if self.table_id != other.table_id: return False
-        if self._command != other._command: return False
-        if self.idle_timeout != other.idle_timeout: return False
-        if self.hard_timeout != other.hard_timeout: return False
-        if self.priority != other.priority: return False
-        if self.buffer_id != other.buffer_id: return False
-        if self.out_port != other.out_port: return False
-        if self.out_group != other.out_group: return False
-        if self.flags != other.flags: return False
-        if self.match != other.match: return False
-        if self.instructions != other.instructions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_mod {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("cookie_mask = ");
-                q.text("%#x" % self.cookie_mask)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("idle_timeout = ");
-                q.text("%#x" % self.idle_timeout)
-                q.text(","); q.breakable()
-                q.text("hard_timeout = ");
-                q.text("%#x" % self.hard_timeout)
-                q.text(","); q.breakable()
-                q.text("priority = ");
-                q.text("%#x" % self.priority)
-                q.text(","); q.breakable()
-                q.text("buffer_id = ");
-                q.text("%#x" % self.buffer_id)
-                q.text(","); q.breakable()
-                q.text("out_port = ");
-                q.text(util.pretty_port(self.out_port))
-                q.text(","); q.breakable()
-                q.text("out_group = ");
-                q.text("%#x" % self.out_group)
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-                q.text(","); q.breakable()
-                q.text("instructions = ");
-                q.pp(self.instructions)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[14] = flow_mod
-
-class flow_add(flow_mod):
-    version = 3
-    type = 14
-    _command = 0
-
-    def __init__(self, xid=None, cookie=None, cookie_mask=None, table_id=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, out_group=None, flags=None, match=None, instructions=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if cookie_mask != None:
-            self.cookie_mask = cookie_mask
-        else:
-            self.cookie_mask = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if idle_timeout != None:
-            self.idle_timeout = idle_timeout
-        else:
-            self.idle_timeout = 0
-        if hard_timeout != None:
-            self.hard_timeout = hard_timeout
-        else:
-            self.hard_timeout = 0
-        if priority != None:
-            self.priority = priority
-        else:
-            self.priority = 0
-        if buffer_id != None:
-            self.buffer_id = buffer_id
-        else:
-            self.buffer_id = 0
-        if out_port != None:
-            self.out_port = out_port
-        else:
-            self.out_port = 0
-        if out_group != None:
-            self.out_group = out_group
-        else:
-            self.out_group = 0
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        if instructions != None:
-            self.instructions = instructions
-        else:
-            self.instructions = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(struct.pack("!Q", self.cookie_mask))
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append(util.pack_fm_cmd(self._command))
-        packed.append(struct.pack("!H", self.idle_timeout))
-        packed.append(struct.pack("!H", self.hard_timeout))
-        packed.append(struct.pack("!H", self.priority))
-        packed.append(struct.pack("!L", self.buffer_id))
-        packed.append(util.pack_port_no(self.out_port))
-        packed.append(struct.pack("!L", self.out_group))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 2)
-        packed.append(self.match.pack())
-        packed.append(loxi.generic_util.pack_list(self.instructions))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_add()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 14)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.cookie = reader.read("!Q")[0]
-        obj.cookie_mask = reader.read("!Q")[0]
-        obj.table_id = reader.read("!B")[0]
-        __command = util.unpack_fm_cmd(reader)
-        assert(__command == 0)
-        obj.idle_timeout = reader.read("!H")[0]
-        obj.hard_timeout = reader.read("!H")[0]
-        obj.priority = reader.read("!H")[0]
-        obj.buffer_id = reader.read("!L")[0]
-        obj.out_port = util.unpack_port_no(reader)
-        obj.out_group = reader.read("!L")[0]
-        obj.flags = reader.read("!H")[0]
-        reader.skip(2)
-        obj.match = ofp.match.unpack(reader)
-        obj.instructions = loxi.generic_util.unpack_list(reader, ofp.instruction.instruction.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.cookie != other.cookie: return False
-        if self.cookie_mask != other.cookie_mask: return False
-        if self.table_id != other.table_id: return False
-        if self.idle_timeout != other.idle_timeout: return False
-        if self.hard_timeout != other.hard_timeout: return False
-        if self.priority != other.priority: return False
-        if self.buffer_id != other.buffer_id: return False
-        if self.out_port != other.out_port: return False
-        if self.out_group != other.out_group: return False
-        if self.flags != other.flags: return False
-        if self.match != other.match: return False
-        if self.instructions != other.instructions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_add {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("cookie_mask = ");
-                q.text("%#x" % self.cookie_mask)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("idle_timeout = ");
-                q.text("%#x" % self.idle_timeout)
-                q.text(","); q.breakable()
-                q.text("hard_timeout = ");
-                q.text("%#x" % self.hard_timeout)
-                q.text(","); q.breakable()
-                q.text("priority = ");
-                q.text("%#x" % self.priority)
-                q.text(","); q.breakable()
-                q.text("buffer_id = ");
-                q.text("%#x" % self.buffer_id)
-                q.text(","); q.breakable()
-                q.text("out_port = ");
-                q.text(util.pretty_port(self.out_port))
-                q.text(","); q.breakable()
-                q.text("out_group = ");
-                q.text("%#x" % self.out_group)
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-                q.text(","); q.breakable()
-                q.text("instructions = ");
-                q.pp(self.instructions)
-            q.breakable()
-        q.text('}')
-
-flow_mod.subtypes[0] = flow_add
-
-class flow_delete(flow_mod):
-    version = 3
-    type = 14
-    _command = 3
-
-    def __init__(self, xid=None, cookie=None, cookie_mask=None, table_id=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, out_group=None, flags=None, match=None, instructions=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if cookie_mask != None:
-            self.cookie_mask = cookie_mask
-        else:
-            self.cookie_mask = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if idle_timeout != None:
-            self.idle_timeout = idle_timeout
-        else:
-            self.idle_timeout = 0
-        if hard_timeout != None:
-            self.hard_timeout = hard_timeout
-        else:
-            self.hard_timeout = 0
-        if priority != None:
-            self.priority = priority
-        else:
-            self.priority = 0
-        if buffer_id != None:
-            self.buffer_id = buffer_id
-        else:
-            self.buffer_id = 0
-        if out_port != None:
-            self.out_port = out_port
-        else:
-            self.out_port = 0
-        if out_group != None:
-            self.out_group = out_group
-        else:
-            self.out_group = 0
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        if instructions != None:
-            self.instructions = instructions
-        else:
-            self.instructions = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(struct.pack("!Q", self.cookie_mask))
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append(util.pack_fm_cmd(self._command))
-        packed.append(struct.pack("!H", self.idle_timeout))
-        packed.append(struct.pack("!H", self.hard_timeout))
-        packed.append(struct.pack("!H", self.priority))
-        packed.append(struct.pack("!L", self.buffer_id))
-        packed.append(util.pack_port_no(self.out_port))
-        packed.append(struct.pack("!L", self.out_group))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 2)
-        packed.append(self.match.pack())
-        packed.append(loxi.generic_util.pack_list(self.instructions))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_delete()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 14)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.cookie = reader.read("!Q")[0]
-        obj.cookie_mask = reader.read("!Q")[0]
-        obj.table_id = reader.read("!B")[0]
-        __command = util.unpack_fm_cmd(reader)
-        assert(__command == 3)
-        obj.idle_timeout = reader.read("!H")[0]
-        obj.hard_timeout = reader.read("!H")[0]
-        obj.priority = reader.read("!H")[0]
-        obj.buffer_id = reader.read("!L")[0]
-        obj.out_port = util.unpack_port_no(reader)
-        obj.out_group = reader.read("!L")[0]
-        obj.flags = reader.read("!H")[0]
-        reader.skip(2)
-        obj.match = ofp.match.unpack(reader)
-        obj.instructions = loxi.generic_util.unpack_list(reader, ofp.instruction.instruction.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.cookie != other.cookie: return False
-        if self.cookie_mask != other.cookie_mask: return False
-        if self.table_id != other.table_id: return False
-        if self.idle_timeout != other.idle_timeout: return False
-        if self.hard_timeout != other.hard_timeout: return False
-        if self.priority != other.priority: return False
-        if self.buffer_id != other.buffer_id: return False
-        if self.out_port != other.out_port: return False
-        if self.out_group != other.out_group: return False
-        if self.flags != other.flags: return False
-        if self.match != other.match: return False
-        if self.instructions != other.instructions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_delete {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("cookie_mask = ");
-                q.text("%#x" % self.cookie_mask)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("idle_timeout = ");
-                q.text("%#x" % self.idle_timeout)
-                q.text(","); q.breakable()
-                q.text("hard_timeout = ");
-                q.text("%#x" % self.hard_timeout)
-                q.text(","); q.breakable()
-                q.text("priority = ");
-                q.text("%#x" % self.priority)
-                q.text(","); q.breakable()
-                q.text("buffer_id = ");
-                q.text("%#x" % self.buffer_id)
-                q.text(","); q.breakable()
-                q.text("out_port = ");
-                q.text(util.pretty_port(self.out_port))
-                q.text(","); q.breakable()
-                q.text("out_group = ");
-                q.text("%#x" % self.out_group)
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-                q.text(","); q.breakable()
-                q.text("instructions = ");
-                q.pp(self.instructions)
-            q.breakable()
-        q.text('}')
-
-flow_mod.subtypes[3] = flow_delete
-
-class flow_delete_strict(flow_mod):
-    version = 3
-    type = 14
-    _command = 4
-
-    def __init__(self, xid=None, cookie=None, cookie_mask=None, table_id=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, out_group=None, flags=None, match=None, instructions=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if cookie_mask != None:
-            self.cookie_mask = cookie_mask
-        else:
-            self.cookie_mask = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if idle_timeout != None:
-            self.idle_timeout = idle_timeout
-        else:
-            self.idle_timeout = 0
-        if hard_timeout != None:
-            self.hard_timeout = hard_timeout
-        else:
-            self.hard_timeout = 0
-        if priority != None:
-            self.priority = priority
-        else:
-            self.priority = 0
-        if buffer_id != None:
-            self.buffer_id = buffer_id
-        else:
-            self.buffer_id = 0
-        if out_port != None:
-            self.out_port = out_port
-        else:
-            self.out_port = 0
-        if out_group != None:
-            self.out_group = out_group
-        else:
-            self.out_group = 0
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        if instructions != None:
-            self.instructions = instructions
-        else:
-            self.instructions = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(struct.pack("!Q", self.cookie_mask))
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append(util.pack_fm_cmd(self._command))
-        packed.append(struct.pack("!H", self.idle_timeout))
-        packed.append(struct.pack("!H", self.hard_timeout))
-        packed.append(struct.pack("!H", self.priority))
-        packed.append(struct.pack("!L", self.buffer_id))
-        packed.append(util.pack_port_no(self.out_port))
-        packed.append(struct.pack("!L", self.out_group))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 2)
-        packed.append(self.match.pack())
-        packed.append(loxi.generic_util.pack_list(self.instructions))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_delete_strict()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 14)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.cookie = reader.read("!Q")[0]
-        obj.cookie_mask = reader.read("!Q")[0]
-        obj.table_id = reader.read("!B")[0]
-        __command = util.unpack_fm_cmd(reader)
-        assert(__command == 4)
-        obj.idle_timeout = reader.read("!H")[0]
-        obj.hard_timeout = reader.read("!H")[0]
-        obj.priority = reader.read("!H")[0]
-        obj.buffer_id = reader.read("!L")[0]
-        obj.out_port = util.unpack_port_no(reader)
-        obj.out_group = reader.read("!L")[0]
-        obj.flags = reader.read("!H")[0]
-        reader.skip(2)
-        obj.match = ofp.match.unpack(reader)
-        obj.instructions = loxi.generic_util.unpack_list(reader, ofp.instruction.instruction.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.cookie != other.cookie: return False
-        if self.cookie_mask != other.cookie_mask: return False
-        if self.table_id != other.table_id: return False
-        if self.idle_timeout != other.idle_timeout: return False
-        if self.hard_timeout != other.hard_timeout: return False
-        if self.priority != other.priority: return False
-        if self.buffer_id != other.buffer_id: return False
-        if self.out_port != other.out_port: return False
-        if self.out_group != other.out_group: return False
-        if self.flags != other.flags: return False
-        if self.match != other.match: return False
-        if self.instructions != other.instructions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_delete_strict {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("cookie_mask = ");
-                q.text("%#x" % self.cookie_mask)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("idle_timeout = ");
-                q.text("%#x" % self.idle_timeout)
-                q.text(","); q.breakable()
-                q.text("hard_timeout = ");
-                q.text("%#x" % self.hard_timeout)
-                q.text(","); q.breakable()
-                q.text("priority = ");
-                q.text("%#x" % self.priority)
-                q.text(","); q.breakable()
-                q.text("buffer_id = ");
-                q.text("%#x" % self.buffer_id)
-                q.text(","); q.breakable()
-                q.text("out_port = ");
-                q.text(util.pretty_port(self.out_port))
-                q.text(","); q.breakable()
-                q.text("out_group = ");
-                q.text("%#x" % self.out_group)
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-                q.text(","); q.breakable()
-                q.text("instructions = ");
-                q.pp(self.instructions)
-            q.breakable()
-        q.text('}')
-
-flow_mod.subtypes[4] = flow_delete_strict
-
-class flow_mod_failed_error_msg(error_msg):
-    version = 3
-    type = 1
-    err_type = 5
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_mod_failed_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 5)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_mod_failed_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[5] = flow_mod_failed_error_msg
-
-class flow_modify(flow_mod):
-    version = 3
-    type = 14
-    _command = 1
-
-    def __init__(self, xid=None, cookie=None, cookie_mask=None, table_id=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, out_group=None, flags=None, match=None, instructions=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if cookie_mask != None:
-            self.cookie_mask = cookie_mask
-        else:
-            self.cookie_mask = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if idle_timeout != None:
-            self.idle_timeout = idle_timeout
-        else:
-            self.idle_timeout = 0
-        if hard_timeout != None:
-            self.hard_timeout = hard_timeout
-        else:
-            self.hard_timeout = 0
-        if priority != None:
-            self.priority = priority
-        else:
-            self.priority = 0
-        if buffer_id != None:
-            self.buffer_id = buffer_id
-        else:
-            self.buffer_id = 0
-        if out_port != None:
-            self.out_port = out_port
-        else:
-            self.out_port = 0
-        if out_group != None:
-            self.out_group = out_group
-        else:
-            self.out_group = 0
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        if instructions != None:
-            self.instructions = instructions
-        else:
-            self.instructions = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(struct.pack("!Q", self.cookie_mask))
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append(util.pack_fm_cmd(self._command))
-        packed.append(struct.pack("!H", self.idle_timeout))
-        packed.append(struct.pack("!H", self.hard_timeout))
-        packed.append(struct.pack("!H", self.priority))
-        packed.append(struct.pack("!L", self.buffer_id))
-        packed.append(util.pack_port_no(self.out_port))
-        packed.append(struct.pack("!L", self.out_group))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 2)
-        packed.append(self.match.pack())
-        packed.append(loxi.generic_util.pack_list(self.instructions))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_modify()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 14)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.cookie = reader.read("!Q")[0]
-        obj.cookie_mask = reader.read("!Q")[0]
-        obj.table_id = reader.read("!B")[0]
-        __command = util.unpack_fm_cmd(reader)
-        assert(__command == 1)
-        obj.idle_timeout = reader.read("!H")[0]
-        obj.hard_timeout = reader.read("!H")[0]
-        obj.priority = reader.read("!H")[0]
-        obj.buffer_id = reader.read("!L")[0]
-        obj.out_port = util.unpack_port_no(reader)
-        obj.out_group = reader.read("!L")[0]
-        obj.flags = reader.read("!H")[0]
-        reader.skip(2)
-        obj.match = ofp.match.unpack(reader)
-        obj.instructions = loxi.generic_util.unpack_list(reader, ofp.instruction.instruction.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.cookie != other.cookie: return False
-        if self.cookie_mask != other.cookie_mask: return False
-        if self.table_id != other.table_id: return False
-        if self.idle_timeout != other.idle_timeout: return False
-        if self.hard_timeout != other.hard_timeout: return False
-        if self.priority != other.priority: return False
-        if self.buffer_id != other.buffer_id: return False
-        if self.out_port != other.out_port: return False
-        if self.out_group != other.out_group: return False
-        if self.flags != other.flags: return False
-        if self.match != other.match: return False
-        if self.instructions != other.instructions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_modify {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("cookie_mask = ");
-                q.text("%#x" % self.cookie_mask)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("idle_timeout = ");
-                q.text("%#x" % self.idle_timeout)
-                q.text(","); q.breakable()
-                q.text("hard_timeout = ");
-                q.text("%#x" % self.hard_timeout)
-                q.text(","); q.breakable()
-                q.text("priority = ");
-                q.text("%#x" % self.priority)
-                q.text(","); q.breakable()
-                q.text("buffer_id = ");
-                q.text("%#x" % self.buffer_id)
-                q.text(","); q.breakable()
-                q.text("out_port = ");
-                q.text(util.pretty_port(self.out_port))
-                q.text(","); q.breakable()
-                q.text("out_group = ");
-                q.text("%#x" % self.out_group)
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-                q.text(","); q.breakable()
-                q.text("instructions = ");
-                q.pp(self.instructions)
-            q.breakable()
-        q.text('}')
-
-flow_mod.subtypes[1] = flow_modify
-
-class flow_modify_strict(flow_mod):
-    version = 3
-    type = 14
-    _command = 2
-
-    def __init__(self, xid=None, cookie=None, cookie_mask=None, table_id=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, out_group=None, flags=None, match=None, instructions=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if cookie_mask != None:
-            self.cookie_mask = cookie_mask
-        else:
-            self.cookie_mask = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if idle_timeout != None:
-            self.idle_timeout = idle_timeout
-        else:
-            self.idle_timeout = 0
-        if hard_timeout != None:
-            self.hard_timeout = hard_timeout
-        else:
-            self.hard_timeout = 0
-        if priority != None:
-            self.priority = priority
-        else:
-            self.priority = 0
-        if buffer_id != None:
-            self.buffer_id = buffer_id
-        else:
-            self.buffer_id = 0
-        if out_port != None:
-            self.out_port = out_port
-        else:
-            self.out_port = 0
-        if out_group != None:
-            self.out_group = out_group
-        else:
-            self.out_group = 0
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        if instructions != None:
-            self.instructions = instructions
-        else:
-            self.instructions = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(struct.pack("!Q", self.cookie_mask))
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append(util.pack_fm_cmd(self._command))
-        packed.append(struct.pack("!H", self.idle_timeout))
-        packed.append(struct.pack("!H", self.hard_timeout))
-        packed.append(struct.pack("!H", self.priority))
-        packed.append(struct.pack("!L", self.buffer_id))
-        packed.append(util.pack_port_no(self.out_port))
-        packed.append(struct.pack("!L", self.out_group))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 2)
-        packed.append(self.match.pack())
-        packed.append(loxi.generic_util.pack_list(self.instructions))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_modify_strict()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 14)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.cookie = reader.read("!Q")[0]
-        obj.cookie_mask = reader.read("!Q")[0]
-        obj.table_id = reader.read("!B")[0]
-        __command = util.unpack_fm_cmd(reader)
-        assert(__command == 2)
-        obj.idle_timeout = reader.read("!H")[0]
-        obj.hard_timeout = reader.read("!H")[0]
-        obj.priority = reader.read("!H")[0]
-        obj.buffer_id = reader.read("!L")[0]
-        obj.out_port = util.unpack_port_no(reader)
-        obj.out_group = reader.read("!L")[0]
-        obj.flags = reader.read("!H")[0]
-        reader.skip(2)
-        obj.match = ofp.match.unpack(reader)
-        obj.instructions = loxi.generic_util.unpack_list(reader, ofp.instruction.instruction.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.cookie != other.cookie: return False
-        if self.cookie_mask != other.cookie_mask: return False
-        if self.table_id != other.table_id: return False
-        if self.idle_timeout != other.idle_timeout: return False
-        if self.hard_timeout != other.hard_timeout: return False
-        if self.priority != other.priority: return False
-        if self.buffer_id != other.buffer_id: return False
-        if self.out_port != other.out_port: return False
-        if self.out_group != other.out_group: return False
-        if self.flags != other.flags: return False
-        if self.match != other.match: return False
-        if self.instructions != other.instructions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_modify_strict {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("cookie_mask = ");
-                q.text("%#x" % self.cookie_mask)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("idle_timeout = ");
-                q.text("%#x" % self.idle_timeout)
-                q.text(","); q.breakable()
-                q.text("hard_timeout = ");
-                q.text("%#x" % self.hard_timeout)
-                q.text(","); q.breakable()
-                q.text("priority = ");
-                q.text("%#x" % self.priority)
-                q.text(","); q.breakable()
-                q.text("buffer_id = ");
-                q.text("%#x" % self.buffer_id)
-                q.text(","); q.breakable()
-                q.text("out_port = ");
-                q.text(util.pretty_port(self.out_port))
-                q.text(","); q.breakable()
-                q.text("out_group = ");
-                q.text("%#x" % self.out_group)
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-                q.text(","); q.breakable()
-                q.text("instructions = ");
-                q.pp(self.instructions)
-            q.breakable()
-        q.text('}')
-
-flow_mod.subtypes[2] = flow_modify_strict
-
-class flow_removed(message):
-    version = 3
-    type = 11
-
-    def __init__(self, xid=None, cookie=None, priority=None, reason=None, table_id=None, duration_sec=None, duration_nsec=None, idle_timeout=None, hard_timeout=None, packet_count=None, byte_count=None, match=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if priority != None:
-            self.priority = priority
-        else:
-            self.priority = 0
-        if reason != None:
-            self.reason = reason
-        else:
-            self.reason = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if duration_sec != None:
-            self.duration_sec = duration_sec
-        else:
-            self.duration_sec = 0
-        if duration_nsec != None:
-            self.duration_nsec = duration_nsec
-        else:
-            self.duration_nsec = 0
-        if idle_timeout != None:
-            self.idle_timeout = idle_timeout
-        else:
-            self.idle_timeout = 0
-        if hard_timeout != None:
-            self.hard_timeout = hard_timeout
-        else:
-            self.hard_timeout = 0
-        if packet_count != None:
-            self.packet_count = packet_count
-        else:
-            self.packet_count = 0
-        if byte_count != None:
-            self.byte_count = byte_count
-        else:
-            self.byte_count = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(struct.pack("!H", self.priority))
-        packed.append(struct.pack("!B", self.reason))
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append(struct.pack("!L", self.duration_sec))
-        packed.append(struct.pack("!L", self.duration_nsec))
-        packed.append(struct.pack("!H", self.idle_timeout))
-        packed.append(struct.pack("!H", self.hard_timeout))
-        packed.append(struct.pack("!Q", self.packet_count))
-        packed.append(struct.pack("!Q", self.byte_count))
-        packed.append(self.match.pack())
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_removed()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 11)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.cookie = reader.read("!Q")[0]
-        obj.priority = reader.read("!H")[0]
-        obj.reason = reader.read("!B")[0]
-        obj.table_id = reader.read("!B")[0]
-        obj.duration_sec = reader.read("!L")[0]
-        obj.duration_nsec = reader.read("!L")[0]
-        obj.idle_timeout = reader.read("!H")[0]
-        obj.hard_timeout = reader.read("!H")[0]
-        obj.packet_count = reader.read("!Q")[0]
-        obj.byte_count = reader.read("!Q")[0]
-        obj.match = ofp.match.unpack(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.cookie != other.cookie: return False
-        if self.priority != other.priority: return False
-        if self.reason != other.reason: return False
-        if self.table_id != other.table_id: return False
-        if self.duration_sec != other.duration_sec: return False
-        if self.duration_nsec != other.duration_nsec: return False
-        if self.idle_timeout != other.idle_timeout: return False
-        if self.hard_timeout != other.hard_timeout: return False
-        if self.packet_count != other.packet_count: return False
-        if self.byte_count != other.byte_count: return False
-        if self.match != other.match: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_removed {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("priority = ");
-                q.text("%#x" % self.priority)
-                q.text(","); q.breakable()
-                q.text("reason = ");
-                q.text("%#x" % self.reason)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("duration_sec = ");
-                q.text("%#x" % self.duration_sec)
-                q.text(","); q.breakable()
-                q.text("duration_nsec = ");
-                q.text("%#x" % self.duration_nsec)
-                q.text(","); q.breakable()
-                q.text("idle_timeout = ");
-                q.text("%#x" % self.idle_timeout)
-                q.text(","); q.breakable()
-                q.text("hard_timeout = ");
-                q.text("%#x" % self.hard_timeout)
-                q.text(","); q.breakable()
-                q.text("packet_count = ");
-                q.text("%#x" % self.packet_count)
-                q.text(","); q.breakable()
-                q.text("byte_count = ");
-                q.text("%#x" % self.byte_count)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[11] = flow_removed
-
-class flow_stats_reply(stats_reply):
-    version = 3
-    type = 19
-    stats_type = 1
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 1)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.flow_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[1] = flow_stats_reply
-
-class flow_stats_request(stats_request):
-    version = 3
-    type = 18
-    stats_type = 1
-
-    def __init__(self, xid=None, flags=None, table_id=None, out_port=None, out_group=None, cookie=None, cookie_mask=None, match=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if out_port != None:
-            self.out_port = out_port
-        else:
-            self.out_port = 0
-        if out_group != None:
-            self.out_group = out_group
-        else:
-            self.out_group = 0
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if cookie_mask != None:
-            self.cookie_mask = cookie_mask
-        else:
-            self.cookie_mask = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append('\x00' * 3)
-        packed.append(util.pack_port_no(self.out_port))
-        packed.append(struct.pack("!L", self.out_group))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(struct.pack("!Q", self.cookie_mask))
-        packed.append(self.match.pack())
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 1)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.table_id = reader.read("!B")[0]
-        reader.skip(3)
-        obj.out_port = util.unpack_port_no(reader)
-        obj.out_group = reader.read("!L")[0]
-        reader.skip(4)
-        obj.cookie = reader.read("!Q")[0]
-        obj.cookie_mask = reader.read("!Q")[0]
-        obj.match = ofp.match.unpack(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.table_id != other.table_id: return False
-        if self.out_port != other.out_port: return False
-        if self.out_group != other.out_group: return False
-        if self.cookie != other.cookie: return False
-        if self.cookie_mask != other.cookie_mask: return False
-        if self.match != other.match: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("out_port = ");
-                q.text(util.pretty_port(self.out_port))
-                q.text(","); q.breakable()
-                q.text("out_group = ");
-                q.text("%#x" % self.out_group)
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("cookie_mask = ");
-                q.text("%#x" % self.cookie_mask)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[1] = flow_stats_request
-
-class get_config_reply(message):
-    version = 3
-    type = 8
-
-    def __init__(self, xid=None, flags=None, miss_send_len=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if miss_send_len != None:
-            self.miss_send_len = miss_send_len
-        else:
-            self.miss_send_len = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append(struct.pack("!H", self.miss_send_len))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = get_config_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 8)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.flags = reader.read("!H")[0]
-        obj.miss_send_len = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.miss_send_len != other.miss_send_len: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("get_config_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("miss_send_len = ");
-                q.text("%#x" % self.miss_send_len)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[8] = get_config_reply
-
-class get_config_request(message):
-    version = 3
-    type = 7
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = get_config_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 7)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("get_config_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-message.subtypes[7] = get_config_request
-
-class group_mod(message):
-    subtypes = {}
-
-    version = 3
-    type = 15
-
-    def __init__(self, xid=None, command=None, group_type=None, group_id=None, buckets=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if command != None:
-            self.command = command
-        else:
-            self.command = 0
-        if group_type != None:
-            self.group_type = group_type
-        else:
-            self.group_type = 0
-        if group_id != None:
-            self.group_id = group_id
-        else:
-            self.group_id = 0
-        if buckets != None:
-            self.buckets = buckets
-        else:
-            self.buckets = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.command))
-        packed.append(struct.pack("!B", self.group_type))
-        packed.append('\x00' * 1)
-        packed.append(struct.pack("!L", self.group_id))
-        packed.append(loxi.generic_util.pack_list(self.buckets))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 8)
-        subclass = group_mod.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = group_mod()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 15)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.command = reader.read("!H")[0]
-        obj.group_type = reader.read("!B")[0]
-        reader.skip(1)
-        obj.group_id = reader.read("!L")[0]
-        obj.buckets = loxi.generic_util.unpack_list(reader, ofp.common.bucket.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.command != other.command: return False
-        if self.group_type != other.group_type: return False
-        if self.group_id != other.group_id: return False
-        if self.buckets != other.buckets: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_mod {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("group_type = ");
-                q.text("%#x" % self.group_type)
-                q.text(","); q.breakable()
-                q.text("group_id = ");
-                q.text("%#x" % self.group_id)
-                q.text(","); q.breakable()
-                q.text("buckets = ");
-                q.pp(self.buckets)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[15] = group_mod
-
-class group_add(group_mod):
-    version = 3
-    type = 15
-    command = 0
-
-    def __init__(self, xid=None, group_type=None, group_id=None, buckets=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if group_type != None:
-            self.group_type = group_type
-        else:
-            self.group_type = 0
-        if group_id != None:
-            self.group_id = group_id
-        else:
-            self.group_id = 0
-        if buckets != None:
-            self.buckets = buckets
-        else:
-            self.buckets = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.command))
-        packed.append(struct.pack("!B", self.group_type))
-        packed.append('\x00' * 1)
-        packed.append(struct.pack("!L", self.group_id))
-        packed.append(loxi.generic_util.pack_list(self.buckets))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group_add()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 15)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _command = reader.read("!H")[0]
-        assert(_command == 0)
-        obj.group_type = reader.read("!B")[0]
-        reader.skip(1)
-        obj.group_id = reader.read("!L")[0]
-        obj.buckets = loxi.generic_util.unpack_list(reader, ofp.common.bucket.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.group_type != other.group_type: return False
-        if self.group_id != other.group_id: return False
-        if self.buckets != other.buckets: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_add {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("group_type = ");
-                q.text("%#x" % self.group_type)
-                q.text(","); q.breakable()
-                q.text("group_id = ");
-                q.text("%#x" % self.group_id)
-                q.text(","); q.breakable()
-                q.text("buckets = ");
-                q.pp(self.buckets)
-            q.breakable()
-        q.text('}')
-
-group_mod.subtypes[0] = group_add
-
-class group_delete(group_mod):
-    version = 3
-    type = 15
-    command = 2
-
-    def __init__(self, xid=None, group_type=None, group_id=None, buckets=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if group_type != None:
-            self.group_type = group_type
-        else:
-            self.group_type = 0
-        if group_id != None:
-            self.group_id = group_id
-        else:
-            self.group_id = 0
-        if buckets != None:
-            self.buckets = buckets
-        else:
-            self.buckets = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.command))
-        packed.append(struct.pack("!B", self.group_type))
-        packed.append('\x00' * 1)
-        packed.append(struct.pack("!L", self.group_id))
-        packed.append(loxi.generic_util.pack_list(self.buckets))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group_delete()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 15)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _command = reader.read("!H")[0]
-        assert(_command == 2)
-        obj.group_type = reader.read("!B")[0]
-        reader.skip(1)
-        obj.group_id = reader.read("!L")[0]
-        obj.buckets = loxi.generic_util.unpack_list(reader, ofp.common.bucket.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.group_type != other.group_type: return False
-        if self.group_id != other.group_id: return False
-        if self.buckets != other.buckets: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_delete {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("group_type = ");
-                q.text("%#x" % self.group_type)
-                q.text(","); q.breakable()
-                q.text("group_id = ");
-                q.text("%#x" % self.group_id)
-                q.text(","); q.breakable()
-                q.text("buckets = ");
-                q.pp(self.buckets)
-            q.breakable()
-        q.text('}')
-
-group_mod.subtypes[2] = group_delete
-
-class group_desc_stats_reply(stats_reply):
-    version = 3
-    type = 19
-    stats_type = 7
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group_desc_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 7)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.group_desc_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_desc_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[7] = group_desc_stats_reply
-
-class group_desc_stats_request(stats_request):
-    version = 3
-    type = 18
-    stats_type = 7
-
-    def __init__(self, xid=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group_desc_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 7)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_desc_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[7] = group_desc_stats_request
-
-class group_features_stats_reply(stats_reply):
-    version = 3
-    type = 19
-    stats_type = 8
-
-    def __init__(self, xid=None, flags=None, types=None, capabilities=None, max_groups_all=None, max_groups_select=None, max_groups_indirect=None, max_groups_ff=None, actions_all=None, actions_select=None, actions_indirect=None, actions_ff=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if types != None:
-            self.types = types
-        else:
-            self.types = 0
-        if capabilities != None:
-            self.capabilities = capabilities
-        else:
-            self.capabilities = 0
-        if max_groups_all != None:
-            self.max_groups_all = max_groups_all
-        else:
-            self.max_groups_all = 0
-        if max_groups_select != None:
-            self.max_groups_select = max_groups_select
-        else:
-            self.max_groups_select = 0
-        if max_groups_indirect != None:
-            self.max_groups_indirect = max_groups_indirect
-        else:
-            self.max_groups_indirect = 0
-        if max_groups_ff != None:
-            self.max_groups_ff = max_groups_ff
-        else:
-            self.max_groups_ff = 0
-        if actions_all != None:
-            self.actions_all = actions_all
-        else:
-            self.actions_all = 0
-        if actions_select != None:
-            self.actions_select = actions_select
-        else:
-            self.actions_select = 0
-        if actions_indirect != None:
-            self.actions_indirect = actions_indirect
-        else:
-            self.actions_indirect = 0
-        if actions_ff != None:
-            self.actions_ff = actions_ff
-        else:
-            self.actions_ff = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.types))
-        packed.append(struct.pack("!L", self.capabilities))
-        packed.append(struct.pack("!L", self.max_groups_all))
-        packed.append(struct.pack("!L", self.max_groups_select))
-        packed.append(struct.pack("!L", self.max_groups_indirect))
-        packed.append(struct.pack("!L", self.max_groups_ff))
-        packed.append(struct.pack("!L", self.actions_all))
-        packed.append(struct.pack("!L", self.actions_select))
-        packed.append(struct.pack("!L", self.actions_indirect))
-        packed.append(struct.pack("!L", self.actions_ff))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group_features_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 8)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.types = reader.read("!L")[0]
-        obj.capabilities = reader.read("!L")[0]
-        obj.max_groups_all = reader.read("!L")[0]
-        obj.max_groups_select = reader.read("!L")[0]
-        obj.max_groups_indirect = reader.read("!L")[0]
-        obj.max_groups_ff = reader.read("!L")[0]
-        obj.actions_all = reader.read("!L")[0]
-        obj.actions_select = reader.read("!L")[0]
-        obj.actions_indirect = reader.read("!L")[0]
-        obj.actions_ff = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.types != other.types: return False
-        if self.capabilities != other.capabilities: return False
-        if self.max_groups_all != other.max_groups_all: return False
-        if self.max_groups_select != other.max_groups_select: return False
-        if self.max_groups_indirect != other.max_groups_indirect: return False
-        if self.max_groups_ff != other.max_groups_ff: return False
-        if self.actions_all != other.actions_all: return False
-        if self.actions_select != other.actions_select: return False
-        if self.actions_indirect != other.actions_indirect: return False
-        if self.actions_ff != other.actions_ff: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_features_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("types = ");
-                q.text("%#x" % self.types)
-                q.text(","); q.breakable()
-                q.text("capabilities = ");
-                q.text("%#x" % self.capabilities)
-                q.text(","); q.breakable()
-                q.text("max_groups_all = ");
-                q.text("%#x" % self.max_groups_all)
-                q.text(","); q.breakable()
-                q.text("max_groups_select = ");
-                q.text("%#x" % self.max_groups_select)
-                q.text(","); q.breakable()
-                q.text("max_groups_indirect = ");
-                q.text("%#x" % self.max_groups_indirect)
-                q.text(","); q.breakable()
-                q.text("max_groups_ff = ");
-                q.text("%#x" % self.max_groups_ff)
-                q.text(","); q.breakable()
-                q.text("actions_all = ");
-                q.text("%#x" % self.actions_all)
-                q.text(","); q.breakable()
-                q.text("actions_select = ");
-                q.text("%#x" % self.actions_select)
-                q.text(","); q.breakable()
-                q.text("actions_indirect = ");
-                q.text("%#x" % self.actions_indirect)
-                q.text(","); q.breakable()
-                q.text("actions_ff = ");
-                q.text("%#x" % self.actions_ff)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[8] = group_features_stats_reply
-
-class group_features_stats_request(stats_request):
-    version = 3
-    type = 18
-    stats_type = 8
-
-    def __init__(self, xid=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group_features_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 8)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_features_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[8] = group_features_stats_request
-
-class group_mod_failed_error_msg(error_msg):
-    version = 3
-    type = 1
-    err_type = 6
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group_mod_failed_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 6)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_mod_failed_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[6] = group_mod_failed_error_msg
-
-class group_modify(group_mod):
-    version = 3
-    type = 15
-    command = 1
-
-    def __init__(self, xid=None, group_type=None, group_id=None, buckets=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if group_type != None:
-            self.group_type = group_type
-        else:
-            self.group_type = 0
-        if group_id != None:
-            self.group_id = group_id
-        else:
-            self.group_id = 0
-        if buckets != None:
-            self.buckets = buckets
-        else:
-            self.buckets = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.command))
-        packed.append(struct.pack("!B", self.group_type))
-        packed.append('\x00' * 1)
-        packed.append(struct.pack("!L", self.group_id))
-        packed.append(loxi.generic_util.pack_list(self.buckets))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group_modify()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 15)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _command = reader.read("!H")[0]
-        assert(_command == 1)
-        obj.group_type = reader.read("!B")[0]
-        reader.skip(1)
-        obj.group_id = reader.read("!L")[0]
-        obj.buckets = loxi.generic_util.unpack_list(reader, ofp.common.bucket.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.group_type != other.group_type: return False
-        if self.group_id != other.group_id: return False
-        if self.buckets != other.buckets: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_modify {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("group_type = ");
-                q.text("%#x" % self.group_type)
-                q.text(","); q.breakable()
-                q.text("group_id = ");
-                q.text("%#x" % self.group_id)
-                q.text(","); q.breakable()
-                q.text("buckets = ");
-                q.pp(self.buckets)
-            q.breakable()
-        q.text('}')
-
-group_mod.subtypes[1] = group_modify
-
-class group_stats_reply(stats_reply):
-    version = 3
-    type = 19
-    stats_type = 6
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 6)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.group_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[6] = group_stats_reply
-
-class group_stats_request(stats_request):
-    version = 3
-    type = 18
-    stats_type = 6
-
-    def __init__(self, xid=None, flags=None, group_id=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if group_id != None:
-            self.group_id = group_id
-        else:
-            self.group_id = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.group_id))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 6)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.group_id = reader.read("!L")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.group_id != other.group_id: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("group_id = ");
-                q.text("%#x" % self.group_id)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[6] = group_stats_request
-
-class hello(message):
-    version = 3
-    type = 0
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = hello()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 0)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("hello {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-message.subtypes[0] = hello
-
-class hello_failed_error_msg(error_msg):
-    version = 3
-    type = 1
-    err_type = 0
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = hello_failed_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 0)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("hello_failed_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[0] = hello_failed_error_msg
-
-class nicira_header(experimenter):
-    subtypes = {}
-
-    version = 3
-    type = 4
-    experimenter = 8992
-
-    def __init__(self, xid=None, subtype=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 12)
-        subclass = nicira_header.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = nicira_header()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 8992)
-        obj.subtype = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.subtype != other.subtype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("nicira_header {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-experimenter.subtypes[8992] = nicira_header
-
-class packet_in(message):
-    version = 3
-    type = 10
-
-    def __init__(self, xid=None, buffer_id=None, total_len=None, reason=None, table_id=None, match=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if buffer_id != None:
-            self.buffer_id = buffer_id
-        else:
-            self.buffer_id = 0
-        if total_len != None:
-            self.total_len = total_len
-        else:
-            self.total_len = 0
-        if reason != None:
-            self.reason = reason
-        else:
-            self.reason = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.buffer_id))
-        packed.append(struct.pack("!H", self.total_len))
-        packed.append(struct.pack("!B", self.reason))
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append(self.match.pack())
-        packed.append('\x00' * 2)
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = packet_in()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 10)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.buffer_id = reader.read("!L")[0]
-        obj.total_len = reader.read("!H")[0]
-        obj.reason = reader.read("!B")[0]
-        obj.table_id = reader.read("!B")[0]
-        obj.match = ofp.match.unpack(reader)
-        reader.skip(2)
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.buffer_id != other.buffer_id: return False
-        if self.total_len != other.total_len: return False
-        if self.reason != other.reason: return False
-        if self.table_id != other.table_id: return False
-        if self.match != other.match: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("packet_in {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("buffer_id = ");
-                q.text("%#x" % self.buffer_id)
-                q.text(","); q.breakable()
-                q.text("total_len = ");
-                q.text("%#x" % self.total_len)
-                q.text(","); q.breakable()
-                q.text("reason = ");
-                q.text("%#x" % self.reason)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[10] = packet_in
-
-class packet_out(message):
-    version = 3
-    type = 13
-
-    def __init__(self, xid=None, buffer_id=None, in_port=None, actions=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if buffer_id != None:
-            self.buffer_id = buffer_id
-        else:
-            self.buffer_id = 0
-        if in_port != None:
-            self.in_port = in_port
-        else:
-            self.in_port = 0
-        if actions != None:
-            self.actions = actions
-        else:
-            self.actions = []
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.buffer_id))
-        packed.append(util.pack_port_no(self.in_port))
-        packed.append(struct.pack("!H", 0)) # placeholder for actions_len at index 6
-        packed.append('\x00' * 6)
-        packed.append(loxi.generic_util.pack_list(self.actions))
-        packed[6] = struct.pack("!H", len(packed[-1]))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = packet_out()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 13)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.buffer_id = reader.read("!L")[0]
-        obj.in_port = util.unpack_port_no(reader)
-        _actions_len = reader.read("!H")[0]
-        reader.skip(6)
-        obj.actions = loxi.generic_util.unpack_list(reader.slice(_actions_len), ofp.action.action.unpack)
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.buffer_id != other.buffer_id: return False
-        if self.in_port != other.in_port: return False
-        if self.actions != other.actions: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("packet_out {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("buffer_id = ");
-                q.text("%#x" % self.buffer_id)
-                q.text(","); q.breakable()
-                q.text("in_port = ");
-                q.text(util.pretty_port(self.in_port))
-                q.text(","); q.breakable()
-                q.text("actions = ");
-                q.pp(self.actions)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[13] = packet_out
-
-class port_mod(message):
-    version = 3
-    type = 16
-
-    def __init__(self, xid=None, port_no=None, hw_addr=None, config=None, mask=None, advertise=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if hw_addr != None:
-            self.hw_addr = hw_addr
-        else:
-            self.hw_addr = [0,0,0,0,0,0]
-        if config != None:
-            self.config = config
-        else:
-            self.config = 0
-        if mask != None:
-            self.mask = mask
-        else:
-            self.mask = 0
-        if advertise != None:
-            self.advertise = advertise
-        else:
-            self.advertise = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!6B", *self.hw_addr))
-        packed.append('\x00' * 2)
-        packed.append(struct.pack("!L", self.config))
-        packed.append(struct.pack("!L", self.mask))
-        packed.append(struct.pack("!L", self.advertise))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = port_mod()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 16)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.port_no = util.unpack_port_no(reader)
-        reader.skip(4)
-        obj.hw_addr = list(reader.read('!6B'))
-        reader.skip(2)
-        obj.config = reader.read("!L")[0]
-        obj.mask = reader.read("!L")[0]
-        obj.advertise = reader.read("!L")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.port_no != other.port_no: return False
-        if self.hw_addr != other.hw_addr: return False
-        if self.config != other.config: return False
-        if self.mask != other.mask: return False
-        if self.advertise != other.advertise: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port_mod {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("hw_addr = ");
-                q.text(util.pretty_mac(self.hw_addr))
-                q.text(","); q.breakable()
-                q.text("config = ");
-                q.text("%#x" % self.config)
-                q.text(","); q.breakable()
-                q.text("mask = ");
-                q.text("%#x" % self.mask)
-                q.text(","); q.breakable()
-                q.text("advertise = ");
-                q.text("%#x" % self.advertise)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[16] = port_mod
-
-class port_mod_failed_error_msg(error_msg):
-    version = 3
-    type = 1
-    err_type = 7
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = port_mod_failed_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 7)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port_mod_failed_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[7] = port_mod_failed_error_msg
-
-class port_stats_reply(stats_reply):
-    version = 3
-    type = 19
-    stats_type = 4
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = port_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 4)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.port_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[4] = port_stats_reply
-
-class port_stats_request(stats_request):
-    version = 3
-    type = 18
-    stats_type = 4
-
-    def __init__(self, xid=None, flags=None, port_no=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = port_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 4)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.port_no = util.unpack_port_no(reader)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.port_no != other.port_no: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[4] = port_stats_request
-
-class port_status(message):
-    version = 3
-    type = 12
-
-    def __init__(self, xid=None, reason=None, desc=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if reason != None:
-            self.reason = reason
-        else:
-            self.reason = 0
-        if desc != None:
-            self.desc = desc
-        else:
-            self.desc = ofp.port_desc()
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!B", self.reason))
-        packed.append('\x00' * 7)
-        packed.append(self.desc.pack())
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = port_status()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 12)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.reason = reader.read("!B")[0]
-        reader.skip(7)
-        obj.desc = ofp.port_desc.unpack(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.reason != other.reason: return False
-        if self.desc != other.desc: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port_status {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("reason = ");
-                q.text("%#x" % self.reason)
-                q.text(","); q.breakable()
-                q.text("desc = ");
-                q.pp(self.desc)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[12] = port_status
-
-class queue_get_config_reply(message):
-    version = 3
-    type = 23
-
-    def __init__(self, xid=None, port=None, queues=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if port != None:
-            self.port = port
-        else:
-            self.port = 0
-        if queues != None:
-            self.queues = queues
-        else:
-            self.queues = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(util.pack_port_no(self.port))
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.queues))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = queue_get_config_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 23)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.port = util.unpack_port_no(reader)
-        reader.skip(4)
-        obj.queues = loxi.generic_util.unpack_list(reader, ofp.common.packet_queue.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.port != other.port: return False
-        if self.queues != other.queues: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_get_config_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("port = ");
-                q.text(util.pretty_port(self.port))
-                q.text(","); q.breakable()
-                q.text("queues = ");
-                q.pp(self.queues)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[23] = queue_get_config_reply
-
-class queue_get_config_request(message):
-    version = 3
-    type = 22
-
-    def __init__(self, xid=None, port=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if port != None:
-            self.port = port
-        else:
-            self.port = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(util.pack_port_no(self.port))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = queue_get_config_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 22)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.port = util.unpack_port_no(reader)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.port != other.port: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_get_config_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("port = ");
-                q.text(util.pretty_port(self.port))
-            q.breakable()
-        q.text('}')
-
-message.subtypes[22] = queue_get_config_request
-
-class queue_op_failed_error_msg(error_msg):
-    version = 3
-    type = 1
-    err_type = 9
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = queue_op_failed_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 9)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_op_failed_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[9] = queue_op_failed_error_msg
-
-class queue_stats_reply(stats_reply):
-    version = 3
-    type = 19
-    stats_type = 5
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = queue_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 5)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.queue_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[5] = queue_stats_reply
-
-class queue_stats_request(stats_request):
-    version = 3
-    type = 18
-    stats_type = 5
-
-    def __init__(self, xid=None, flags=None, port_no=None, queue_id=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if queue_id != None:
-            self.queue_id = queue_id
-        else:
-            self.queue_id = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(struct.pack("!L", self.queue_id))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = queue_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 5)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.port_no = util.unpack_port_no(reader)
-        obj.queue_id = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.port_no != other.port_no: return False
-        if self.queue_id != other.queue_id: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("queue_id = ");
-                q.text("%#x" % self.queue_id)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[5] = queue_stats_request
-
-class role_reply(message):
-    version = 3
-    type = 25
-
-    def __init__(self, xid=None, role=None, generation_id=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if role != None:
-            self.role = role
-        else:
-            self.role = 0
-        if generation_id != None:
-            self.generation_id = generation_id
-        else:
-            self.generation_id = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.role))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!Q", self.generation_id))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = role_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 25)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.role = reader.read("!L")[0]
-        reader.skip(4)
-        obj.generation_id = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.role != other.role: return False
-        if self.generation_id != other.generation_id: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("role_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("role = ");
-                q.text("%#x" % self.role)
-                q.text(","); q.breakable()
-                q.text("generation_id = ");
-                q.text("%#x" % self.generation_id)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[25] = role_reply
-
-class role_request(message):
-    version = 3
-    type = 24
-
-    def __init__(self, xid=None, role=None, generation_id=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if role != None:
-            self.role = role
-        else:
-            self.role = 0
-        if generation_id != None:
-            self.generation_id = generation_id
-        else:
-            self.generation_id = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.role))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!Q", self.generation_id))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = role_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 24)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.role = reader.read("!L")[0]
-        reader.skip(4)
-        obj.generation_id = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.role != other.role: return False
-        if self.generation_id != other.generation_id: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("role_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("role = ");
-                q.text("%#x" % self.role)
-                q.text(","); q.breakable()
-                q.text("generation_id = ");
-                q.text("%#x" % self.generation_id)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[24] = role_request
-
-class role_request_failed_error_msg(error_msg):
-    version = 3
-    type = 1
-    err_type = 11
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = role_request_failed_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 11)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("role_request_failed_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[11] = role_request_failed_error_msg
-
-class set_config(message):
-    version = 3
-    type = 9
-
-    def __init__(self, xid=None, flags=None, miss_send_len=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if miss_send_len != None:
-            self.miss_send_len = miss_send_len
-        else:
-            self.miss_send_len = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append(struct.pack("!H", self.miss_send_len))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_config()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 9)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.flags = reader.read("!H")[0]
-        obj.miss_send_len = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.miss_send_len != other.miss_send_len: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_config {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("miss_send_len = ");
-                q.text("%#x" % self.miss_send_len)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[9] = set_config
-
-class switch_config_failed_error_msg(error_msg):
-    version = 3
-    type = 1
-    err_type = 10
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = switch_config_failed_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 10)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("switch_config_failed_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[10] = switch_config_failed_error_msg
-
-class table_mod(message):
-    version = 3
-    type = 17
-
-    def __init__(self, xid=None, table_id=None, config=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if config != None:
-            self.config = config
-        else:
-            self.config = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append('\x00' * 3)
-        packed.append(struct.pack("!L", self.config))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_mod()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 17)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.table_id = reader.read("!B")[0]
-        reader.skip(3)
-        obj.config = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.table_id != other.table_id: return False
-        if self.config != other.config: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_mod {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("config = ");
-                q.text("%#x" % self.config)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[17] = table_mod
-
-class table_mod_failed_error_msg(error_msg):
-    version = 3
-    type = 1
-    err_type = 8
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_mod_failed_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 8)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_mod_failed_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[8] = table_mod_failed_error_msg
-
-class table_stats_reply(stats_reply):
-    version = 3
-    type = 19
-    stats_type = 3
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 3)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.table_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[3] = table_stats_reply
-
-class table_stats_request(stats_request):
-    version = 3
-    type = 18
-    stats_type = 3
-
-    def __init__(self, xid=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 3)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 3)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[3] = table_stats_request
-
-
-def parse_header(buf):
-    if len(buf) < 8:
-        raise loxi.ProtocolError("too short to be an OpenFlow message")
-    return struct.unpack_from("!BBHL", buf)
-
-def parse_message(buf):
-    msg_ver, msg_type, msg_len, msg_xid = parse_header(buf)
-    if msg_ver != ofp.OFP_VERSION and msg_type != ofp.OFPT_HELLO:
-        raise loxi.ProtocolError("wrong OpenFlow version (expected %d, got %d)" % (ofp.OFP_VERSION, msg_ver))
-    if len(buf) != msg_len:
-        raise loxi.ProtocolError("incorrect message size")
-    return message.unpack(loxi.generic_util.OFReader(buf))
diff --git a/python/ofagent/loxi/of12/oxm.py b/python/ofagent/loxi/of12/oxm.py
deleted file mode 100644
index f2d6dfe..0000000
--- a/python/ofagent/loxi/of12/oxm.py
+++ /dev/null
@@ -1,5499 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template module.py
-# Do not modify
-
-import struct
-import loxi
-import util
-import loxi.generic_util
-
-import sys
-ofp = sys.modules['loxi.of12']
-
-class oxm(loxi.OFObject):
-    subtypes = {}
-
-
-    def __init__(self, type_len=None):
-        if type_len != None:
-            self.type_len = type_len
-        else:
-            self.type_len = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 0)
-        subclass = oxm.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = oxm()
-        obj.type_len = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type_len != other.type_len: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("oxm {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-
-class arp_op(oxm):
-    type_len = 2147494402
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = arp_op()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147494402)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("arp_op {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147494402] = arp_op
-
-class arp_op_masked(oxm):
-    type_len = 2147494660
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        packed.append(struct.pack("!H", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = arp_op_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147494660)
-        obj.value = reader.read("!H")[0]
-        obj.value_mask = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("arp_op_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147494660] = arp_op_masked
-
-class arp_sha(oxm):
-    type_len = 2147495942
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!6B", *self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = arp_sha()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147495942)
-        obj.value = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("arp_sha {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147495942] = arp_sha
-
-class arp_sha_masked(oxm):
-    type_len = 2147496204
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!6B", *self.value))
-        packed.append(struct.pack("!6B", *self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = arp_sha_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147496204)
-        obj.value = list(reader.read('!6B'))
-        obj.value_mask = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("arp_sha_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text(util.pretty_mac(self.value_mask))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147496204] = arp_sha_masked
-
-class arp_spa(oxm):
-    type_len = 2147494916
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = arp_spa()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147494916)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("arp_spa {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147494916] = arp_spa
-
-class arp_spa_masked(oxm):
-    type_len = 2147495176
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = arp_spa_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147495176)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("arp_spa_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147495176] = arp_spa_masked
-
-class arp_tha(oxm):
-    type_len = 2147496454
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!6B", *self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = arp_tha()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147496454)
-        obj.value = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("arp_tha {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147496454] = arp_tha
-
-class arp_tha_masked(oxm):
-    type_len = 2147496716
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!6B", *self.value))
-        packed.append(struct.pack("!6B", *self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = arp_tha_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147496716)
-        obj.value = list(reader.read('!6B'))
-        obj.value_mask = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("arp_tha_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text(util.pretty_mac(self.value_mask))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147496716] = arp_tha_masked
-
-class arp_tpa(oxm):
-    type_len = 2147495428
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = arp_tpa()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147495428)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("arp_tpa {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147495428] = arp_tpa
-
-class arp_tpa_masked(oxm):
-    type_len = 2147495688
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = arp_tpa_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147495688)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("arp_tpa_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147495688] = arp_tpa_masked
-
-class bsn_egr_port_group_id(oxm):
-    type_len = 200196
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_egr_port_group_id()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 200196)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_egr_port_group_id {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[200196] = bsn_egr_port_group_id
-
-class bsn_egr_port_group_id_masked(oxm):
-    type_len = 200456
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_egr_port_group_id_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 200456)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_egr_port_group_id_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[200456] = bsn_egr_port_group_id_masked
-
-class bsn_global_vrf_allowed(oxm):
-    type_len = 198145
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_global_vrf_allowed()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 198145)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_global_vrf_allowed {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[198145] = bsn_global_vrf_allowed
-
-class bsn_global_vrf_allowed_masked(oxm):
-    type_len = 198402
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        packed.append(struct.pack("!B", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_global_vrf_allowed_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 198402)
-        obj.value = reader.read("!B")[0]
-        obj.value_mask = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_global_vrf_allowed_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[198402] = bsn_global_vrf_allowed_masked
-
-class bsn_in_ports_128(oxm):
-    type_len = 196624
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = set()
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(util.pack_bitmap_128(self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_in_ports_128()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 196624)
-        obj.value = util.unpack_bitmap_128(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_in_ports_128 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.pp(self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[196624] = bsn_in_ports_128
-
-class bsn_in_ports_128_masked(oxm):
-    type_len = 196896
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = set()
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = set()
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(util.pack_bitmap_128(self.value))
-        packed.append(util.pack_bitmap_128(self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_in_ports_128_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 196896)
-        obj.value = util.unpack_bitmap_128(reader)
-        obj.value_mask = util.unpack_bitmap_128(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_in_ports_128_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.pp(self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.pp(self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[196896] = bsn_in_ports_128_masked
-
-class bsn_in_ports_512(oxm):
-    type_len = 206400
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = set()
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(util.pack_bitmap_512(self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_in_ports_512()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 206400)
-        obj.value = util.unpack_bitmap_512(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_in_ports_512 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.pp(self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[206400] = bsn_in_ports_512
-
-class bsn_in_ports_512_masked(oxm):
-    type_len = 206720
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = set()
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = set()
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(util.pack_bitmap_512(self.value))
-        packed.append(util.pack_bitmap_512(self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_in_ports_512_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 206720)
-        obj.value = util.unpack_bitmap_512(reader)
-        obj.value_mask = util.unpack_bitmap_512(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_in_ports_512_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.pp(self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.pp(self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[206720] = bsn_in_ports_512_masked
-
-class bsn_ingress_port_group_id(oxm):
-    type_len = 206852
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_ingress_port_group_id()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 206852)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_ingress_port_group_id {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[206852] = bsn_ingress_port_group_id
-
-class bsn_ingress_port_group_id_masked(oxm):
-    type_len = 207112
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_ingress_port_group_id_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 207112)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_ingress_port_group_id_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[207112] = bsn_ingress_port_group_id_masked
-
-class bsn_l2_cache_hit(oxm):
-    type_len = 205825
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_l2_cache_hit()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 205825)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_l2_cache_hit {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[205825] = bsn_l2_cache_hit
-
-class bsn_l2_cache_hit_masked(oxm):
-    type_len = 206082
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        packed.append(struct.pack("!B", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_l2_cache_hit_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 206082)
-        obj.value = reader.read("!B")[0]
-        obj.value_mask = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_l2_cache_hit_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[206082] = bsn_l2_cache_hit_masked
-
-class bsn_l3_dst_class_id(oxm):
-    type_len = 199684
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_l3_dst_class_id()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 199684)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_l3_dst_class_id {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[199684] = bsn_l3_dst_class_id
-
-class bsn_l3_dst_class_id_masked(oxm):
-    type_len = 199944
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_l3_dst_class_id_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 199944)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_l3_dst_class_id_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[199944] = bsn_l3_dst_class_id_masked
-
-class bsn_l3_interface_class_id(oxm):
-    type_len = 198660
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_l3_interface_class_id()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 198660)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_l3_interface_class_id {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[198660] = bsn_l3_interface_class_id
-
-class bsn_l3_interface_class_id_masked(oxm):
-    type_len = 198920
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_l3_interface_class_id_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 198920)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_l3_interface_class_id_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[198920] = bsn_l3_interface_class_id_masked
-
-class bsn_l3_src_class_id(oxm):
-    type_len = 199172
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_l3_src_class_id()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 199172)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_l3_src_class_id {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[199172] = bsn_l3_src_class_id
-
-class bsn_l3_src_class_id_masked(oxm):
-    type_len = 199432
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_l3_src_class_id_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 199432)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_l3_src_class_id_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[199432] = bsn_l3_src_class_id_masked
-
-class bsn_lag_id(oxm):
-    type_len = 197124
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_lag_id()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 197124)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_lag_id {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[197124] = bsn_lag_id
-
-class bsn_lag_id_masked(oxm):
-    type_len = 197384
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_lag_id_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 197384)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_lag_id_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[197384] = bsn_lag_id_masked
-
-class bsn_tcp_flags(oxm):
-    type_len = 204802
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_tcp_flags()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 204802)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_tcp_flags {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[204802] = bsn_tcp_flags
-
-class bsn_tcp_flags_masked(oxm):
-    type_len = 205060
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        packed.append(struct.pack("!H", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_tcp_flags_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 205060)
-        obj.value = reader.read("!H")[0]
-        obj.value_mask = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_tcp_flags_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[205060] = bsn_tcp_flags_masked
-
-class bsn_udf0(oxm):
-    type_len = 200708
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf0()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 200708)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf0 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[200708] = bsn_udf0
-
-class bsn_udf0_masked(oxm):
-    type_len = 200968
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf0_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 200968)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf0_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[200968] = bsn_udf0_masked
-
-class bsn_udf1(oxm):
-    type_len = 201220
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf1()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 201220)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf1 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[201220] = bsn_udf1
-
-class bsn_udf1_masked(oxm):
-    type_len = 201480
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf1_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 201480)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf1_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[201480] = bsn_udf1_masked
-
-class bsn_udf2(oxm):
-    type_len = 201732
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf2()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 201732)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf2 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[201732] = bsn_udf2
-
-class bsn_udf2_masked(oxm):
-    type_len = 201992
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf2_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 201992)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf2_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[201992] = bsn_udf2_masked
-
-class bsn_udf3(oxm):
-    type_len = 202244
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf3()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 202244)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf3 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[202244] = bsn_udf3
-
-class bsn_udf3_masked(oxm):
-    type_len = 202504
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf3_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 202504)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf3_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[202504] = bsn_udf3_masked
-
-class bsn_udf4(oxm):
-    type_len = 202756
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf4()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 202756)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf4 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[202756] = bsn_udf4
-
-class bsn_udf4_masked(oxm):
-    type_len = 203016
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf4_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 203016)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf4_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[203016] = bsn_udf4_masked
-
-class bsn_udf5(oxm):
-    type_len = 203268
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf5()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 203268)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf5 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[203268] = bsn_udf5
-
-class bsn_udf5_masked(oxm):
-    type_len = 203528
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf5_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 203528)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf5_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[203528] = bsn_udf5_masked
-
-class bsn_udf6(oxm):
-    type_len = 203780
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf6()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 203780)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf6 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[203780] = bsn_udf6
-
-class bsn_udf6_masked(oxm):
-    type_len = 204040
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf6_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 204040)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf6_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[204040] = bsn_udf6_masked
-
-class bsn_udf7(oxm):
-    type_len = 204292
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf7()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 204292)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf7 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[204292] = bsn_udf7
-
-class bsn_udf7_masked(oxm):
-    type_len = 204552
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf7_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 204552)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf7_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[204552] = bsn_udf7_masked
-
-class bsn_vlan_xlate_port_group_id(oxm):
-    type_len = 205316
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_vlan_xlate_port_group_id()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 205316)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vlan_xlate_port_group_id {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[205316] = bsn_vlan_xlate_port_group_id
-
-class bsn_vlan_xlate_port_group_id_masked(oxm):
-    type_len = 205576
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_vlan_xlate_port_group_id_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 205576)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vlan_xlate_port_group_id_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[205576] = bsn_vlan_xlate_port_group_id_masked
-
-class bsn_vrf(oxm):
-    type_len = 197636
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_vrf()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 197636)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vrf {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[197636] = bsn_vrf
-
-class bsn_vrf_masked(oxm):
-    type_len = 197896
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_vrf_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 197896)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vrf_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[197896] = bsn_vrf_masked
-
-class eth_dst(oxm):
-    type_len = 2147485190
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!6B", *self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = eth_dst()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147485190)
-        obj.value = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("eth_dst {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147485190] = eth_dst
-
-class eth_dst_masked(oxm):
-    type_len = 2147485452
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!6B", *self.value))
-        packed.append(struct.pack("!6B", *self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = eth_dst_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147485452)
-        obj.value = list(reader.read('!6B'))
-        obj.value_mask = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("eth_dst_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text(util.pretty_mac(self.value_mask))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147485452] = eth_dst_masked
-
-class eth_src(oxm):
-    type_len = 2147485702
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!6B", *self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = eth_src()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147485702)
-        obj.value = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("eth_src {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147485702] = eth_src
-
-class eth_src_masked(oxm):
-    type_len = 2147485964
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!6B", *self.value))
-        packed.append(struct.pack("!6B", *self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = eth_src_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147485964)
-        obj.value = list(reader.read('!6B'))
-        obj.value_mask = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("eth_src_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text(util.pretty_mac(self.value_mask))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147485964] = eth_src_masked
-
-class eth_type(oxm):
-    type_len = 2147486210
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = eth_type()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147486210)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("eth_type {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147486210] = eth_type
-
-class eth_type_masked(oxm):
-    type_len = 2147486468
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        packed.append(struct.pack("!H", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = eth_type_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147486468)
-        obj.value = reader.read("!H")[0]
-        obj.value_mask = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("eth_type_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147486468] = eth_type_masked
-
-class icmpv4_code(oxm):
-    type_len = 2147493889
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = icmpv4_code()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147493889)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("icmpv4_code {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147493889] = icmpv4_code
-
-class icmpv4_code_masked(oxm):
-    type_len = 2147494146
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        packed.append(struct.pack("!B", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = icmpv4_code_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147494146)
-        obj.value = reader.read("!B")[0]
-        obj.value_mask = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("icmpv4_code_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147494146] = icmpv4_code_masked
-
-class icmpv4_type(oxm):
-    type_len = 2147493377
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = icmpv4_type()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147493377)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("icmpv4_type {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147493377] = icmpv4_type
-
-class icmpv4_type_masked(oxm):
-    type_len = 2147493634
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        packed.append(struct.pack("!B", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = icmpv4_type_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147493634)
-        obj.value = reader.read("!B")[0]
-        obj.value_mask = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("icmpv4_type_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147493634] = icmpv4_type_masked
-
-class icmpv6_code(oxm):
-    type_len = 2147499009
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = icmpv6_code()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147499009)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("icmpv6_code {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147499009] = icmpv6_code
-
-class icmpv6_code_masked(oxm):
-    type_len = 2147499266
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        packed.append(struct.pack("!B", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = icmpv6_code_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147499266)
-        obj.value = reader.read("!B")[0]
-        obj.value_mask = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("icmpv6_code_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147499266] = icmpv6_code_masked
-
-class icmpv6_type(oxm):
-    type_len = 2147498497
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = icmpv6_type()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147498497)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("icmpv6_type {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147498497] = icmpv6_type
-
-class icmpv6_type_masked(oxm):
-    type_len = 2147498754
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        packed.append(struct.pack("!B", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = icmpv6_type_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147498754)
-        obj.value = reader.read("!B")[0]
-        obj.value_mask = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("icmpv6_type_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147498754] = icmpv6_type_masked
-
-class in_phy_port(oxm):
-    type_len = 2147484164
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(util.pack_port_no(self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = in_phy_port()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147484164)
-        obj.value = util.unpack_port_no(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("in_phy_port {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_port(self.value))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147484164] = in_phy_port
-
-class in_phy_port_masked(oxm):
-    type_len = 2147484424
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(util.pack_port_no(self.value))
-        packed.append(util.pack_port_no(self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = in_phy_port_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147484424)
-        obj.value = util.unpack_port_no(reader)
-        obj.value_mask = util.unpack_port_no(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("in_phy_port_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_port(self.value))
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text(util.pretty_port(self.value_mask))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147484424] = in_phy_port_masked
-
-class in_port(oxm):
-    type_len = 2147483652
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(util.pack_port_no(self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = in_port()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147483652)
-        obj.value = util.unpack_port_no(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("in_port {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_port(self.value))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147483652] = in_port
-
-class in_port_masked(oxm):
-    type_len = 2147483912
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(util.pack_port_no(self.value))
-        packed.append(util.pack_port_no(self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = in_port_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147483912)
-        obj.value = util.unpack_port_no(reader)
-        obj.value_mask = util.unpack_port_no(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("in_port_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_port(self.value))
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text(util.pretty_port(self.value_mask))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147483912] = in_port_masked
-
-class ip_dscp(oxm):
-    type_len = 2147487745
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ip_dscp()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147487745)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ip_dscp {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147487745] = ip_dscp
-
-class ip_dscp_masked(oxm):
-    type_len = 2147488002
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        packed.append(struct.pack("!B", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ip_dscp_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147488002)
-        obj.value = reader.read("!B")[0]
-        obj.value_mask = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ip_dscp_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147488002] = ip_dscp_masked
-
-class ip_ecn(oxm):
-    type_len = 2147488257
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ip_ecn()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147488257)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ip_ecn {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147488257] = ip_ecn
-
-class ip_ecn_masked(oxm):
-    type_len = 2147488514
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        packed.append(struct.pack("!B", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ip_ecn_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147488514)
-        obj.value = reader.read("!B")[0]
-        obj.value_mask = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ip_ecn_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147488514] = ip_ecn_masked
-
-class ip_proto(oxm):
-    type_len = 2147488769
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ip_proto()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147488769)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ip_proto {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147488769] = ip_proto
-
-class ip_proto_masked(oxm):
-    type_len = 2147489026
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        packed.append(struct.pack("!B", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ip_proto_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147489026)
-        obj.value = reader.read("!B")[0]
-        obj.value_mask = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ip_proto_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147489026] = ip_proto_masked
-
-class ipv4_dst(oxm):
-    type_len = 2147489796
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv4_dst()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147489796)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv4_dst {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_ipv4(self.value))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147489796] = ipv4_dst
-
-class ipv4_dst_masked(oxm):
-    type_len = 2147490056
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv4_dst_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147490056)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv4_dst_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_ipv4(self.value))
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text(util.pretty_ipv4(self.value_mask))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147490056] = ipv4_dst_masked
-
-class ipv4_src(oxm):
-    type_len = 2147489284
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv4_src()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147489284)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv4_src {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_ipv4(self.value))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147489284] = ipv4_src
-
-class ipv4_src_masked(oxm):
-    type_len = 2147489544
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv4_src_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147489544)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv4_src_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_ipv4(self.value))
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text(util.pretty_ipv4(self.value_mask))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147489544] = ipv4_src_masked
-
-class ipv6_dst(oxm):
-    type_len = 2147497488
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!16s", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv6_dst()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147497488)
-        obj.value = reader.read('!16s')[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv6_dst {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.pp(self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147497488] = ipv6_dst
-
-class ipv6_dst_masked(oxm):
-    type_len = 2147497760
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!16s", self.value))
-        packed.append(struct.pack("!16s", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv6_dst_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147497760)
-        obj.value = reader.read('!16s')[0]
-        obj.value_mask = reader.read('!16s')[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv6_dst_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.pp(self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.pp(self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147497760] = ipv6_dst_masked
-
-class ipv6_flabel(oxm):
-    type_len = 2147497988
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv6_flabel()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147497988)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv6_flabel {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147497988] = ipv6_flabel
-
-class ipv6_flabel_masked(oxm):
-    type_len = 2147498248
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv6_flabel_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147498248)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv6_flabel_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147498248] = ipv6_flabel_masked
-
-class ipv6_nd_sll(oxm):
-    type_len = 2147500038
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!6B", *self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv6_nd_sll()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147500038)
-        obj.value = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv6_nd_sll {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147500038] = ipv6_nd_sll
-
-class ipv6_nd_sll_masked(oxm):
-    type_len = 2147500300
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!6B", *self.value))
-        packed.append(struct.pack("!6B", *self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv6_nd_sll_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147500300)
-        obj.value = list(reader.read('!6B'))
-        obj.value_mask = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv6_nd_sll_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text(util.pretty_mac(self.value_mask))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147500300] = ipv6_nd_sll_masked
-
-class ipv6_nd_target(oxm):
-    type_len = 2147499536
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!16s", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv6_nd_target()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147499536)
-        obj.value = reader.read('!16s')[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv6_nd_target {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.pp(self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147499536] = ipv6_nd_target
-
-class ipv6_nd_target_masked(oxm):
-    type_len = 2147499808
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!16s", self.value))
-        packed.append(struct.pack("!16s", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv6_nd_target_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147499808)
-        obj.value = reader.read('!16s')[0]
-        obj.value_mask = reader.read('!16s')[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv6_nd_target_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.pp(self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.pp(self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147499808] = ipv6_nd_target_masked
-
-class ipv6_nd_tll(oxm):
-    type_len = 2147500550
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!6B", *self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv6_nd_tll()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147500550)
-        obj.value = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv6_nd_tll {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147500550] = ipv6_nd_tll
-
-class ipv6_nd_tll_masked(oxm):
-    type_len = 2147500812
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!6B", *self.value))
-        packed.append(struct.pack("!6B", *self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv6_nd_tll_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147500812)
-        obj.value = list(reader.read('!6B'))
-        obj.value_mask = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv6_nd_tll_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text(util.pretty_mac(self.value_mask))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147500812] = ipv6_nd_tll_masked
-
-class ipv6_src(oxm):
-    type_len = 2147496976
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!16s", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv6_src()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147496976)
-        obj.value = reader.read('!16s')[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv6_src {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.pp(self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147496976] = ipv6_src
-
-class ipv6_src_masked(oxm):
-    type_len = 2147497248
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!16s", self.value))
-        packed.append(struct.pack("!16s", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv6_src_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147497248)
-        obj.value = reader.read('!16s')[0]
-        obj.value_mask = reader.read('!16s')[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv6_src_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.pp(self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.pp(self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147497248] = ipv6_src_masked
-
-class metadata(oxm):
-    type_len = 2147484680
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!Q", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = metadata()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147484680)
-        obj.value = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("metadata {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147484680] = metadata
-
-class metadata_masked(oxm):
-    type_len = 2147484944
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!Q", self.value))
-        packed.append(struct.pack("!Q", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = metadata_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147484944)
-        obj.value = reader.read("!Q")[0]
-        obj.value_mask = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("metadata_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147484944] = metadata_masked
-
-class mpls_label(oxm):
-    type_len = 2147501060
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = mpls_label()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147501060)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("mpls_label {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147501060] = mpls_label
-
-class mpls_label_masked(oxm):
-    type_len = 2147501320
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = mpls_label_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147501320)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("mpls_label_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147501320] = mpls_label_masked
-
-class mpls_tc(oxm):
-    type_len = 2147501569
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = mpls_tc()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147501569)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("mpls_tc {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147501569] = mpls_tc
-
-class mpls_tc_masked(oxm):
-    type_len = 2147501826
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        packed.append(struct.pack("!B", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = mpls_tc_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147501826)
-        obj.value = reader.read("!B")[0]
-        obj.value_mask = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("mpls_tc_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147501826] = mpls_tc_masked
-
-class sctp_dst(oxm):
-    type_len = 2147492866
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = sctp_dst()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147492866)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("sctp_dst {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147492866] = sctp_dst
-
-class sctp_dst_masked(oxm):
-    type_len = 2147493124
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        packed.append(struct.pack("!H", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = sctp_dst_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147493124)
-        obj.value = reader.read("!H")[0]
-        obj.value_mask = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("sctp_dst_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147493124] = sctp_dst_masked
-
-class sctp_src(oxm):
-    type_len = 2147492354
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = sctp_src()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147492354)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("sctp_src {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147492354] = sctp_src
-
-class sctp_src_masked(oxm):
-    type_len = 2147492612
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        packed.append(struct.pack("!H", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = sctp_src_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147492612)
-        obj.value = reader.read("!H")[0]
-        obj.value_mask = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("sctp_src_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147492612] = sctp_src_masked
-
-class tcp_dst(oxm):
-    type_len = 2147490818
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = tcp_dst()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147490818)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("tcp_dst {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147490818] = tcp_dst
-
-class tcp_dst_masked(oxm):
-    type_len = 2147491076
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        packed.append(struct.pack("!H", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = tcp_dst_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147491076)
-        obj.value = reader.read("!H")[0]
-        obj.value_mask = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("tcp_dst_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147491076] = tcp_dst_masked
-
-class tcp_src(oxm):
-    type_len = 2147490306
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = tcp_src()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147490306)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("tcp_src {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147490306] = tcp_src
-
-class tcp_src_masked(oxm):
-    type_len = 2147490564
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        packed.append(struct.pack("!H", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = tcp_src_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147490564)
-        obj.value = reader.read("!H")[0]
-        obj.value_mask = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("tcp_src_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147490564] = tcp_src_masked
-
-class tunnel_ipv4_dst(oxm):
-    type_len = 81924
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = tunnel_ipv4_dst()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 81924)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("tunnel_ipv4_dst {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_ipv4(self.value))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[81924] = tunnel_ipv4_dst
-
-class tunnel_ipv4_dst_masked(oxm):
-    type_len = 82184
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = tunnel_ipv4_dst_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 82184)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("tunnel_ipv4_dst_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_ipv4(self.value))
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text(util.pretty_ipv4(self.value_mask))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[82184] = tunnel_ipv4_dst_masked
-
-class tunnel_ipv4_src(oxm):
-    type_len = 81412
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = tunnel_ipv4_src()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 81412)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("tunnel_ipv4_src {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_ipv4(self.value))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[81412] = tunnel_ipv4_src
-
-class tunnel_ipv4_src_masked(oxm):
-    type_len = 81672
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = tunnel_ipv4_src_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 81672)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("tunnel_ipv4_src_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_ipv4(self.value))
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text(util.pretty_ipv4(self.value_mask))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[81672] = tunnel_ipv4_src_masked
-
-class udp_dst(oxm):
-    type_len = 2147491842
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = udp_dst()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147491842)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("udp_dst {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147491842] = udp_dst
-
-class udp_dst_masked(oxm):
-    type_len = 2147492100
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        packed.append(struct.pack("!H", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = udp_dst_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147492100)
-        obj.value = reader.read("!H")[0]
-        obj.value_mask = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("udp_dst_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147492100] = udp_dst_masked
-
-class udp_src(oxm):
-    type_len = 2147491330
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = udp_src()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147491330)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("udp_src {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147491330] = udp_src
-
-class udp_src_masked(oxm):
-    type_len = 2147491588
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        packed.append(struct.pack("!H", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = udp_src_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147491588)
-        obj.value = reader.read("!H")[0]
-        obj.value_mask = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("udp_src_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147491588] = udp_src_masked
-
-class vlan_pcp(oxm):
-    type_len = 2147487233
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = vlan_pcp()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147487233)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("vlan_pcp {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147487233] = vlan_pcp
-
-class vlan_pcp_masked(oxm):
-    type_len = 2147487490
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        packed.append(struct.pack("!B", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = vlan_pcp_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147487490)
-        obj.value = reader.read("!B")[0]
-        obj.value_mask = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("vlan_pcp_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147487490] = vlan_pcp_masked
-
-class vlan_vid(oxm):
-    type_len = 2147486722
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = vlan_vid()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147486722)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("vlan_vid {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147486722] = vlan_vid
-
-class vlan_vid_masked(oxm):
-    type_len = 2147486980
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        packed.append(struct.pack("!H", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = vlan_vid_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147486980)
-        obj.value = reader.read("!H")[0]
-        obj.value_mask = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("vlan_vid_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147486980] = vlan_vid_masked
-
-
diff --git a/python/ofagent/loxi/of12/util.py b/python/ofagent/loxi/of12/util.py
deleted file mode 100644
index 90913a2..0000000
--- a/python/ofagent/loxi/of12/util.py
+++ /dev/null
@@ -1,133 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-# Automatically generated by LOXI from template util.py
-# Do not modify
-
-import struct
-import loxi
-import const
-import common
-import action
-import instruction
-import oxm
-
-def pretty_mac(mac):
-    return ':'.join(["%02x" % x for x in mac])
-
-def pretty_ipv4(v):
-    return "%d.%d.%d.%d" % ((v >> 24) & 0xFF, (v >> 16) & 0xFF, (v >> 8) & 0xFF, v & 0xFF)
-
-def pretty_flags(v, flag_names):
-    set_flags = []
-    for flag_name in flag_names:
-        flag_value = getattr(const, flag_name)
-        if v & flag_value == flag_value:
-            set_flags.append(flag_name)
-        elif v & flag_value:
-            set_flags.append('%s&%#x' % (flag_name, v & flag_value))
-        v &= ~flag_value
-    if v:
-        set_flags.append("%#x" % v)
-    return '|'.join(set_flags) or '0'
-
-
-def pretty_port(v):
-    named_ports = [(k,v2) for (k,v2) in const.__dict__.iteritems() if k.startswith('OFPP_')]
-    for (k, v2) in named_ports:
-        if v == v2:
-            return k
-    return v
-
-def pack_port_no(value):
-    return struct.pack("!L", value)
-
-def unpack_port_no(reader):
-    return reader.read("!L")[0]
-
-def pack_fm_cmd(value):
-    return struct.pack("!B", value)
-
-def unpack_fm_cmd(reader):
-    return reader.read("!B")[0]
-
-def init_wc_bmap():
-    return 0
-
-def pack_wc_bmap(value):
-    return struct.pack("!Q", value)
-
-def unpack_wc_bmap(reader):
-    return reader.read("!Q")[0]
-
-def init_match_bmap():
-    return 0
-
-def pack_match_bmap(value):
-    return struct.pack("!Q", value)
-
-def unpack_match_bmap(reader):
-    return reader.read("!Q")[0]
-
-MASK64 = (1 << 64) - 1
-
-def pack_bitmap_128(value):
-    x = 0l
-    for y in value:
-        x |= 1 << y
-    return struct.pack("!QQ", (x >> 64) & MASK64, x & MASK64)
-
-def unpack_bitmap_128(reader):
-    hi, lo = reader.read("!QQ")
-    x = (hi << 64) | lo
-    i = 0
-    value = set()
-    while x != 0:
-        if x & 1 == 1:
-            value.add(i)
-        i += 1
-        x >>= 1
-    return value
-
-def pack_bitmap_512(value):
-    words = [0] * 8
-    for v in value:
-        assert v < 512
-        words[7-v/64] |= 1 << (v % 64)
-    return struct.pack("!8Q", *words)
-
-def unpack_bitmap_512(reader):
-    words = reader.read("!8Q")
-    x = 0l
-    for word in words:
-        x <<= 64
-        x |= word
-    i = 0
-    value = set()
-    while x != 0:
-        if x & 1 == 1:
-            value.add(i)
-        i += 1
-        x >>= 1
-    return value
-
-def pack_checksum_128(value):
-    return struct.pack("!QQ", (value >> 64) & MASK64, value & MASK64)
-
-def unpack_checksum_128(reader):
-    hi, lo = reader.read("!QQ")
-    return (hi << 64) | lo
diff --git a/python/ofagent/loxi/of13/__init__.py b/python/ofagent/loxi/of13/__init__.py
deleted file mode 100644
index ff0f0b6..0000000
--- a/python/ofagent/loxi/of13/__init__.py
+++ /dev/null
@@ -1,34 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template init.py
-# Do not modify
-
-import const
-import bsn_tlv
-import meter_band
-import instruction
-import oxm
-import common
-import instruction_id
-import action
-import message
-import action_id
-from const import *
-from common import *
-from loxi import ProtocolError
diff --git a/python/ofagent/loxi/of13/action.py b/python/ofagent/loxi/of13/action.py
deleted file mode 100644
index f8727a1..0000000
--- a/python/ofagent/loxi/of13/action.py
+++ /dev/null
@@ -1,1298 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template module.py
-# Do not modify
-
-import struct
-import loxi
-import util
-import loxi.generic_util
-
-import sys
-ofp = sys.modules['loxi.of13']
-
-class action(loxi.OFObject):
-    subtypes = {}
-
-
-    def __init__(self, type=None):
-        if type != None:
-            self.type = type
-        else:
-            self.type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 0)
-        subclass = action.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = action()
-        obj.type = reader.read("!H")[0]
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type != other.type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("action {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-
-class experimenter(action):
-    subtypes = {}
-
-    type = 65535
-
-    def __init__(self, experimenter=None, data=None):
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed.append(loxi.generic_util.pad_to(8, length))
-        length += len(packed[-1])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 4)
-        subclass = experimenter.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = experimenter()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.experimenter = reader.read("!L")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.experimenter != other.experimenter: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("experimenter {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[65535] = experimenter
-
-class bsn(experimenter):
-    subtypes = {}
-
-    type = 65535
-    experimenter = 6035143
-
-    def __init__(self, subtype=None):
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 8)
-        subclass = bsn.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = bsn()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        obj.subtype = reader.read("!L")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.subtype != other.subtype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-experimenter.subtypes[6035143] = bsn
-
-class bsn_checksum(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 4
-
-    def __init__(self, checksum=None):
-        if checksum != None:
-            self.checksum = checksum
-        else:
-            self.checksum = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(util.pack_checksum_128(self.checksum))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_checksum()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 4)
-        obj.checksum = util.unpack_checksum_128(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.checksum != other.checksum: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_checksum {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("checksum = ");
-                q.pp(self.checksum)
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[4] = bsn_checksum
-
-class bsn_gentable(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 5
-
-    def __init__(self, table_id=None, key=None):
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if key != None:
-            self.key = key
-        else:
-            self.key = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.table_id))
-        packed.append(loxi.generic_util.pack_list(self.key))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_gentable()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 5)
-        obj.table_id = reader.read("!L")[0]
-        obj.key = loxi.generic_util.unpack_list(reader, ofp.bsn_tlv.bsn_tlv.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.table_id != other.table_id: return False
-        if self.key != other.key: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_gentable {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("key = ");
-                q.pp(self.key)
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[5] = bsn_gentable
-
-class bsn_mirror(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 1
-
-    def __init__(self, dest_port=None, vlan_tag=None, copy_stage=None):
-        if dest_port != None:
-            self.dest_port = dest_port
-        else:
-            self.dest_port = 0
-        if vlan_tag != None:
-            self.vlan_tag = vlan_tag
-        else:
-            self.vlan_tag = 0
-        if copy_stage != None:
-            self.copy_stage = copy_stage
-        else:
-            self.copy_stage = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.dest_port))
-        packed.append(struct.pack("!L", self.vlan_tag))
-        packed.append(struct.pack("!B", self.copy_stage))
-        packed.append('\x00' * 3)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_mirror()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 1)
-        obj.dest_port = reader.read("!L")[0]
-        obj.vlan_tag = reader.read("!L")[0]
-        obj.copy_stage = reader.read("!B")[0]
-        reader.skip(3)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.dest_port != other.dest_port: return False
-        if self.vlan_tag != other.vlan_tag: return False
-        if self.copy_stage != other.copy_stage: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_mirror {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("dest_port = ");
-                q.text("%#x" % self.dest_port)
-                q.text(","); q.breakable()
-                q.text("vlan_tag = ");
-                q.text("%#x" % self.vlan_tag)
-                q.text(","); q.breakable()
-                q.text("copy_stage = ");
-                q.text("%#x" % self.copy_stage)
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[1] = bsn_mirror
-
-class bsn_set_tunnel_dst(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 2
-
-    def __init__(self, dst=None):
-        if dst != None:
-            self.dst = dst
-        else:
-            self.dst = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.dst))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_set_tunnel_dst()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 2)
-        obj.dst = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.dst != other.dst: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_set_tunnel_dst {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("dst = ");
-                q.text("%#x" % self.dst)
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[2] = bsn_set_tunnel_dst
-
-class copy_ttl_in(action):
-    type = 12
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = copy_ttl_in()
-        _type = reader.read("!H")[0]
-        assert(_type == 12)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("copy_ttl_in {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action.subtypes[12] = copy_ttl_in
-
-class copy_ttl_out(action):
-    type = 11
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = copy_ttl_out()
-        _type = reader.read("!H")[0]
-        assert(_type == 11)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("copy_ttl_out {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action.subtypes[11] = copy_ttl_out
-
-class dec_mpls_ttl(action):
-    type = 16
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = dec_mpls_ttl()
-        _type = reader.read("!H")[0]
-        assert(_type == 16)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("dec_mpls_ttl {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action.subtypes[16] = dec_mpls_ttl
-
-class dec_nw_ttl(action):
-    type = 24
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = dec_nw_ttl()
-        _type = reader.read("!H")[0]
-        assert(_type == 24)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("dec_nw_ttl {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action.subtypes[24] = dec_nw_ttl
-
-class group(action):
-    type = 22
-
-    def __init__(self, group_id=None):
-        if group_id != None:
-            self.group_id = group_id
-        else:
-            self.group_id = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.group_id))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group()
-        _type = reader.read("!H")[0]
-        assert(_type == 22)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.group_id = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.group_id != other.group_id: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("group_id = ");
-                q.text("%#x" % self.group_id)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[22] = group
-
-class nicira(experimenter):
-    subtypes = {}
-
-    type = 65535
-    experimenter = 8992
-
-    def __init__(self, subtype=None):
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!H", self.subtype))
-        packed.append('\x00' * 2)
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 8)
-        subclass = nicira.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = nicira()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 8992)
-        obj.subtype = reader.read("!H")[0]
-        reader.skip(2)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.subtype != other.subtype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("nicira {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-experimenter.subtypes[8992] = nicira
-
-class nicira_dec_ttl(nicira):
-    type = 65535
-    experimenter = 8992
-    subtype = 18
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!H", self.subtype))
-        packed.append('\x00' * 2)
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = nicira_dec_ttl()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 8992)
-        _subtype = reader.read("!H")[0]
-        assert(_subtype == 18)
-        reader.skip(2)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("nicira_dec_ttl {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-nicira.subtypes[18] = nicira_dec_ttl
-
-class output(action):
-    type = 0
-
-    def __init__(self, port=None, max_len=None):
-        if port != None:
-            self.port = port
-        else:
-            self.port = 0
-        if max_len != None:
-            self.max_len = max_len
-        else:
-            self.max_len = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(util.pack_port_no(self.port))
-        packed.append(struct.pack("!H", self.max_len))
-        packed.append('\x00' * 6)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = output()
-        _type = reader.read("!H")[0]
-        assert(_type == 0)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.port = util.unpack_port_no(reader)
-        obj.max_len = reader.read("!H")[0]
-        reader.skip(6)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.port != other.port: return False
-        if self.max_len != other.max_len: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("output {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("port = ");
-                q.text(util.pretty_port(self.port))
-                q.text(","); q.breakable()
-                q.text("max_len = ");
-                q.text("%#x" % self.max_len)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[0] = output
-
-class pop_mpls(action):
-    type = 20
-
-    def __init__(self, ethertype=None):
-        if ethertype != None:
-            self.ethertype = ethertype
-        else:
-            self.ethertype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!H", self.ethertype))
-        packed.append('\x00' * 2)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = pop_mpls()
-        _type = reader.read("!H")[0]
-        assert(_type == 20)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.ethertype = reader.read("!H")[0]
-        reader.skip(2)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.ethertype != other.ethertype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("pop_mpls {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("ethertype = ");
-                q.text("%#x" % self.ethertype)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[20] = pop_mpls
-
-class pop_pbb(action):
-    type = 27
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = pop_pbb()
-        _type = reader.read("!H")[0]
-        assert(_type == 27)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("pop_pbb {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action.subtypes[27] = pop_pbb
-
-class pop_vlan(action):
-    type = 18
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = pop_vlan()
-        _type = reader.read("!H")[0]
-        assert(_type == 18)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("pop_vlan {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action.subtypes[18] = pop_vlan
-
-class push_mpls(action):
-    type = 19
-
-    def __init__(self, ethertype=None):
-        if ethertype != None:
-            self.ethertype = ethertype
-        else:
-            self.ethertype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!H", self.ethertype))
-        packed.append('\x00' * 2)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = push_mpls()
-        _type = reader.read("!H")[0]
-        assert(_type == 19)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.ethertype = reader.read("!H")[0]
-        reader.skip(2)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.ethertype != other.ethertype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("push_mpls {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("ethertype = ");
-                q.text("%#x" % self.ethertype)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[19] = push_mpls
-
-class push_pbb(action):
-    type = 26
-
-    def __init__(self, ethertype=None):
-        if ethertype != None:
-            self.ethertype = ethertype
-        else:
-            self.ethertype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!H", self.ethertype))
-        packed.append('\x00' * 2)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = push_pbb()
-        _type = reader.read("!H")[0]
-        assert(_type == 26)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.ethertype = reader.read("!H")[0]
-        reader.skip(2)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.ethertype != other.ethertype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("push_pbb {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("ethertype = ");
-                q.text("%#x" % self.ethertype)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[26] = push_pbb
-
-class push_vlan(action):
-    type = 17
-
-    def __init__(self, ethertype=None):
-        if ethertype != None:
-            self.ethertype = ethertype
-        else:
-            self.ethertype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!H", self.ethertype))
-        packed.append('\x00' * 2)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = push_vlan()
-        _type = reader.read("!H")[0]
-        assert(_type == 17)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.ethertype = reader.read("!H")[0]
-        reader.skip(2)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.ethertype != other.ethertype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("push_vlan {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("ethertype = ");
-                q.text("%#x" % self.ethertype)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[17] = push_vlan
-
-class set_field(action):
-    type = 25
-
-    def __init__(self, field=None):
-        if field != None:
-            self.field = field
-        else:
-            self.field = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(self.field.pack())
-        length = sum([len(x) for x in packed])
-        packed.append(loxi.generic_util.pad_to(8, length))
-        length += len(packed[-1])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_field()
-        _type = reader.read("!H")[0]
-        assert(_type == 25)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.field = ofp.oxm.oxm.unpack(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.field != other.field: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_field {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("field = ");
-                q.pp(self.field)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[25] = set_field
-
-class set_mpls_ttl(action):
-    type = 15
-
-    def __init__(self, mpls_ttl=None):
-        if mpls_ttl != None:
-            self.mpls_ttl = mpls_ttl
-        else:
-            self.mpls_ttl = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!B", self.mpls_ttl))
-        packed.append('\x00' * 3)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_mpls_ttl()
-        _type = reader.read("!H")[0]
-        assert(_type == 15)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.mpls_ttl = reader.read("!B")[0]
-        reader.skip(3)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.mpls_ttl != other.mpls_ttl: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_mpls_ttl {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("mpls_ttl = ");
-                q.text("%#x" % self.mpls_ttl)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[15] = set_mpls_ttl
-
-class set_nw_ttl(action):
-    type = 23
-
-    def __init__(self, nw_ttl=None):
-        if nw_ttl != None:
-            self.nw_ttl = nw_ttl
-        else:
-            self.nw_ttl = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!B", self.nw_ttl))
-        packed.append('\x00' * 3)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_nw_ttl()
-        _type = reader.read("!H")[0]
-        assert(_type == 23)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.nw_ttl = reader.read("!B")[0]
-        reader.skip(3)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.nw_ttl != other.nw_ttl: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_nw_ttl {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("nw_ttl = ");
-                q.text("%#x" % self.nw_ttl)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[23] = set_nw_ttl
-
-class set_queue(action):
-    type = 21
-
-    def __init__(self, queue_id=None):
-        if queue_id != None:
-            self.queue_id = queue_id
-        else:
-            self.queue_id = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.queue_id))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_queue()
-        _type = reader.read("!H")[0]
-        assert(_type == 21)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.queue_id = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.queue_id != other.queue_id: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_queue {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("queue_id = ");
-                q.text("%#x" % self.queue_id)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[21] = set_queue
-
-
diff --git a/python/ofagent/loxi/of13/action_id.py b/python/ofagent/loxi/of13/action_id.py
deleted file mode 100644
index 0162205..0000000
--- a/python/ofagent/loxi/of13/action_id.py
+++ /dev/null
@@ -1,1079 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template module.py
-# Do not modify
-
-import struct
-import loxi
-import util
-import loxi.generic_util
-
-import sys
-ofp = sys.modules['loxi.of13']
-
-class action_id(loxi.OFObject):
-    subtypes = {}
-
-
-    def __init__(self, type=None):
-        if type != None:
-            self.type = type
-        else:
-            self.type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 0)
-        subclass = action_id.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = action_id()
-        obj.type = reader.read("!H")[0]
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type != other.type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("action_id {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-
-class experimenter(action_id):
-    subtypes = {}
-
-    type = 65535
-
-    def __init__(self, experimenter=None):
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 4)
-        subclass = experimenter.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = experimenter()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.experimenter = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.experimenter != other.experimenter: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("experimenter {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action_id.subtypes[65535] = experimenter
-
-class bsn(experimenter):
-    subtypes = {}
-
-    type = 65535
-    experimenter = 6035143
-
-    def __init__(self, subtype=None):
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 8)
-        subclass = bsn.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = bsn()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        obj.subtype = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.subtype != other.subtype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-experimenter.subtypes[6035143] = bsn
-
-class bsn_checksum(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 4
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_checksum()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_checksum {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[4] = bsn_checksum
-
-class bsn_gentable(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 5
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_gentable()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 5)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_gentable {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[5] = bsn_gentable
-
-class bsn_mirror(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 1
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_mirror()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 1)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_mirror {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[1] = bsn_mirror
-
-class bsn_set_tunnel_dst(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 2
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_set_tunnel_dst()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 2)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_set_tunnel_dst {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[2] = bsn_set_tunnel_dst
-
-class copy_ttl_in(action_id):
-    type = 12
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = copy_ttl_in()
-        _type = reader.read("!H")[0]
-        assert(_type == 12)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("copy_ttl_in {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action_id.subtypes[12] = copy_ttl_in
-
-class copy_ttl_out(action_id):
-    type = 11
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = copy_ttl_out()
-        _type = reader.read("!H")[0]
-        assert(_type == 11)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("copy_ttl_out {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action_id.subtypes[11] = copy_ttl_out
-
-class dec_mpls_ttl(action_id):
-    type = 16
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = dec_mpls_ttl()
-        _type = reader.read("!H")[0]
-        assert(_type == 16)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("dec_mpls_ttl {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action_id.subtypes[16] = dec_mpls_ttl
-
-class dec_nw_ttl(action_id):
-    type = 24
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = dec_nw_ttl()
-        _type = reader.read("!H")[0]
-        assert(_type == 24)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("dec_nw_ttl {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action_id.subtypes[24] = dec_nw_ttl
-
-class group(action_id):
-    type = 22
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group()
-        _type = reader.read("!H")[0]
-        assert(_type == 22)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action_id.subtypes[22] = group
-
-class nicira(experimenter):
-    subtypes = {}
-
-    type = 65535
-    experimenter = 8992
-
-    def __init__(self, subtype=None):
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!H", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 8)
-        subclass = nicira.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = nicira()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 8992)
-        obj.subtype = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.subtype != other.subtype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("nicira {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-experimenter.subtypes[8992] = nicira
-
-class nicira_dec_ttl(nicira):
-    type = 65535
-    experimenter = 8992
-    subtype = 18
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!H", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = nicira_dec_ttl()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 8992)
-        _subtype = reader.read("!H")[0]
-        assert(_subtype == 18)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("nicira_dec_ttl {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-nicira.subtypes[18] = nicira_dec_ttl
-
-class output(action_id):
-    type = 0
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = output()
-        _type = reader.read("!H")[0]
-        assert(_type == 0)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("output {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action_id.subtypes[0] = output
-
-class pop_mpls(action_id):
-    type = 20
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = pop_mpls()
-        _type = reader.read("!H")[0]
-        assert(_type == 20)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("pop_mpls {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action_id.subtypes[20] = pop_mpls
-
-class pop_pbb(action_id):
-    type = 27
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = pop_pbb()
-        _type = reader.read("!H")[0]
-        assert(_type == 27)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("pop_pbb {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action_id.subtypes[27] = pop_pbb
-
-class pop_vlan(action_id):
-    type = 18
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = pop_vlan()
-        _type = reader.read("!H")[0]
-        assert(_type == 18)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("pop_vlan {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action_id.subtypes[18] = pop_vlan
-
-class push_mpls(action_id):
-    type = 19
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = push_mpls()
-        _type = reader.read("!H")[0]
-        assert(_type == 19)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("push_mpls {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action_id.subtypes[19] = push_mpls
-
-class push_pbb(action_id):
-    type = 26
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = push_pbb()
-        _type = reader.read("!H")[0]
-        assert(_type == 26)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("push_pbb {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action_id.subtypes[26] = push_pbb
-
-class push_vlan(action_id):
-    type = 17
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = push_vlan()
-        _type = reader.read("!H")[0]
-        assert(_type == 17)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("push_vlan {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action_id.subtypes[17] = push_vlan
-
-class set_field(action_id):
-    type = 25
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_field()
-        _type = reader.read("!H")[0]
-        assert(_type == 25)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_field {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action_id.subtypes[25] = set_field
-
-class set_mpls_ttl(action_id):
-    type = 15
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_mpls_ttl()
-        _type = reader.read("!H")[0]
-        assert(_type == 15)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_mpls_ttl {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action_id.subtypes[15] = set_mpls_ttl
-
-class set_nw_ttl(action_id):
-    type = 23
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_nw_ttl()
-        _type = reader.read("!H")[0]
-        assert(_type == 23)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_nw_ttl {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action_id.subtypes[23] = set_nw_ttl
-
-class set_queue(action_id):
-    type = 21
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_queue()
-        _type = reader.read("!H")[0]
-        assert(_type == 21)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_queue {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action_id.subtypes[21] = set_queue
-
-
diff --git a/python/ofagent/loxi/of13/bsn_tlv.py b/python/ofagent/loxi/of13/bsn_tlv.py
deleted file mode 100644
index 964ca7c..0000000
--- a/python/ofagent/loxi/of13/bsn_tlv.py
+++ /dev/null
@@ -1,4801 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template module.py
-# Do not modify
-
-import struct
-import loxi
-import util
-import loxi.generic_util
-
-import sys
-ofp = sys.modules['loxi.of13']
-
-class bsn_tlv(loxi.OFObject):
-    subtypes = {}
-
-
-    def __init__(self, type=None):
-        if type != None:
-            self.type = type
-        else:
-            self.type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 0)
-        subclass = bsn_tlv.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = bsn_tlv()
-        obj.type = reader.read("!H")[0]
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type != other.type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_tlv {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-
-class actor_key(bsn_tlv):
-    type = 44
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = actor_key()
-        _type = reader.read("!H")[0]
-        assert(_type == 44)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("actor_key {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[44] = actor_key
-
-class actor_port_num(bsn_tlv):
-    type = 43
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = actor_port_num()
-        _type = reader.read("!H")[0]
-        assert(_type == 43)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("actor_port_num {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[43] = actor_port_num
-
-class actor_port_priority(bsn_tlv):
-    type = 42
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = actor_port_priority()
-        _type = reader.read("!H")[0]
-        assert(_type == 42)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("actor_port_priority {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[42] = actor_port_priority
-
-class actor_state(bsn_tlv):
-    type = 53
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!B", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = actor_state()
-        _type = reader.read("!H")[0]
-        assert(_type == 53)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("actor_state {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[53] = actor_state
-
-class actor_system_mac(bsn_tlv):
-    type = 41
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!6B", *self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = actor_system_mac()
-        _type = reader.read("!H")[0]
-        assert(_type == 41)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("actor_system_mac {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[41] = actor_system_mac
-
-class actor_system_priority(bsn_tlv):
-    type = 40
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = actor_system_priority()
-        _type = reader.read("!H")[0]
-        assert(_type == 40)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("actor_system_priority {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[40] = actor_system_priority
-
-class anchor(bsn_tlv):
-    type = 81
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = anchor()
-        _type = reader.read("!H")[0]
-        assert(_type == 81)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("anchor {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[81] = anchor
-
-class broadcast_query_timeout(bsn_tlv):
-    type = 10
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = broadcast_query_timeout()
-        _type = reader.read("!H")[0]
-        assert(_type == 10)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("broadcast_query_timeout {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[10] = broadcast_query_timeout
-
-class broadcast_rate(bsn_tlv):
-    type = 90
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = broadcast_rate()
-        _type = reader.read("!H")[0]
-        assert(_type == 90)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("broadcast_rate {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[90] = broadcast_rate
-
-class bucket(bsn_tlv):
-    type = 64
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(loxi.generic_util.pack_list(self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bucket()
-        _type = reader.read("!H")[0]
-        assert(_type == 64)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = loxi.generic_util.unpack_list(reader, ofp.bsn_tlv.bsn_tlv.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bucket {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.pp(self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[64] = bucket
-
-class circuit_id(bsn_tlv):
-    type = 14
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(self.value)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = circuit_id()
-        _type = reader.read("!H")[0]
-        assert(_type == 14)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("circuit_id {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.pp(self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[14] = circuit_id
-
-class convergence_status(bsn_tlv):
-    type = 45
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!B", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = convergence_status()
-        _type = reader.read("!H")[0]
-        assert(_type == 45)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("convergence_status {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[45] = convergence_status
-
-class crc_enabled(bsn_tlv):
-    type = 22
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!B", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = crc_enabled()
-        _type = reader.read("!H")[0]
-        assert(_type == 22)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("crc_enabled {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[22] = crc_enabled
-
-class data(bsn_tlv):
-    type = 55
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(self.value)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = data()
-        _type = reader.read("!H")[0]
-        assert(_type == 55)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("data {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.pp(self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[55] = data
-
-class decap(bsn_tlv):
-    type = 85
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = decap()
-        _type = reader.read("!H")[0]
-        assert(_type == 85)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("decap {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[85] = decap
-
-class eth_dst(bsn_tlv):
-    type = 33
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!6B", *self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = eth_dst()
-        _type = reader.read("!H")[0]
-        assert(_type == 33)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("eth_dst {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[33] = eth_dst
-
-class eth_src(bsn_tlv):
-    type = 32
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!6B", *self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = eth_src()
-        _type = reader.read("!H")[0]
-        assert(_type == 32)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("eth_src {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[32] = eth_src
-
-class external_gateway_ip(bsn_tlv):
-    type = 26
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = external_gateway_ip()
-        _type = reader.read("!H")[0]
-        assert(_type == 26)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("external_gateway_ip {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_ipv4(self.value))
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[26] = external_gateway_ip
-
-class external_gateway_mac(bsn_tlv):
-    type = 29
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!6B", *self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = external_gateway_mac()
-        _type = reader.read("!H")[0]
-        assert(_type == 29)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("external_gateway_mac {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[29] = external_gateway_mac
-
-class external_ip(bsn_tlv):
-    type = 23
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = external_ip()
-        _type = reader.read("!H")[0]
-        assert(_type == 23)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("external_ip {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_ipv4(self.value))
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[23] = external_ip
-
-class external_mac(bsn_tlv):
-    type = 24
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!6B", *self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = external_mac()
-        _type = reader.read("!H")[0]
-        assert(_type == 24)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("external_mac {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[24] = external_mac
-
-class external_netmask(bsn_tlv):
-    type = 25
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = external_netmask()
-        _type = reader.read("!H")[0]
-        assert(_type == 25)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("external_netmask {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_ipv4(self.value))
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[25] = external_netmask
-
-class generation_id(bsn_tlv):
-    type = 80
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!Q", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = generation_id()
-        _type = reader.read("!H")[0]
-        assert(_type == 80)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("generation_id {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[80] = generation_id
-
-class hash_packet_field(bsn_tlv):
-    type = 103
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!Q", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = hash_packet_field()
-        _type = reader.read("!H")[0]
-        assert(_type == 103)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("hash_packet_field {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[103] = hash_packet_field
-
-class hash_packet_type(bsn_tlv):
-    type = 102
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!B", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = hash_packet_type()
-        _type = reader.read("!H")[0]
-        assert(_type == 102)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("hash_packet_type {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[102] = hash_packet_type
-
-class hash_seed(bsn_tlv):
-    type = 100
-
-    def __init__(self, seed1=None, seed2=None):
-        if seed1 != None:
-            self.seed1 = seed1
-        else:
-            self.seed1 = 0
-        if seed2 != None:
-            self.seed2 = seed2
-        else:
-            self.seed2 = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.seed1))
-        packed.append(struct.pack("!L", self.seed2))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = hash_seed()
-        _type = reader.read("!H")[0]
-        assert(_type == 100)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.seed1 = reader.read("!L")[0]
-        obj.seed2 = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.seed1 != other.seed1: return False
-        if self.seed2 != other.seed2: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("hash_seed {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("seed1 = ");
-                q.text("%#x" % self.seed1)
-                q.text(","); q.breakable()
-                q.text("seed2 = ");
-                q.text("%#x" % self.seed2)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[100] = hash_seed
-
-class hash_type(bsn_tlv):
-    type = 101
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!B", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = hash_type()
-        _type = reader.read("!H")[0]
-        assert(_type == 101)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("hash_type {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[101] = hash_type
-
-class header_size(bsn_tlv):
-    type = 31
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = header_size()
-        _type = reader.read("!H")[0]
-        assert(_type == 31)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("header_size {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[31] = header_size
-
-class icmp_code(bsn_tlv):
-    type = 69
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!B", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = icmp_code()
-        _type = reader.read("!H")[0]
-        assert(_type == 69)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("icmp_code {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[69] = icmp_code
-
-class icmp_id(bsn_tlv):
-    type = 70
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = icmp_id()
-        _type = reader.read("!H")[0]
-        assert(_type == 70)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("icmp_id {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[70] = icmp_id
-
-class icmp_type(bsn_tlv):
-    type = 68
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!B", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = icmp_type()
-        _type = reader.read("!H")[0]
-        assert(_type == 68)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("icmp_type {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[68] = icmp_type
-
-class idle_notification(bsn_tlv):
-    type = 7
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = idle_notification()
-        _type = reader.read("!H")[0]
-        assert(_type == 7)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("idle_notification {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[7] = idle_notification
-
-class idle_time(bsn_tlv):
-    type = 5
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!Q", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = idle_time()
-        _type = reader.read("!H")[0]
-        assert(_type == 5)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("idle_time {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[5] = idle_time
-
-class idle_timeout(bsn_tlv):
-    type = 8
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = idle_timeout()
-        _type = reader.read("!H")[0]
-        assert(_type == 8)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("idle_timeout {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[8] = idle_timeout
-
-class igmp_snooping(bsn_tlv):
-    type = 78
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = igmp_snooping()
-        _type = reader.read("!H")[0]
-        assert(_type == 78)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("igmp_snooping {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[78] = igmp_snooping
-
-class internal_gateway_mac(bsn_tlv):
-    type = 28
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!6B", *self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = internal_gateway_mac()
-        _type = reader.read("!H")[0]
-        assert(_type == 28)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("internal_gateway_mac {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[28] = internal_gateway_mac
-
-class internal_mac(bsn_tlv):
-    type = 27
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!6B", *self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = internal_mac()
-        _type = reader.read("!H")[0]
-        assert(_type == 27)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("internal_mac {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[27] = internal_mac
-
-class interval(bsn_tlv):
-    type = 58
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = interval()
-        _type = reader.read("!H")[0]
-        assert(_type == 58)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("interval {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[58] = interval
-
-class ip_proto(bsn_tlv):
-    type = 67
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!B", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ip_proto()
-        _type = reader.read("!H")[0]
-        assert(_type == 67)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ip_proto {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[67] = ip_proto
-
-class ipv4(bsn_tlv):
-    type = 4
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv4()
-        _type = reader.read("!H")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv4 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_ipv4(self.value))
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[4] = ipv4
-
-class ipv4_dst(bsn_tlv):
-    type = 35
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv4_dst()
-        _type = reader.read("!H")[0]
-        assert(_type == 35)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv4_dst {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_ipv4(self.value))
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[35] = ipv4_dst
-
-class ipv4_netmask(bsn_tlv):
-    type = 60
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv4_netmask()
-        _type = reader.read("!H")[0]
-        assert(_type == 60)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv4_netmask {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_ipv4(self.value))
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[60] = ipv4_netmask
-
-class ipv4_src(bsn_tlv):
-    type = 34
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv4_src()
-        _type = reader.read("!H")[0]
-        assert(_type == 34)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv4_src {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_ipv4(self.value))
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[34] = ipv4_src
-
-class ipv6(bsn_tlv):
-    type = 84
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!16s", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv6()
-        _type = reader.read("!H")[0]
-        assert(_type == 84)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read('!16s')[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv6 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.pp(self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[84] = ipv6
-
-class known_multicast_rate(bsn_tlv):
-    type = 91
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = known_multicast_rate()
-        _type = reader.read("!H")[0]
-        assert(_type == 91)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("known_multicast_rate {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[91] = known_multicast_rate
-
-class l2_multicast_lookup(bsn_tlv):
-    type = 79
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = l2_multicast_lookup()
-        _type = reader.read("!H")[0]
-        assert(_type == 79)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("l2_multicast_lookup {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[79] = l2_multicast_lookup
-
-class mac(bsn_tlv):
-    type = 1
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!6B", *self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = mac()
-        _type = reader.read("!H")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("mac {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[1] = mac
-
-class mac_mask(bsn_tlv):
-    type = 56
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!6B", *self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = mac_mask()
-        _type = reader.read("!H")[0]
-        assert(_type == 56)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("mac_mask {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[56] = mac_mask
-
-class mcg_type_vxlan(bsn_tlv):
-    type = 87
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = mcg_type_vxlan()
-        _type = reader.read("!H")[0]
-        assert(_type == 87)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("mcg_type_vxlan {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[87] = mcg_type_vxlan
-
-class miss_packets(bsn_tlv):
-    type = 13
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!Q", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = miss_packets()
-        _type = reader.read("!H")[0]
-        assert(_type == 13)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("miss_packets {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[13] = miss_packets
-
-class mpls_control_word(bsn_tlv):
-    type = 62
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!B", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = mpls_control_word()
-        _type = reader.read("!H")[0]
-        assert(_type == 62)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("mpls_control_word {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[62] = mpls_control_word
-
-class mpls_label(bsn_tlv):
-    type = 61
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = mpls_label()
-        _type = reader.read("!H")[0]
-        assert(_type == 61)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("mpls_label {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[61] = mpls_label
-
-class mpls_sequenced(bsn_tlv):
-    type = 63
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!B", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = mpls_sequenced()
-        _type = reader.read("!H")[0]
-        assert(_type == 63)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("mpls_sequenced {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[63] = mpls_sequenced
-
-class multicast_interface_id(bsn_tlv):
-    type = 95
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = multicast_interface_id()
-        _type = reader.read("!H")[0]
-        assert(_type == 95)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("multicast_interface_id {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[95] = multicast_interface_id
-
-class name(bsn_tlv):
-    type = 52
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(self.value)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = name()
-        _type = reader.read("!H")[0]
-        assert(_type == 52)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("name {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.pp(self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[52] = name
-
-class negate(bsn_tlv):
-    type = 83
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = negate()
-        _type = reader.read("!H")[0]
-        assert(_type == 83)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("negate {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[83] = negate
-
-class nexthop_type_vxlan(bsn_tlv):
-    type = 94
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = nexthop_type_vxlan()
-        _type = reader.read("!H")[0]
-        assert(_type == 94)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("nexthop_type_vxlan {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[94] = nexthop_type_vxlan
-
-class offset(bsn_tlv):
-    type = 82
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = offset()
-        _type = reader.read("!H")[0]
-        assert(_type == 82)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("offset {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[82] = offset
-
-class partner_key(bsn_tlv):
-    type = 51
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = partner_key()
-        _type = reader.read("!H")[0]
-        assert(_type == 51)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("partner_key {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[51] = partner_key
-
-class partner_port_num(bsn_tlv):
-    type = 50
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = partner_port_num()
-        _type = reader.read("!H")[0]
-        assert(_type == 50)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("partner_port_num {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[50] = partner_port_num
-
-class partner_port_priority(bsn_tlv):
-    type = 49
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = partner_port_priority()
-        _type = reader.read("!H")[0]
-        assert(_type == 49)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("partner_port_priority {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[49] = partner_port_priority
-
-class partner_state(bsn_tlv):
-    type = 54
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!B", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = partner_state()
-        _type = reader.read("!H")[0]
-        assert(_type == 54)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("partner_state {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[54] = partner_state
-
-class partner_system_mac(bsn_tlv):
-    type = 48
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!6B", *self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = partner_system_mac()
-        _type = reader.read("!H")[0]
-        assert(_type == 48)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("partner_system_mac {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[48] = partner_system_mac
-
-class partner_system_priority(bsn_tlv):
-    type = 47
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = partner_system_priority()
-        _type = reader.read("!H")[0]
-        assert(_type == 47)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("partner_system_priority {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[47] = partner_system_priority
-
-class port(bsn_tlv):
-    type = 0
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(util.pack_port_no(self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = port()
-        _type = reader.read("!H")[0]
-        assert(_type == 0)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = util.unpack_port_no(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_port(self.value))
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[0] = port
-
-class port_vxlan_mode(bsn_tlv):
-    type = 88
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!B", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = port_vxlan_mode()
-        _type = reader.read("!H")[0]
-        assert(_type == 88)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port_vxlan_mode {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[88] = port_vxlan_mode
-
-class priority(bsn_tlv):
-    type = 57
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = priority()
-        _type = reader.read("!H")[0]
-        assert(_type == 57)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("priority {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[57] = priority
-
-class queue_id(bsn_tlv):
-    type = 20
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = queue_id()
-        _type = reader.read("!H")[0]
-        assert(_type == 20)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_id {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[20] = queue_id
-
-class queue_weight(bsn_tlv):
-    type = 21
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = queue_weight()
-        _type = reader.read("!H")[0]
-        assert(_type == 21)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_weight {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[21] = queue_weight
-
-class rate_unit(bsn_tlv):
-    type = 89
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!B", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = rate_unit()
-        _type = reader.read("!H")[0]
-        assert(_type == 89)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("rate_unit {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[89] = rate_unit
-
-class reference(bsn_tlv):
-    type = 59
-
-    def __init__(self, table_id=None, key=None):
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if key != None:
-            self.key = key
-        else:
-            self.key = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.table_id))
-        packed.append(loxi.generic_util.pack_list(self.key))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = reference()
-        _type = reader.read("!H")[0]
-        assert(_type == 59)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.table_id = reader.read("!H")[0]
-        obj.key = loxi.generic_util.unpack_list(reader, ofp.bsn_tlv.bsn_tlv.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.table_id != other.table_id: return False
-        if self.key != other.key: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("reference {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("key = ");
-                q.pp(self.key)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[59] = reference
-
-class reply_packets(bsn_tlv):
-    type = 12
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!Q", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = reply_packets()
-        _type = reader.read("!H")[0]
-        assert(_type == 12)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("reply_packets {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[12] = reply_packets
-
-class request_packets(bsn_tlv):
-    type = 11
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!Q", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = request_packets()
-        _type = reader.read("!H")[0]
-        assert(_type == 11)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("request_packets {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[11] = request_packets
-
-class rx_bytes(bsn_tlv):
-    type = 71
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!Q", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = rx_bytes()
-        _type = reader.read("!H")[0]
-        assert(_type == 71)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("rx_bytes {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[71] = rx_bytes
-
-class rx_packets(bsn_tlv):
-    type = 2
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!Q", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = rx_packets()
-        _type = reader.read("!H")[0]
-        assert(_type == 2)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("rx_packets {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[2] = rx_packets
-
-class sampling_rate(bsn_tlv):
-    type = 30
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = sampling_rate()
-        _type = reader.read("!H")[0]
-        assert(_type == 30)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("sampling_rate {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[30] = sampling_rate
-
-class set_loopback_mode(bsn_tlv):
-    type = 74
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_loopback_mode()
-        _type = reader.read("!H")[0]
-        assert(_type == 74)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_loopback_mode {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[74] = set_loopback_mode
-
-class status(bsn_tlv):
-    type = 97
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!B", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = status()
-        _type = reader.read("!H")[0]
-        assert(_type == 97)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("status {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[97] = status
-
-class strip_mpls_l2_on_ingress(bsn_tlv):
-    type = 75
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = strip_mpls_l2_on_ingress()
-        _type = reader.read("!H")[0]
-        assert(_type == 75)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("strip_mpls_l2_on_ingress {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[75] = strip_mpls_l2_on_ingress
-
-class strip_mpls_l3_on_ingress(bsn_tlv):
-    type = 76
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = strip_mpls_l3_on_ingress()
-        _type = reader.read("!H")[0]
-        assert(_type == 76)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("strip_mpls_l3_on_ingress {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[76] = strip_mpls_l3_on_ingress
-
-class strip_vlan_on_egress(bsn_tlv):
-    type = 73
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = strip_vlan_on_egress()
-        _type = reader.read("!H")[0]
-        assert(_type == 73)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("strip_vlan_on_egress {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[73] = strip_vlan_on_egress
-
-class sub_agent_id(bsn_tlv):
-    type = 38
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = sub_agent_id()
-        _type = reader.read("!H")[0]
-        assert(_type == 38)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("sub_agent_id {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[38] = sub_agent_id
-
-class tcp_dst(bsn_tlv):
-    type = 66
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = tcp_dst()
-        _type = reader.read("!H")[0]
-        assert(_type == 66)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("tcp_dst {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[66] = tcp_dst
-
-class tcp_src(bsn_tlv):
-    type = 65
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = tcp_src()
-        _type = reader.read("!H")[0]
-        assert(_type == 65)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("tcp_src {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[65] = tcp_src
-
-class tx_bytes(bsn_tlv):
-    type = 39
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!Q", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = tx_bytes()
-        _type = reader.read("!H")[0]
-        assert(_type == 39)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("tx_bytes {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[39] = tx_bytes
-
-class tx_packets(bsn_tlv):
-    type = 3
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!Q", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = tx_packets()
-        _type = reader.read("!H")[0]
-        assert(_type == 3)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("tx_packets {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[3] = tx_packets
-
-class udf_anchor(bsn_tlv):
-    type = 16
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = udf_anchor()
-        _type = reader.read("!H")[0]
-        assert(_type == 16)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("udf_anchor {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[16] = udf_anchor
-
-class udf_id(bsn_tlv):
-    type = 15
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = udf_id()
-        _type = reader.read("!H")[0]
-        assert(_type == 15)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("udf_id {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[15] = udf_id
-
-class udf_length(bsn_tlv):
-    type = 18
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = udf_length()
-        _type = reader.read("!H")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("udf_length {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[18] = udf_length
-
-class udf_offset(bsn_tlv):
-    type = 17
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = udf_offset()
-        _type = reader.read("!H")[0]
-        assert(_type == 17)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("udf_offset {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[17] = udf_offset
-
-class udp_dst(bsn_tlv):
-    type = 37
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = udp_dst()
-        _type = reader.read("!H")[0]
-        assert(_type == 37)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("udp_dst {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[37] = udp_dst
-
-class udp_src(bsn_tlv):
-    type = 36
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = udp_src()
-        _type = reader.read("!H")[0]
-        assert(_type == 36)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("udp_src {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[36] = udp_src
-
-class unicast_query_timeout(bsn_tlv):
-    type = 9
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = unicast_query_timeout()
-        _type = reader.read("!H")[0]
-        assert(_type == 9)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("unicast_query_timeout {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[9] = unicast_query_timeout
-
-class unicast_rate(bsn_tlv):
-    type = 93
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = unicast_rate()
-        _type = reader.read("!H")[0]
-        assert(_type == 93)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("unicast_rate {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[93] = unicast_rate
-
-class unknown_multicast_rate(bsn_tlv):
-    type = 92
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = unknown_multicast_rate()
-        _type = reader.read("!H")[0]
-        assert(_type == 92)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("unknown_multicast_rate {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[92] = unknown_multicast_rate
-
-class use_packet_state(bsn_tlv):
-    type = 96
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!B", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = use_packet_state()
-        _type = reader.read("!H")[0]
-        assert(_type == 96)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("use_packet_state {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[96] = use_packet_state
-
-class vfi(bsn_tlv):
-    type = 99
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = vfi()
-        _type = reader.read("!H")[0]
-        assert(_type == 99)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("vfi {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[99] = vfi
-
-class vlan_pcp(bsn_tlv):
-    type = 72
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!B", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = vlan_pcp()
-        _type = reader.read("!H")[0]
-        assert(_type == 72)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("vlan_pcp {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[72] = vlan_pcp
-
-class vlan_vid(bsn_tlv):
-    type = 6
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = vlan_vid()
-        _type = reader.read("!H")[0]
-        assert(_type == 6)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("vlan_vid {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[6] = vlan_vid
-
-class vlan_vid_mask(bsn_tlv):
-    type = 77
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = vlan_vid_mask()
-        _type = reader.read("!H")[0]
-        assert(_type == 77)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("vlan_vid_mask {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[77] = vlan_vid_mask
-
-class vni(bsn_tlv):
-    type = 86
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = vni()
-        _type = reader.read("!H")[0]
-        assert(_type == 86)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("vni {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[86] = vni
-
-class vrf(bsn_tlv):
-    type = 19
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = vrf()
-        _type = reader.read("!H")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("vrf {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[19] = vrf
-
-
diff --git a/python/ofagent/loxi/of13/common.py b/python/ofagent/loxi/of13/common.py
deleted file mode 100644
index 4e95fcb..0000000
--- a/python/ofagent/loxi/of13/common.py
+++ /dev/null
@@ -1,4170 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template module.py
-# Do not modify
-
-import struct
-import loxi
-import util
-import loxi.generic_util
-
-import sys
-ofp = sys.modules['loxi.of13']
-
-class bsn_controller_connection(loxi.OFObject):
-
-    def __init__(self, state=None, auxiliary_id=None, role=None, uri=None):
-        if state != None:
-            self.state = state
-        else:
-            self.state = 0
-        if auxiliary_id != None:
-            self.auxiliary_id = auxiliary_id
-        else:
-            self.auxiliary_id = 0
-        if role != None:
-            self.role = role
-        else:
-            self.role = 0
-        if uri != None:
-            self.uri = uri
-        else:
-            self.uri = ""
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.state))
-        packed.append(struct.pack("!B", self.auxiliary_id))
-        packed.append('\x00' * 2)
-        packed.append(struct.pack("!L", self.role))
-        packed.append(struct.pack("!256s", self.uri))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_controller_connection()
-        obj.state = reader.read("!B")[0]
-        obj.auxiliary_id = reader.read("!B")[0]
-        reader.skip(2)
-        obj.role = reader.read("!L")[0]
-        obj.uri = reader.read("!256s")[0].rstrip("\x00")
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.state != other.state: return False
-        if self.auxiliary_id != other.auxiliary_id: return False
-        if self.role != other.role: return False
-        if self.uri != other.uri: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_controller_connection {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("state = ");
-                q.text("%#x" % self.state)
-                q.text(","); q.breakable()
-                q.text("auxiliary_id = ");
-                q.text("%#x" % self.auxiliary_id)
-                q.text(","); q.breakable()
-                q.text("role = ");
-                q.text("%#x" % self.role)
-                q.text(","); q.breakable()
-                q.text("uri = ");
-                q.pp(self.uri)
-            q.breakable()
-        q.text('}')
-
-
-class bsn_debug_counter_desc_stats_entry(loxi.OFObject):
-
-    def __init__(self, counter_id=None, name=None, description=None):
-        if counter_id != None:
-            self.counter_id = counter_id
-        else:
-            self.counter_id = 0
-        if name != None:
-            self.name = name
-        else:
-            self.name = ""
-        if description != None:
-            self.description = description
-        else:
-            self.description = ""
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!Q", self.counter_id))
-        packed.append(struct.pack("!64s", self.name))
-        packed.append(struct.pack("!256s", self.description))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_debug_counter_desc_stats_entry()
-        obj.counter_id = reader.read("!Q")[0]
-        obj.name = reader.read("!64s")[0].rstrip("\x00")
-        obj.description = reader.read("!256s")[0].rstrip("\x00")
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.counter_id != other.counter_id: return False
-        if self.name != other.name: return False
-        if self.description != other.description: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_debug_counter_desc_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("counter_id = ");
-                q.text("%#x" % self.counter_id)
-                q.text(","); q.breakable()
-                q.text("name = ");
-                q.pp(self.name)
-                q.text(","); q.breakable()
-                q.text("description = ");
-                q.pp(self.description)
-            q.breakable()
-        q.text('}')
-
-
-class bsn_debug_counter_stats_entry(loxi.OFObject):
-
-    def __init__(self, counter_id=None, value=None):
-        if counter_id != None:
-            self.counter_id = counter_id
-        else:
-            self.counter_id = 0
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!Q", self.counter_id))
-        packed.append(struct.pack("!Q", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_debug_counter_stats_entry()
-        obj.counter_id = reader.read("!Q")[0]
-        obj.value = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.counter_id != other.counter_id: return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_debug_counter_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("counter_id = ");
-                q.text("%#x" % self.counter_id)
-                q.text(","); q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-
-class bsn_flow_checksum_bucket_stats_entry(loxi.OFObject):
-
-    def __init__(self, checksum=None):
-        if checksum != None:
-            self.checksum = checksum
-        else:
-            self.checksum = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!Q", self.checksum))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_flow_checksum_bucket_stats_entry()
-        obj.checksum = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.checksum != other.checksum: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_flow_checksum_bucket_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("checksum = ");
-                q.text("%#x" % self.checksum)
-            q.breakable()
-        q.text('}')
-
-
-class bsn_generic_stats_entry(loxi.OFObject):
-
-    def __init__(self, tlvs=None):
-        if tlvs != None:
-            self.tlvs = tlvs
-        else:
-            self.tlvs = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 0
-        packed.append(loxi.generic_util.pack_list(self.tlvs))
-        length = sum([len(x) for x in packed])
-        packed[0] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_generic_stats_entry()
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 2)
-        obj.tlvs = loxi.generic_util.unpack_list(reader, ofp.bsn_tlv.bsn_tlv.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.tlvs != other.tlvs: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_generic_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("tlvs = ");
-                q.pp(self.tlvs)
-            q.breakable()
-        q.text('}')
-
-
-class bsn_gentable_bucket_stats_entry(loxi.OFObject):
-
-    def __init__(self, checksum=None):
-        if checksum != None:
-            self.checksum = checksum
-        else:
-            self.checksum = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(util.pack_checksum_128(self.checksum))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_gentable_bucket_stats_entry()
-        obj.checksum = util.unpack_checksum_128(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.checksum != other.checksum: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_gentable_bucket_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("checksum = ");
-                q.pp(self.checksum)
-            q.breakable()
-        q.text('}')
-
-
-class bsn_gentable_desc_stats_entry(loxi.OFObject):
-
-    def __init__(self, table_id=None, name=None, buckets_size=None, max_entries=None):
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if name != None:
-            self.name = name
-        else:
-            self.name = ""
-        if buckets_size != None:
-            self.buckets_size = buckets_size
-        else:
-            self.buckets_size = 0
-        if max_entries != None:
-            self.max_entries = max_entries
-        else:
-            self.max_entries = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 0
-        packed.append(struct.pack("!H", self.table_id))
-        packed.append(struct.pack("!32s", self.name))
-        packed.append(struct.pack("!L", self.buckets_size))
-        packed.append(struct.pack("!L", self.max_entries))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[0] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_gentable_desc_stats_entry()
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 2)
-        obj.table_id = reader.read("!H")[0]
-        obj.name = reader.read("!32s")[0].rstrip("\x00")
-        obj.buckets_size = reader.read("!L")[0]
-        obj.max_entries = reader.read("!L")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.table_id != other.table_id: return False
-        if self.name != other.name: return False
-        if self.buckets_size != other.buckets_size: return False
-        if self.max_entries != other.max_entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_gentable_desc_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("name = ");
-                q.pp(self.name)
-                q.text(","); q.breakable()
-                q.text("buckets_size = ");
-                q.text("%#x" % self.buckets_size)
-                q.text(","); q.breakable()
-                q.text("max_entries = ");
-                q.text("%#x" % self.max_entries)
-            q.breakable()
-        q.text('}')
-
-
-class bsn_gentable_entry_desc_stats_entry(loxi.OFObject):
-
-    def __init__(self, checksum=None, key=None, value=None):
-        if checksum != None:
-            self.checksum = checksum
-        else:
-            self.checksum = 0
-        if key != None:
-            self.key = key
-        else:
-            self.key = []
-        if value != None:
-            self.value = value
-        else:
-            self.value = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 0
-        packed.append(struct.pack("!H", 0)) # placeholder for key_length at index 1
-        packed.append(util.pack_checksum_128(self.checksum))
-        packed.append(loxi.generic_util.pack_list(self.key))
-        packed[1] = struct.pack("!H", len(packed[-1]))
-        packed.append(loxi.generic_util.pack_list(self.value))
-        length = sum([len(x) for x in packed])
-        packed[0] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_gentable_entry_desc_stats_entry()
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 2)
-        _key_length = reader.read("!H")[0]
-        obj.checksum = util.unpack_checksum_128(reader)
-        obj.key = loxi.generic_util.unpack_list(reader.slice(_key_length), ofp.bsn_tlv.bsn_tlv.unpack)
-        obj.value = loxi.generic_util.unpack_list(reader, ofp.bsn_tlv.bsn_tlv.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.checksum != other.checksum: return False
-        if self.key != other.key: return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_gentable_entry_desc_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("checksum = ");
-                q.pp(self.checksum)
-                q.text(","); q.breakable()
-                q.text("key = ");
-                q.pp(self.key)
-                q.text(","); q.breakable()
-                q.text("value = ");
-                q.pp(self.value)
-            q.breakable()
-        q.text('}')
-
-
-class bsn_gentable_entry_stats_entry(loxi.OFObject):
-
-    def __init__(self, key=None, stats=None):
-        if key != None:
-            self.key = key
-        else:
-            self.key = []
-        if stats != None:
-            self.stats = stats
-        else:
-            self.stats = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 0
-        packed.append(struct.pack("!H", 0)) # placeholder for key_length at index 1
-        packed.append(loxi.generic_util.pack_list(self.key))
-        packed[1] = struct.pack("!H", len(packed[-1]))
-        packed.append(loxi.generic_util.pack_list(self.stats))
-        length = sum([len(x) for x in packed])
-        packed[0] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_gentable_entry_stats_entry()
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 2)
-        _key_length = reader.read("!H")[0]
-        obj.key = loxi.generic_util.unpack_list(reader.slice(_key_length), ofp.bsn_tlv.bsn_tlv.unpack)
-        obj.stats = loxi.generic_util.unpack_list(reader, ofp.bsn_tlv.bsn_tlv.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.key != other.key: return False
-        if self.stats != other.stats: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_gentable_entry_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("key = ");
-                q.pp(self.key)
-                q.text(","); q.breakable()
-                q.text("stats = ");
-                q.pp(self.stats)
-            q.breakable()
-        q.text('}')
-
-
-class bsn_gentable_stats_entry(loxi.OFObject):
-
-    def __init__(self, table_id=None, entry_count=None, checksum=None):
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if entry_count != None:
-            self.entry_count = entry_count
-        else:
-            self.entry_count = 0
-        if checksum != None:
-            self.checksum = checksum
-        else:
-            self.checksum = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.table_id))
-        packed.append('\x00' * 2)
-        packed.append(struct.pack("!L", self.entry_count))
-        packed.append(util.pack_checksum_128(self.checksum))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_gentable_stats_entry()
-        obj.table_id = reader.read("!H")[0]
-        reader.skip(2)
-        obj.entry_count = reader.read("!L")[0]
-        obj.checksum = util.unpack_checksum_128(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.table_id != other.table_id: return False
-        if self.entry_count != other.entry_count: return False
-        if self.checksum != other.checksum: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_gentable_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("entry_count = ");
-                q.text("%#x" % self.entry_count)
-                q.text(","); q.breakable()
-                q.text("checksum = ");
-                q.pp(self.checksum)
-            q.breakable()
-        q.text('}')
-
-
-class bsn_interface(loxi.OFObject):
-
-    def __init__(self, hw_addr=None, name=None, ipv4_addr=None, ipv4_netmask=None):
-        if hw_addr != None:
-            self.hw_addr = hw_addr
-        else:
-            self.hw_addr = [0,0,0,0,0,0]
-        if name != None:
-            self.name = name
-        else:
-            self.name = ""
-        if ipv4_addr != None:
-            self.ipv4_addr = ipv4_addr
-        else:
-            self.ipv4_addr = 0
-        if ipv4_netmask != None:
-            self.ipv4_netmask = ipv4_netmask
-        else:
-            self.ipv4_netmask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!6B", *self.hw_addr))
-        packed.append('\x00' * 2)
-        packed.append(struct.pack("!16s", self.name))
-        packed.append(struct.pack("!L", self.ipv4_addr))
-        packed.append(struct.pack("!L", self.ipv4_netmask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_interface()
-        obj.hw_addr = list(reader.read('!6B'))
-        reader.skip(2)
-        obj.name = reader.read("!16s")[0].rstrip("\x00")
-        obj.ipv4_addr = reader.read("!L")[0]
-        obj.ipv4_netmask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.hw_addr != other.hw_addr: return False
-        if self.name != other.name: return False
-        if self.ipv4_addr != other.ipv4_addr: return False
-        if self.ipv4_netmask != other.ipv4_netmask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_interface {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("hw_addr = ");
-                q.text(util.pretty_mac(self.hw_addr))
-                q.text(","); q.breakable()
-                q.text("name = ");
-                q.pp(self.name)
-                q.text(","); q.breakable()
-                q.text("ipv4_addr = ");
-                q.text(util.pretty_ipv4(self.ipv4_addr))
-                q.text(","); q.breakable()
-                q.text("ipv4_netmask = ");
-                q.text(util.pretty_ipv4(self.ipv4_netmask))
-            q.breakable()
-        q.text('}')
-
-
-class bsn_lacp_stats_entry(loxi.OFObject):
-
-    def __init__(self, port_no=None, actor_sys_priority=None, actor_sys_mac=None, actor_port_priority=None, actor_port_num=None, actor_key=None, convergence_status=None, partner_sys_priority=None, partner_sys_mac=None, partner_port_priority=None, partner_port_num=None, partner_key=None):
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if actor_sys_priority != None:
-            self.actor_sys_priority = actor_sys_priority
-        else:
-            self.actor_sys_priority = 0
-        if actor_sys_mac != None:
-            self.actor_sys_mac = actor_sys_mac
-        else:
-            self.actor_sys_mac = [0,0,0,0,0,0]
-        if actor_port_priority != None:
-            self.actor_port_priority = actor_port_priority
-        else:
-            self.actor_port_priority = 0
-        if actor_port_num != None:
-            self.actor_port_num = actor_port_num
-        else:
-            self.actor_port_num = 0
-        if actor_key != None:
-            self.actor_key = actor_key
-        else:
-            self.actor_key = 0
-        if convergence_status != None:
-            self.convergence_status = convergence_status
-        else:
-            self.convergence_status = 0
-        if partner_sys_priority != None:
-            self.partner_sys_priority = partner_sys_priority
-        else:
-            self.partner_sys_priority = 0
-        if partner_sys_mac != None:
-            self.partner_sys_mac = partner_sys_mac
-        else:
-            self.partner_sys_mac = [0,0,0,0,0,0]
-        if partner_port_priority != None:
-            self.partner_port_priority = partner_port_priority
-        else:
-            self.partner_port_priority = 0
-        if partner_port_num != None:
-            self.partner_port_num = partner_port_num
-        else:
-            self.partner_port_num = 0
-        if partner_key != None:
-            self.partner_key = partner_key
-        else:
-            self.partner_key = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(struct.pack("!H", self.actor_sys_priority))
-        packed.append(struct.pack("!6B", *self.actor_sys_mac))
-        packed.append(struct.pack("!H", self.actor_port_priority))
-        packed.append(struct.pack("!H", self.actor_port_num))
-        packed.append(struct.pack("!H", self.actor_key))
-        packed.append(struct.pack("!B", self.convergence_status))
-        packed.append('\x00' * 1)
-        packed.append(struct.pack("!H", self.partner_sys_priority))
-        packed.append(struct.pack("!6B", *self.partner_sys_mac))
-        packed.append(struct.pack("!H", self.partner_port_priority))
-        packed.append(struct.pack("!H", self.partner_port_num))
-        packed.append(struct.pack("!H", self.partner_key))
-        packed.append('\x00' * 2)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_lacp_stats_entry()
-        obj.port_no = util.unpack_port_no(reader)
-        obj.actor_sys_priority = reader.read("!H")[0]
-        obj.actor_sys_mac = list(reader.read('!6B'))
-        obj.actor_port_priority = reader.read("!H")[0]
-        obj.actor_port_num = reader.read("!H")[0]
-        obj.actor_key = reader.read("!H")[0]
-        obj.convergence_status = reader.read("!B")[0]
-        reader.skip(1)
-        obj.partner_sys_priority = reader.read("!H")[0]
-        obj.partner_sys_mac = list(reader.read('!6B'))
-        obj.partner_port_priority = reader.read("!H")[0]
-        obj.partner_port_num = reader.read("!H")[0]
-        obj.partner_key = reader.read("!H")[0]
-        reader.skip(2)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.port_no != other.port_no: return False
-        if self.actor_sys_priority != other.actor_sys_priority: return False
-        if self.actor_sys_mac != other.actor_sys_mac: return False
-        if self.actor_port_priority != other.actor_port_priority: return False
-        if self.actor_port_num != other.actor_port_num: return False
-        if self.actor_key != other.actor_key: return False
-        if self.convergence_status != other.convergence_status: return False
-        if self.partner_sys_priority != other.partner_sys_priority: return False
-        if self.partner_sys_mac != other.partner_sys_mac: return False
-        if self.partner_port_priority != other.partner_port_priority: return False
-        if self.partner_port_num != other.partner_port_num: return False
-        if self.partner_key != other.partner_key: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_lacp_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("actor_sys_priority = ");
-                q.text("%#x" % self.actor_sys_priority)
-                q.text(","); q.breakable()
-                q.text("actor_sys_mac = ");
-                q.text(util.pretty_mac(self.actor_sys_mac))
-                q.text(","); q.breakable()
-                q.text("actor_port_priority = ");
-                q.text("%#x" % self.actor_port_priority)
-                q.text(","); q.breakable()
-                q.text("actor_port_num = ");
-                q.text("%#x" % self.actor_port_num)
-                q.text(","); q.breakable()
-                q.text("actor_key = ");
-                q.text("%#x" % self.actor_key)
-                q.text(","); q.breakable()
-                q.text("convergence_status = ");
-                q.text("%#x" % self.convergence_status)
-                q.text(","); q.breakable()
-                q.text("partner_sys_priority = ");
-                q.text("%#x" % self.partner_sys_priority)
-                q.text(","); q.breakable()
-                q.text("partner_sys_mac = ");
-                q.text(util.pretty_mac(self.partner_sys_mac))
-                q.text(","); q.breakable()
-                q.text("partner_port_priority = ");
-                q.text("%#x" % self.partner_port_priority)
-                q.text(","); q.breakable()
-                q.text("partner_port_num = ");
-                q.text("%#x" % self.partner_port_num)
-                q.text(","); q.breakable()
-                q.text("partner_key = ");
-                q.text("%#x" % self.partner_key)
-            q.breakable()
-        q.text('}')
-
-
-class bsn_port_counter_stats_entry(loxi.OFObject):
-
-    def __init__(self, port_no=None, values=None):
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if values != None:
-            self.values = values
-        else:
-            self.values = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 0
-        packed.append('\x00' * 2)
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(loxi.generic_util.pack_list(self.values))
-        length = sum([len(x) for x in packed])
-        packed[0] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_port_counter_stats_entry()
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 2)
-        reader.skip(2)
-        obj.port_no = util.unpack_port_no(reader)
-        obj.values = loxi.generic_util.unpack_list(reader, ofp.common.uint64.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.port_no != other.port_no: return False
-        if self.values != other.values: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_port_counter_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("values = ");
-                q.pp(self.values)
-            q.breakable()
-        q.text('}')
-
-
-class bsn_switch_pipeline_stats_entry(loxi.OFObject):
-
-    def __init__(self, pipeline=None):
-        if pipeline != None:
-            self.pipeline = pipeline
-        else:
-            self.pipeline = ""
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!256s", self.pipeline))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_switch_pipeline_stats_entry()
-        obj.pipeline = reader.read("!256s")[0].rstrip("\x00")
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.pipeline != other.pipeline: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_switch_pipeline_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("pipeline = ");
-                q.pp(self.pipeline)
-            q.breakable()
-        q.text('}')
-
-
-class bsn_table_checksum_stats_entry(loxi.OFObject):
-
-    def __init__(self, table_id=None, checksum=None):
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if checksum != None:
-            self.checksum = checksum
-        else:
-            self.checksum = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append(struct.pack("!Q", self.checksum))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_table_checksum_stats_entry()
-        obj.table_id = reader.read("!B")[0]
-        obj.checksum = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.table_id != other.table_id: return False
-        if self.checksum != other.checksum: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_table_checksum_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("checksum = ");
-                q.text("%#x" % self.checksum)
-            q.breakable()
-        q.text('}')
-
-
-class bsn_tlv_vlan_mac_list(loxi.OFObject):
-    type = 98
-
-    def __init__(self, key=None):
-        if key != None:
-            self.key = key
-        else:
-            self.key = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(loxi.generic_util.pack_list(self.key))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_tlv_vlan_mac_list()
-        _type = reader.read("!H")[0]
-        assert(_type == 98)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.key = loxi.generic_util.unpack_list(reader, ofp.common.bsn_vlan_mac.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.key != other.key: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_tlv_vlan_mac_list {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("key = ");
-                q.pp(self.key)
-            q.breakable()
-        q.text('}')
-
-
-class bsn_vport(loxi.OFObject):
-    subtypes = {}
-
-
-    def __init__(self, type=None):
-        if type != None:
-            self.type = type
-        else:
-            self.type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 0)
-        subclass = bsn_vport.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = bsn_vport()
-        obj.type = reader.read("!H")[0]
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type != other.type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vport {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-
-class bsn_vlan_counter_stats_entry(loxi.OFObject):
-
-    def __init__(self, vlan_vid=None, values=None):
-        if vlan_vid != None:
-            self.vlan_vid = vlan_vid
-        else:
-            self.vlan_vid = 0
-        if values != None:
-            self.values = values
-        else:
-            self.values = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 0
-        packed.append(struct.pack("!H", self.vlan_vid))
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.values))
-        length = sum([len(x) for x in packed])
-        packed[0] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_vlan_counter_stats_entry()
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 2)
-        obj.vlan_vid = reader.read("!H")[0]
-        reader.skip(4)
-        obj.values = loxi.generic_util.unpack_list(reader, ofp.common.uint64.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.vlan_vid != other.vlan_vid: return False
-        if self.values != other.values: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vlan_counter_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("vlan_vid = ");
-                q.text("%#x" % self.vlan_vid)
-                q.text(","); q.breakable()
-                q.text("values = ");
-                q.pp(self.values)
-            q.breakable()
-        q.text('}')
-
-
-class bsn_vlan_mac(loxi.OFObject):
-
-    def __init__(self, vlan_vid=None, mac=None):
-        if vlan_vid != None:
-            self.vlan_vid = vlan_vid
-        else:
-            self.vlan_vid = 0
-        if mac != None:
-            self.mac = mac
-        else:
-            self.mac = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.vlan_vid))
-        packed.append(struct.pack("!6B", *self.mac))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_vlan_mac()
-        obj.vlan_vid = reader.read("!H")[0]
-        obj.mac = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.vlan_vid != other.vlan_vid: return False
-        if self.mac != other.mac: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vlan_mac {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("vlan_vid = ");
-                q.text("%#x" % self.vlan_vid)
-                q.text(","); q.breakable()
-                q.text("mac = ");
-                q.text(util.pretty_mac(self.mac))
-            q.breakable()
-        q.text('}')
-
-
-class bsn_vport_l2gre(bsn_vport):
-    type = 1
-
-    def __init__(self, flags=None, port_no=None, loopback_port_no=None, local_mac=None, nh_mac=None, src_ip=None, dst_ip=None, dscp=None, ttl=None, vpn=None, rate_limit=None, if_name=None):
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if loopback_port_no != None:
-            self.loopback_port_no = loopback_port_no
-        else:
-            self.loopback_port_no = 0
-        if local_mac != None:
-            self.local_mac = local_mac
-        else:
-            self.local_mac = [0,0,0,0,0,0]
-        if nh_mac != None:
-            self.nh_mac = nh_mac
-        else:
-            self.nh_mac = [0,0,0,0,0,0]
-        if src_ip != None:
-            self.src_ip = src_ip
-        else:
-            self.src_ip = 0
-        if dst_ip != None:
-            self.dst_ip = dst_ip
-        else:
-            self.dst_ip = 0
-        if dscp != None:
-            self.dscp = dscp
-        else:
-            self.dscp = 0
-        if ttl != None:
-            self.ttl = ttl
-        else:
-            self.ttl = 0
-        if vpn != None:
-            self.vpn = vpn
-        else:
-            self.vpn = 0
-        if rate_limit != None:
-            self.rate_limit = rate_limit
-        else:
-            self.rate_limit = 0
-        if if_name != None:
-            self.if_name = if_name
-        else:
-            self.if_name = ""
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.flags))
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(util.pack_port_no(self.loopback_port_no))
-        packed.append(struct.pack("!6B", *self.local_mac))
-        packed.append(struct.pack("!6B", *self.nh_mac))
-        packed.append(struct.pack("!L", self.src_ip))
-        packed.append(struct.pack("!L", self.dst_ip))
-        packed.append(struct.pack("!B", self.dscp))
-        packed.append(struct.pack("!B", self.ttl))
-        packed.append('\x00' * 2)
-        packed.append(struct.pack("!L", self.vpn))
-        packed.append(struct.pack("!L", self.rate_limit))
-        packed.append(struct.pack("!16s", self.if_name))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_vport_l2gre()
-        _type = reader.read("!H")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.flags = reader.read("!L")[0]
-        obj.port_no = util.unpack_port_no(reader)
-        obj.loopback_port_no = util.unpack_port_no(reader)
-        obj.local_mac = list(reader.read('!6B'))
-        obj.nh_mac = list(reader.read('!6B'))
-        obj.src_ip = reader.read("!L")[0]
-        obj.dst_ip = reader.read("!L")[0]
-        obj.dscp = reader.read("!B")[0]
-        obj.ttl = reader.read("!B")[0]
-        reader.skip(2)
-        obj.vpn = reader.read("!L")[0]
-        obj.rate_limit = reader.read("!L")[0]
-        obj.if_name = reader.read("!16s")[0].rstrip("\x00")
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.flags != other.flags: return False
-        if self.port_no != other.port_no: return False
-        if self.loopback_port_no != other.loopback_port_no: return False
-        if self.local_mac != other.local_mac: return False
-        if self.nh_mac != other.nh_mac: return False
-        if self.src_ip != other.src_ip: return False
-        if self.dst_ip != other.dst_ip: return False
-        if self.dscp != other.dscp: return False
-        if self.ttl != other.ttl: return False
-        if self.vpn != other.vpn: return False
-        if self.rate_limit != other.rate_limit: return False
-        if self.if_name != other.if_name: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vport_l2gre {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("loopback_port_no = ");
-                q.text(util.pretty_port(self.loopback_port_no))
-                q.text(","); q.breakable()
-                q.text("local_mac = ");
-                q.text(util.pretty_mac(self.local_mac))
-                q.text(","); q.breakable()
-                q.text("nh_mac = ");
-                q.text(util.pretty_mac(self.nh_mac))
-                q.text(","); q.breakable()
-                q.text("src_ip = ");
-                q.text(util.pretty_ipv4(self.src_ip))
-                q.text(","); q.breakable()
-                q.text("dst_ip = ");
-                q.text(util.pretty_ipv4(self.dst_ip))
-                q.text(","); q.breakable()
-                q.text("dscp = ");
-                q.text("%#x" % self.dscp)
-                q.text(","); q.breakable()
-                q.text("ttl = ");
-                q.text("%#x" % self.ttl)
-                q.text(","); q.breakable()
-                q.text("vpn = ");
-                q.text("%#x" % self.vpn)
-                q.text(","); q.breakable()
-                q.text("rate_limit = ");
-                q.text("%#x" % self.rate_limit)
-                q.text(","); q.breakable()
-                q.text("if_name = ");
-                q.pp(self.if_name)
-            q.breakable()
-        q.text('}')
-
-bsn_vport.subtypes[1] = bsn_vport_l2gre
-
-class bsn_vport_q_in_q(bsn_vport):
-    type = 0
-
-    def __init__(self, port_no=None, ingress_tpid=None, ingress_vlan_id=None, egress_tpid=None, egress_vlan_id=None, if_name=None):
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if ingress_tpid != None:
-            self.ingress_tpid = ingress_tpid
-        else:
-            self.ingress_tpid = 0
-        if ingress_vlan_id != None:
-            self.ingress_vlan_id = ingress_vlan_id
-        else:
-            self.ingress_vlan_id = 0
-        if egress_tpid != None:
-            self.egress_tpid = egress_tpid
-        else:
-            self.egress_tpid = 0
-        if egress_vlan_id != None:
-            self.egress_vlan_id = egress_vlan_id
-        else:
-            self.egress_vlan_id = 0
-        if if_name != None:
-            self.if_name = if_name
-        else:
-            self.if_name = ""
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.port_no))
-        packed.append(struct.pack("!H", self.ingress_tpid))
-        packed.append(struct.pack("!H", self.ingress_vlan_id))
-        packed.append(struct.pack("!H", self.egress_tpid))
-        packed.append(struct.pack("!H", self.egress_vlan_id))
-        packed.append(struct.pack("!16s", self.if_name))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_vport_q_in_q()
-        _type = reader.read("!H")[0]
-        assert(_type == 0)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.port_no = reader.read("!L")[0]
-        obj.ingress_tpid = reader.read("!H")[0]
-        obj.ingress_vlan_id = reader.read("!H")[0]
-        obj.egress_tpid = reader.read("!H")[0]
-        obj.egress_vlan_id = reader.read("!H")[0]
-        obj.if_name = reader.read("!16s")[0].rstrip("\x00")
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.port_no != other.port_no: return False
-        if self.ingress_tpid != other.ingress_tpid: return False
-        if self.ingress_vlan_id != other.ingress_vlan_id: return False
-        if self.egress_tpid != other.egress_tpid: return False
-        if self.egress_vlan_id != other.egress_vlan_id: return False
-        if self.if_name != other.if_name: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vport_q_in_q {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("port_no = ");
-                q.text("%#x" % self.port_no)
-                q.text(","); q.breakable()
-                q.text("ingress_tpid = ");
-                q.text("%#x" % self.ingress_tpid)
-                q.text(","); q.breakable()
-                q.text("ingress_vlan_id = ");
-                q.text("%#x" % self.ingress_vlan_id)
-                q.text(","); q.breakable()
-                q.text("egress_tpid = ");
-                q.text("%#x" % self.egress_tpid)
-                q.text(","); q.breakable()
-                q.text("egress_vlan_id = ");
-                q.text("%#x" % self.egress_vlan_id)
-                q.text(","); q.breakable()
-                q.text("if_name = ");
-                q.pp(self.if_name)
-            q.breakable()
-        q.text('}')
-
-bsn_vport.subtypes[0] = bsn_vport_q_in_q
-
-class bsn_vrf_counter_stats_entry(loxi.OFObject):
-
-    def __init__(self, vrf=None, values=None):
-        if vrf != None:
-            self.vrf = vrf
-        else:
-            self.vrf = 0
-        if values != None:
-            self.values = values
-        else:
-            self.values = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 0
-        packed.append('\x00' * 2)
-        packed.append(struct.pack("!L", self.vrf))
-        packed.append(loxi.generic_util.pack_list(self.values))
-        length = sum([len(x) for x in packed])
-        packed[0] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_vrf_counter_stats_entry()
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 2)
-        reader.skip(2)
-        obj.vrf = reader.read("!L")[0]
-        obj.values = loxi.generic_util.unpack_list(reader, ofp.common.uint64.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.vrf != other.vrf: return False
-        if self.values != other.values: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vrf_counter_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("vrf = ");
-                q.text("%#x" % self.vrf)
-                q.text(","); q.breakable()
-                q.text("values = ");
-                q.pp(self.values)
-            q.breakable()
-        q.text('}')
-
-
-class bucket(loxi.OFObject):
-
-    def __init__(self, weight=None, watch_port=None, watch_group=None, actions=None):
-        if weight != None:
-            self.weight = weight
-        else:
-            self.weight = 0
-        if watch_port != None:
-            self.watch_port = watch_port
-        else:
-            self.watch_port = 0
-        if watch_group != None:
-            self.watch_group = watch_group
-        else:
-            self.watch_group = 0
-        if actions != None:
-            self.actions = actions
-        else:
-            self.actions = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 0
-        packed.append(struct.pack("!H", self.weight))
-        packed.append(util.pack_port_no(self.watch_port))
-        packed.append(struct.pack("!L", self.watch_group))
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.actions))
-        length = sum([len(x) for x in packed])
-        packed[0] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bucket()
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 2)
-        obj.weight = reader.read("!H")[0]
-        obj.watch_port = util.unpack_port_no(reader)
-        obj.watch_group = reader.read("!L")[0]
-        reader.skip(4)
-        obj.actions = loxi.generic_util.unpack_list(reader, ofp.action.action.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.weight != other.weight: return False
-        if self.watch_port != other.watch_port: return False
-        if self.watch_group != other.watch_group: return False
-        if self.actions != other.actions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bucket {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("weight = ");
-                q.text("%#x" % self.weight)
-                q.text(","); q.breakable()
-                q.text("watch_port = ");
-                q.text(util.pretty_port(self.watch_port))
-                q.text(","); q.breakable()
-                q.text("watch_group = ");
-                q.text("%#x" % self.watch_group)
-                q.text(","); q.breakable()
-                q.text("actions = ");
-                q.pp(self.actions)
-            q.breakable()
-        q.text('}')
-
-
-class bucket_counter(loxi.OFObject):
-
-    def __init__(self, packet_count=None, byte_count=None):
-        if packet_count != None:
-            self.packet_count = packet_count
-        else:
-            self.packet_count = 0
-        if byte_count != None:
-            self.byte_count = byte_count
-        else:
-            self.byte_count = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!Q", self.packet_count))
-        packed.append(struct.pack("!Q", self.byte_count))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bucket_counter()
-        obj.packet_count = reader.read("!Q")[0]
-        obj.byte_count = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.packet_count != other.packet_count: return False
-        if self.byte_count != other.byte_count: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bucket_counter {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("packet_count = ");
-                q.text("%#x" % self.packet_count)
-                q.text(","); q.breakable()
-                q.text("byte_count = ");
-                q.text("%#x" % self.byte_count)
-            q.breakable()
-        q.text('}')
-
-
-class flow_stats_entry(loxi.OFObject):
-
-    def __init__(self, table_id=None, duration_sec=None, duration_nsec=None, priority=None, idle_timeout=None, hard_timeout=None, flags=None, cookie=None, packet_count=None, byte_count=None, match=None, instructions=None):
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if duration_sec != None:
-            self.duration_sec = duration_sec
-        else:
-            self.duration_sec = 0
-        if duration_nsec != None:
-            self.duration_nsec = duration_nsec
-        else:
-            self.duration_nsec = 0
-        if priority != None:
-            self.priority = priority
-        else:
-            self.priority = 0
-        if idle_timeout != None:
-            self.idle_timeout = idle_timeout
-        else:
-            self.idle_timeout = 0
-        if hard_timeout != None:
-            self.hard_timeout = hard_timeout
-        else:
-            self.hard_timeout = 0
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if packet_count != None:
-            self.packet_count = packet_count
-        else:
-            self.packet_count = 0
-        if byte_count != None:
-            self.byte_count = byte_count
-        else:
-            self.byte_count = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        if instructions != None:
-            self.instructions = instructions
-        else:
-            self.instructions = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 0
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append('\x00' * 1)
-        packed.append(struct.pack("!L", self.duration_sec))
-        packed.append(struct.pack("!L", self.duration_nsec))
-        packed.append(struct.pack("!H", self.priority))
-        packed.append(struct.pack("!H", self.idle_timeout))
-        packed.append(struct.pack("!H", self.hard_timeout))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(struct.pack("!Q", self.packet_count))
-        packed.append(struct.pack("!Q", self.byte_count))
-        packed.append(self.match.pack())
-        packed.append(loxi.generic_util.pack_list(self.instructions))
-        length = sum([len(x) for x in packed])
-        packed[0] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_stats_entry()
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 2)
-        obj.table_id = reader.read("!B")[0]
-        reader.skip(1)
-        obj.duration_sec = reader.read("!L")[0]
-        obj.duration_nsec = reader.read("!L")[0]
-        obj.priority = reader.read("!H")[0]
-        obj.idle_timeout = reader.read("!H")[0]
-        obj.hard_timeout = reader.read("!H")[0]
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.cookie = reader.read("!Q")[0]
-        obj.packet_count = reader.read("!Q")[0]
-        obj.byte_count = reader.read("!Q")[0]
-        obj.match = ofp.match.unpack(reader)
-        obj.instructions = loxi.generic_util.unpack_list(reader, ofp.instruction.instruction.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.table_id != other.table_id: return False
-        if self.duration_sec != other.duration_sec: return False
-        if self.duration_nsec != other.duration_nsec: return False
-        if self.priority != other.priority: return False
-        if self.idle_timeout != other.idle_timeout: return False
-        if self.hard_timeout != other.hard_timeout: return False
-        if self.flags != other.flags: return False
-        if self.cookie != other.cookie: return False
-        if self.packet_count != other.packet_count: return False
-        if self.byte_count != other.byte_count: return False
-        if self.match != other.match: return False
-        if self.instructions != other.instructions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("duration_sec = ");
-                q.text("%#x" % self.duration_sec)
-                q.text(","); q.breakable()
-                q.text("duration_nsec = ");
-                q.text("%#x" % self.duration_nsec)
-                q.text(","); q.breakable()
-                q.text("priority = ");
-                q.text("%#x" % self.priority)
-                q.text(","); q.breakable()
-                q.text("idle_timeout = ");
-                q.text("%#x" % self.idle_timeout)
-                q.text(","); q.breakable()
-                q.text("hard_timeout = ");
-                q.text("%#x" % self.hard_timeout)
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("packet_count = ");
-                q.text("%#x" % self.packet_count)
-                q.text(","); q.breakable()
-                q.text("byte_count = ");
-                q.text("%#x" % self.byte_count)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-                q.text(","); q.breakable()
-                q.text("instructions = ");
-                q.pp(self.instructions)
-            q.breakable()
-        q.text('}')
-
-
-class group_desc_stats_entry(loxi.OFObject):
-
-    def __init__(self, group_type=None, group_id=None, buckets=None):
-        if group_type != None:
-            self.group_type = group_type
-        else:
-            self.group_type = 0
-        if group_id != None:
-            self.group_id = group_id
-        else:
-            self.group_id = 0
-        if buckets != None:
-            self.buckets = buckets
-        else:
-            self.buckets = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 0
-        packed.append(struct.pack("!B", self.group_type))
-        packed.append('\x00' * 1)
-        packed.append(struct.pack("!L", self.group_id))
-        packed.append(loxi.generic_util.pack_list(self.buckets))
-        length = sum([len(x) for x in packed])
-        packed[0] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group_desc_stats_entry()
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 2)
-        obj.group_type = reader.read("!B")[0]
-        reader.skip(1)
-        obj.group_id = reader.read("!L")[0]
-        obj.buckets = loxi.generic_util.unpack_list(reader, ofp.common.bucket.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.group_type != other.group_type: return False
-        if self.group_id != other.group_id: return False
-        if self.buckets != other.buckets: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_desc_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("group_type = ");
-                q.text("%#x" % self.group_type)
-                q.text(","); q.breakable()
-                q.text("group_id = ");
-                q.text("%#x" % self.group_id)
-                q.text(","); q.breakable()
-                q.text("buckets = ");
-                q.pp(self.buckets)
-            q.breakable()
-        q.text('}')
-
-
-class group_stats_entry(loxi.OFObject):
-
-    def __init__(self, group_id=None, ref_count=None, packet_count=None, byte_count=None, duration_sec=None, duration_nsec=None, bucket_stats=None):
-        if group_id != None:
-            self.group_id = group_id
-        else:
-            self.group_id = 0
-        if ref_count != None:
-            self.ref_count = ref_count
-        else:
-            self.ref_count = 0
-        if packet_count != None:
-            self.packet_count = packet_count
-        else:
-            self.packet_count = 0
-        if byte_count != None:
-            self.byte_count = byte_count
-        else:
-            self.byte_count = 0
-        if duration_sec != None:
-            self.duration_sec = duration_sec
-        else:
-            self.duration_sec = 0
-        if duration_nsec != None:
-            self.duration_nsec = duration_nsec
-        else:
-            self.duration_nsec = 0
-        if bucket_stats != None:
-            self.bucket_stats = bucket_stats
-        else:
-            self.bucket_stats = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 0
-        packed.append('\x00' * 2)
-        packed.append(struct.pack("!L", self.group_id))
-        packed.append(struct.pack("!L", self.ref_count))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!Q", self.packet_count))
-        packed.append(struct.pack("!Q", self.byte_count))
-        packed.append(struct.pack("!L", self.duration_sec))
-        packed.append(struct.pack("!L", self.duration_nsec))
-        packed.append(loxi.generic_util.pack_list(self.bucket_stats))
-        length = sum([len(x) for x in packed])
-        packed[0] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group_stats_entry()
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 2)
-        reader.skip(2)
-        obj.group_id = reader.read("!L")[0]
-        obj.ref_count = reader.read("!L")[0]
-        reader.skip(4)
-        obj.packet_count = reader.read("!Q")[0]
-        obj.byte_count = reader.read("!Q")[0]
-        obj.duration_sec = reader.read("!L")[0]
-        obj.duration_nsec = reader.read("!L")[0]
-        obj.bucket_stats = loxi.generic_util.unpack_list(reader, ofp.common.bucket_counter.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.group_id != other.group_id: return False
-        if self.ref_count != other.ref_count: return False
-        if self.packet_count != other.packet_count: return False
-        if self.byte_count != other.byte_count: return False
-        if self.duration_sec != other.duration_sec: return False
-        if self.duration_nsec != other.duration_nsec: return False
-        if self.bucket_stats != other.bucket_stats: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("group_id = ");
-                q.text("%#x" % self.group_id)
-                q.text(","); q.breakable()
-                q.text("ref_count = ");
-                q.text("%#x" % self.ref_count)
-                q.text(","); q.breakable()
-                q.text("packet_count = ");
-                q.text("%#x" % self.packet_count)
-                q.text(","); q.breakable()
-                q.text("byte_count = ");
-                q.text("%#x" % self.byte_count)
-                q.text(","); q.breakable()
-                q.text("duration_sec = ");
-                q.text("%#x" % self.duration_sec)
-                q.text(","); q.breakable()
-                q.text("duration_nsec = ");
-                q.text("%#x" % self.duration_nsec)
-                q.text(","); q.breakable()
-                q.text("bucket_stats = ");
-                q.pp(self.bucket_stats)
-            q.breakable()
-        q.text('}')
-
-
-class hello_elem(loxi.OFObject):
-    subtypes = {}
-
-
-    def __init__(self, type=None):
-        if type != None:
-            self.type = type
-        else:
-            self.type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 0)
-        subclass = hello_elem.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = hello_elem()
-        obj.type = reader.read("!H")[0]
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type != other.type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("hello_elem {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-
-class hello_elem_versionbitmap(hello_elem):
-    type = 1
-
-    def __init__(self, bitmaps=None):
-        if bitmaps != None:
-            self.bitmaps = bitmaps
-        else:
-            self.bitmaps = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(loxi.generic_util.pack_list(self.bitmaps))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = hello_elem_versionbitmap()
-        _type = reader.read("!H")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.bitmaps = loxi.generic_util.unpack_list(reader, ofp.common.uint32.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.bitmaps != other.bitmaps: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("hello_elem_versionbitmap {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("bitmaps = ");
-                q.pp(self.bitmaps)
-            q.breakable()
-        q.text('}')
-
-hello_elem.subtypes[1] = hello_elem_versionbitmap
-
-class hello_elem_bitmap(loxi.OFObject):
-
-    def __init__(self, version_list=None):
-        if version_list != None:
-            self.version_list = version_list
-        else:
-            self.version_list = []
-        self.bitmap = 0
-        for version in version_list:
-            self.bitmap = self.bitmap | 1 << version
-        return
-
-    def pack(self):
-        return struct.pack("!L", self.bitmap)
-
-class match_v3(loxi.OFObject):
-    type = 1
-
-    def __init__(self, oxm_list=None):
-        if oxm_list != None:
-            self.oxm_list = oxm_list
-        else:
-            self.oxm_list = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(loxi.generic_util.pack_list(self.oxm_list))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        packed.append(loxi.generic_util.pad_to(8, length))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = match_v3()
-        _type = reader.read("!H")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.oxm_list = loxi.generic_util.unpack_list(reader, ofp.oxm.oxm.unpack)
-        orig_reader.skip_align()
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.oxm_list != other.oxm_list: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("match_v3 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("oxm_list = ");
-                q.pp(self.oxm_list)
-            q.breakable()
-        q.text('}')
-
-
-class meter_band_stats(loxi.OFObject):
-
-    def __init__(self, packet_band_count=None, byte_band_count=None):
-        if packet_band_count != None:
-            self.packet_band_count = packet_band_count
-        else:
-            self.packet_band_count = 0
-        if byte_band_count != None:
-            self.byte_band_count = byte_band_count
-        else:
-            self.byte_band_count = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!Q", self.packet_band_count))
-        packed.append(struct.pack("!Q", self.byte_band_count))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = meter_band_stats()
-        obj.packet_band_count = reader.read("!Q")[0]
-        obj.byte_band_count = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.packet_band_count != other.packet_band_count: return False
-        if self.byte_band_count != other.byte_band_count: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("meter_band_stats {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("packet_band_count = ");
-                q.text("%#x" % self.packet_band_count)
-                q.text(","); q.breakable()
-                q.text("byte_band_count = ");
-                q.text("%#x" % self.byte_band_count)
-            q.breakable()
-        q.text('}')
-
-
-class meter_config(loxi.OFObject):
-
-    def __init__(self, flags=None, meter_id=None, entries=None):
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if meter_id != None:
-            self.meter_id = meter_id
-        else:
-            self.meter_id = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 0
-        packed.append(struct.pack("!H", self.flags))
-        packed.append(struct.pack("!L", self.meter_id))
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[0] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = meter_config()
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 2)
-        obj.flags = reader.read("!H")[0]
-        obj.meter_id = reader.read("!L")[0]
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.meter_band.meter_band.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.flags != other.flags: return False
-        if self.meter_id != other.meter_id: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("meter_config {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("meter_id = ");
-                q.text("%#x" % self.meter_id)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-
-class meter_features(loxi.OFObject):
-
-    def __init__(self, max_meter=None, band_types=None, capabilities=None, max_bands=None, max_color=None):
-        if max_meter != None:
-            self.max_meter = max_meter
-        else:
-            self.max_meter = 0
-        if band_types != None:
-            self.band_types = band_types
-        else:
-            self.band_types = 0
-        if capabilities != None:
-            self.capabilities = capabilities
-        else:
-            self.capabilities = 0
-        if max_bands != None:
-            self.max_bands = max_bands
-        else:
-            self.max_bands = 0
-        if max_color != None:
-            self.max_color = max_color
-        else:
-            self.max_color = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.max_meter))
-        packed.append(struct.pack("!L", self.band_types))
-        packed.append(struct.pack("!L", self.capabilities))
-        packed.append(struct.pack("!B", self.max_bands))
-        packed.append(struct.pack("!B", self.max_color))
-        packed.append('\x00' * 2)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = meter_features()
-        obj.max_meter = reader.read("!L")[0]
-        obj.band_types = reader.read("!L")[0]
-        obj.capabilities = reader.read("!L")[0]
-        obj.max_bands = reader.read("!B")[0]
-        obj.max_color = reader.read("!B")[0]
-        reader.skip(2)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.max_meter != other.max_meter: return False
-        if self.band_types != other.band_types: return False
-        if self.capabilities != other.capabilities: return False
-        if self.max_bands != other.max_bands: return False
-        if self.max_color != other.max_color: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("meter_features {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("max_meter = ");
-                q.text("%#x" % self.max_meter)
-                q.text(","); q.breakable()
-                q.text("band_types = ");
-                q.text("%#x" % self.band_types)
-                q.text(","); q.breakable()
-                q.text("capabilities = ");
-                q.text("%#x" % self.capabilities)
-                q.text(","); q.breakable()
-                q.text("max_bands = ");
-                q.text("%#x" % self.max_bands)
-                q.text(","); q.breakable()
-                q.text("max_color = ");
-                q.text("%#x" % self.max_color)
-            q.breakable()
-        q.text('}')
-
-
-class meter_stats(loxi.OFObject):
-
-    def __init__(self, meter_id=None, flow_count=None, packet_in_count=None, byte_in_count=None, duration_sec=None, duration_nsec=None, band_stats=None):
-        if meter_id != None:
-            self.meter_id = meter_id
-        else:
-            self.meter_id = 0
-        if flow_count != None:
-            self.flow_count = flow_count
-        else:
-            self.flow_count = 0
-        if packet_in_count != None:
-            self.packet_in_count = packet_in_count
-        else:
-            self.packet_in_count = 0
-        if byte_in_count != None:
-            self.byte_in_count = byte_in_count
-        else:
-            self.byte_in_count = 0
-        if duration_sec != None:
-            self.duration_sec = duration_sec
-        else:
-            self.duration_sec = 0
-        if duration_nsec != None:
-            self.duration_nsec = duration_nsec
-        else:
-            self.duration_nsec = 0
-        if band_stats != None:
-            self.band_stats = band_stats
-        else:
-            self.band_stats = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.meter_id))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 6)
-        packed.append(struct.pack("!L", self.flow_count))
-        packed.append(struct.pack("!Q", self.packet_in_count))
-        packed.append(struct.pack("!Q", self.byte_in_count))
-        packed.append(struct.pack("!L", self.duration_sec))
-        packed.append(struct.pack("!L", self.duration_nsec))
-        packed.append(loxi.generic_util.pack_list(self.band_stats))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = meter_stats()
-        obj.meter_id = reader.read("!L")[0]
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 6)
-        reader.skip(6)
-        obj.flow_count = reader.read("!L")[0]
-        obj.packet_in_count = reader.read("!Q")[0]
-        obj.byte_in_count = reader.read("!Q")[0]
-        obj.duration_sec = reader.read("!L")[0]
-        obj.duration_nsec = reader.read("!L")[0]
-        obj.band_stats = loxi.generic_util.unpack_list(reader, ofp.common.meter_band_stats.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.meter_id != other.meter_id: return False
-        if self.flow_count != other.flow_count: return False
-        if self.packet_in_count != other.packet_in_count: return False
-        if self.byte_in_count != other.byte_in_count: return False
-        if self.duration_sec != other.duration_sec: return False
-        if self.duration_nsec != other.duration_nsec: return False
-        if self.band_stats != other.band_stats: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("meter_stats {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("meter_id = ");
-                q.text("%#x" % self.meter_id)
-                q.text(","); q.breakable()
-                q.text("flow_count = ");
-                q.text("%#x" % self.flow_count)
-                q.text(","); q.breakable()
-                q.text("packet_in_count = ");
-                q.text("%#x" % self.packet_in_count)
-                q.text(","); q.breakable()
-                q.text("byte_in_count = ");
-                q.text("%#x" % self.byte_in_count)
-                q.text(","); q.breakable()
-                q.text("duration_sec = ");
-                q.text("%#x" % self.duration_sec)
-                q.text(","); q.breakable()
-                q.text("duration_nsec = ");
-                q.text("%#x" % self.duration_nsec)
-                q.text(","); q.breakable()
-                q.text("band_stats = ");
-                q.pp(self.band_stats)
-            q.breakable()
-        q.text('}')
-
-
-class packet_queue(loxi.OFObject):
-
-    def __init__(self, queue_id=None, port=None, properties=None):
-        if queue_id != None:
-            self.queue_id = queue_id
-        else:
-            self.queue_id = 0
-        if port != None:
-            self.port = port
-        else:
-            self.port = 0
-        if properties != None:
-            self.properties = properties
-        else:
-            self.properties = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.queue_id))
-        packed.append(util.pack_port_no(self.port))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 2
-        packed.append('\x00' * 6)
-        packed.append(loxi.generic_util.pack_list(self.properties))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = packet_queue()
-        obj.queue_id = reader.read("!L")[0]
-        obj.port = util.unpack_port_no(reader)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 10)
-        reader.skip(6)
-        obj.properties = loxi.generic_util.unpack_list(reader, ofp.common.queue_prop.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.queue_id != other.queue_id: return False
-        if self.port != other.port: return False
-        if self.properties != other.properties: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("packet_queue {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("queue_id = ");
-                q.text("%#x" % self.queue_id)
-                q.text(","); q.breakable()
-                q.text("port = ");
-                q.text(util.pretty_port(self.port))
-                q.text(","); q.breakable()
-                q.text("properties = ");
-                q.pp(self.properties)
-            q.breakable()
-        q.text('}')
-
-
-class port_desc(loxi.OFObject):
-
-    def __init__(self, port_no=None, hw_addr=None, name=None, config=None, state=None, curr=None, advertised=None, supported=None, peer=None, curr_speed=None, max_speed=None):
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if hw_addr != None:
-            self.hw_addr = hw_addr
-        else:
-            self.hw_addr = [0,0,0,0,0,0]
-        if name != None:
-            self.name = name
-        else:
-            self.name = ""
-        if config != None:
-            self.config = config
-        else:
-            self.config = 0
-        if state != None:
-            self.state = state
-        else:
-            self.state = 0
-        if curr != None:
-            self.curr = curr
-        else:
-            self.curr = 0
-        if advertised != None:
-            self.advertised = advertised
-        else:
-            self.advertised = 0
-        if supported != None:
-            self.supported = supported
-        else:
-            self.supported = 0
-        if peer != None:
-            self.peer = peer
-        else:
-            self.peer = 0
-        if curr_speed != None:
-            self.curr_speed = curr_speed
-        else:
-            self.curr_speed = 0
-        if max_speed != None:
-            self.max_speed = max_speed
-        else:
-            self.max_speed = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!6B", *self.hw_addr))
-        packed.append('\x00' * 2)
-        packed.append(struct.pack("!16s", self.name))
-        packed.append(struct.pack("!L", self.config))
-        packed.append(struct.pack("!L", self.state))
-        packed.append(struct.pack("!L", self.curr))
-        packed.append(struct.pack("!L", self.advertised))
-        packed.append(struct.pack("!L", self.supported))
-        packed.append(struct.pack("!L", self.peer))
-        packed.append(struct.pack("!L", self.curr_speed))
-        packed.append(struct.pack("!L", self.max_speed))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = port_desc()
-        obj.port_no = util.unpack_port_no(reader)
-        reader.skip(4)
-        obj.hw_addr = list(reader.read('!6B'))
-        reader.skip(2)
-        obj.name = reader.read("!16s")[0].rstrip("\x00")
-        obj.config = reader.read("!L")[0]
-        obj.state = reader.read("!L")[0]
-        obj.curr = reader.read("!L")[0]
-        obj.advertised = reader.read("!L")[0]
-        obj.supported = reader.read("!L")[0]
-        obj.peer = reader.read("!L")[0]
-        obj.curr_speed = reader.read("!L")[0]
-        obj.max_speed = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.port_no != other.port_no: return False
-        if self.hw_addr != other.hw_addr: return False
-        if self.name != other.name: return False
-        if self.config != other.config: return False
-        if self.state != other.state: return False
-        if self.curr != other.curr: return False
-        if self.advertised != other.advertised: return False
-        if self.supported != other.supported: return False
-        if self.peer != other.peer: return False
-        if self.curr_speed != other.curr_speed: return False
-        if self.max_speed != other.max_speed: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port_desc {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("hw_addr = ");
-                q.text(util.pretty_mac(self.hw_addr))
-                q.text(","); q.breakable()
-                q.text("name = ");
-                q.pp(self.name)
-                q.text(","); q.breakable()
-                q.text("config = ");
-                q.text("%#x" % self.config)
-                q.text(","); q.breakable()
-                q.text("state = ");
-                q.text("%#x" % self.state)
-                q.text(","); q.breakable()
-                q.text("curr = ");
-                q.text("%#x" % self.curr)
-                q.text(","); q.breakable()
-                q.text("advertised = ");
-                q.text("%#x" % self.advertised)
-                q.text(","); q.breakable()
-                q.text("supported = ");
-                q.text("%#x" % self.supported)
-                q.text(","); q.breakable()
-                q.text("peer = ");
-                q.text("%#x" % self.peer)
-                q.text(","); q.breakable()
-                q.text("curr_speed = ");
-                q.text("%#x" % self.curr_speed)
-                q.text(","); q.breakable()
-                q.text("max_speed = ");
-                q.text("%#x" % self.max_speed)
-            q.breakable()
-        q.text('}')
-
-
-class port_stats_entry(loxi.OFObject):
-
-    def __init__(self, port_no=None, rx_packets=None, tx_packets=None, rx_bytes=None, tx_bytes=None, rx_dropped=None, tx_dropped=None, rx_errors=None, tx_errors=None, rx_frame_err=None, rx_over_err=None, rx_crc_err=None, collisions=None, duration_sec=None, duration_nsec=None):
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if rx_packets != None:
-            self.rx_packets = rx_packets
-        else:
-            self.rx_packets = 0
-        if tx_packets != None:
-            self.tx_packets = tx_packets
-        else:
-            self.tx_packets = 0
-        if rx_bytes != None:
-            self.rx_bytes = rx_bytes
-        else:
-            self.rx_bytes = 0
-        if tx_bytes != None:
-            self.tx_bytes = tx_bytes
-        else:
-            self.tx_bytes = 0
-        if rx_dropped != None:
-            self.rx_dropped = rx_dropped
-        else:
-            self.rx_dropped = 0
-        if tx_dropped != None:
-            self.tx_dropped = tx_dropped
-        else:
-            self.tx_dropped = 0
-        if rx_errors != None:
-            self.rx_errors = rx_errors
-        else:
-            self.rx_errors = 0
-        if tx_errors != None:
-            self.tx_errors = tx_errors
-        else:
-            self.tx_errors = 0
-        if rx_frame_err != None:
-            self.rx_frame_err = rx_frame_err
-        else:
-            self.rx_frame_err = 0
-        if rx_over_err != None:
-            self.rx_over_err = rx_over_err
-        else:
-            self.rx_over_err = 0
-        if rx_crc_err != None:
-            self.rx_crc_err = rx_crc_err
-        else:
-            self.rx_crc_err = 0
-        if collisions != None:
-            self.collisions = collisions
-        else:
-            self.collisions = 0
-        if duration_sec != None:
-            self.duration_sec = duration_sec
-        else:
-            self.duration_sec = 0
-        if duration_nsec != None:
-            self.duration_nsec = duration_nsec
-        else:
-            self.duration_nsec = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!Q", self.rx_packets))
-        packed.append(struct.pack("!Q", self.tx_packets))
-        packed.append(struct.pack("!Q", self.rx_bytes))
-        packed.append(struct.pack("!Q", self.tx_bytes))
-        packed.append(struct.pack("!Q", self.rx_dropped))
-        packed.append(struct.pack("!Q", self.tx_dropped))
-        packed.append(struct.pack("!Q", self.rx_errors))
-        packed.append(struct.pack("!Q", self.tx_errors))
-        packed.append(struct.pack("!Q", self.rx_frame_err))
-        packed.append(struct.pack("!Q", self.rx_over_err))
-        packed.append(struct.pack("!Q", self.rx_crc_err))
-        packed.append(struct.pack("!Q", self.collisions))
-        packed.append(struct.pack("!L", self.duration_sec))
-        packed.append(struct.pack("!L", self.duration_nsec))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = port_stats_entry()
-        obj.port_no = util.unpack_port_no(reader)
-        reader.skip(4)
-        obj.rx_packets = reader.read("!Q")[0]
-        obj.tx_packets = reader.read("!Q")[0]
-        obj.rx_bytes = reader.read("!Q")[0]
-        obj.tx_bytes = reader.read("!Q")[0]
-        obj.rx_dropped = reader.read("!Q")[0]
-        obj.tx_dropped = reader.read("!Q")[0]
-        obj.rx_errors = reader.read("!Q")[0]
-        obj.tx_errors = reader.read("!Q")[0]
-        obj.rx_frame_err = reader.read("!Q")[0]
-        obj.rx_over_err = reader.read("!Q")[0]
-        obj.rx_crc_err = reader.read("!Q")[0]
-        obj.collisions = reader.read("!Q")[0]
-        obj.duration_sec = reader.read("!L")[0]
-        obj.duration_nsec = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.port_no != other.port_no: return False
-        if self.rx_packets != other.rx_packets: return False
-        if self.tx_packets != other.tx_packets: return False
-        if self.rx_bytes != other.rx_bytes: return False
-        if self.tx_bytes != other.tx_bytes: return False
-        if self.rx_dropped != other.rx_dropped: return False
-        if self.tx_dropped != other.tx_dropped: return False
-        if self.rx_errors != other.rx_errors: return False
-        if self.tx_errors != other.tx_errors: return False
-        if self.rx_frame_err != other.rx_frame_err: return False
-        if self.rx_over_err != other.rx_over_err: return False
-        if self.rx_crc_err != other.rx_crc_err: return False
-        if self.collisions != other.collisions: return False
-        if self.duration_sec != other.duration_sec: return False
-        if self.duration_nsec != other.duration_nsec: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("rx_packets = ");
-                q.text("%#x" % self.rx_packets)
-                q.text(","); q.breakable()
-                q.text("tx_packets = ");
-                q.text("%#x" % self.tx_packets)
-                q.text(","); q.breakable()
-                q.text("rx_bytes = ");
-                q.text("%#x" % self.rx_bytes)
-                q.text(","); q.breakable()
-                q.text("tx_bytes = ");
-                q.text("%#x" % self.tx_bytes)
-                q.text(","); q.breakable()
-                q.text("rx_dropped = ");
-                q.text("%#x" % self.rx_dropped)
-                q.text(","); q.breakable()
-                q.text("tx_dropped = ");
-                q.text("%#x" % self.tx_dropped)
-                q.text(","); q.breakable()
-                q.text("rx_errors = ");
-                q.text("%#x" % self.rx_errors)
-                q.text(","); q.breakable()
-                q.text("tx_errors = ");
-                q.text("%#x" % self.tx_errors)
-                q.text(","); q.breakable()
-                q.text("rx_frame_err = ");
-                q.text("%#x" % self.rx_frame_err)
-                q.text(","); q.breakable()
-                q.text("rx_over_err = ");
-                q.text("%#x" % self.rx_over_err)
-                q.text(","); q.breakable()
-                q.text("rx_crc_err = ");
-                q.text("%#x" % self.rx_crc_err)
-                q.text(","); q.breakable()
-                q.text("collisions = ");
-                q.text("%#x" % self.collisions)
-                q.text(","); q.breakable()
-                q.text("duration_sec = ");
-                q.text("%#x" % self.duration_sec)
-                q.text(","); q.breakable()
-                q.text("duration_nsec = ");
-                q.text("%#x" % self.duration_nsec)
-            q.breakable()
-        q.text('}')
-
-
-class queue_prop(loxi.OFObject):
-    subtypes = {}
-
-
-    def __init__(self, type=None):
-        if type != None:
-            self.type = type
-        else:
-            self.type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 0)
-        subclass = queue_prop.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = queue_prop()
-        obj.type = reader.read("!H")[0]
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type != other.type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_prop {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-
-class queue_prop_experimenter(queue_prop):
-    subtypes = {}
-
-    type = 65535
-
-    def __init__(self, experimenter=None, data=None):
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append('\x00' * 4)
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 8)
-        subclass = queue_prop_experimenter.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = queue_prop_experimenter()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        obj.experimenter = reader.read("!L")[0]
-        reader.skip(4)
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.experimenter != other.experimenter: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_prop_experimenter {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-queue_prop.subtypes[65535] = queue_prop_experimenter
-
-class queue_prop_max_rate(queue_prop):
-    type = 2
-
-    def __init__(self, rate=None):
-        if rate != None:
-            self.rate = rate
-        else:
-            self.rate = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!H", self.rate))
-        packed.append('\x00' * 6)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = queue_prop_max_rate()
-        _type = reader.read("!H")[0]
-        assert(_type == 2)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        obj.rate = reader.read("!H")[0]
-        reader.skip(6)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.rate != other.rate: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_prop_max_rate {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("rate = ");
-                q.text("%#x" % self.rate)
-            q.breakable()
-        q.text('}')
-
-queue_prop.subtypes[2] = queue_prop_max_rate
-
-class queue_prop_min_rate(queue_prop):
-    type = 1
-
-    def __init__(self, rate=None):
-        if rate != None:
-            self.rate = rate
-        else:
-            self.rate = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!H", self.rate))
-        packed.append('\x00' * 6)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = queue_prop_min_rate()
-        _type = reader.read("!H")[0]
-        assert(_type == 1)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        obj.rate = reader.read("!H")[0]
-        reader.skip(6)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.rate != other.rate: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_prop_min_rate {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("rate = ");
-                q.text("%#x" % self.rate)
-            q.breakable()
-        q.text('}')
-
-queue_prop.subtypes[1] = queue_prop_min_rate
-
-class queue_stats_entry(loxi.OFObject):
-
-    def __init__(self, port_no=None, queue_id=None, tx_bytes=None, tx_packets=None, tx_errors=None, duration_sec=None, duration_nsec=None):
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if queue_id != None:
-            self.queue_id = queue_id
-        else:
-            self.queue_id = 0
-        if tx_bytes != None:
-            self.tx_bytes = tx_bytes
-        else:
-            self.tx_bytes = 0
-        if tx_packets != None:
-            self.tx_packets = tx_packets
-        else:
-            self.tx_packets = 0
-        if tx_errors != None:
-            self.tx_errors = tx_errors
-        else:
-            self.tx_errors = 0
-        if duration_sec != None:
-            self.duration_sec = duration_sec
-        else:
-            self.duration_sec = 0
-        if duration_nsec != None:
-            self.duration_nsec = duration_nsec
-        else:
-            self.duration_nsec = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(struct.pack("!L", self.queue_id))
-        packed.append(struct.pack("!Q", self.tx_bytes))
-        packed.append(struct.pack("!Q", self.tx_packets))
-        packed.append(struct.pack("!Q", self.tx_errors))
-        packed.append(struct.pack("!L", self.duration_sec))
-        packed.append(struct.pack("!L", self.duration_nsec))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = queue_stats_entry()
-        obj.port_no = util.unpack_port_no(reader)
-        obj.queue_id = reader.read("!L")[0]
-        obj.tx_bytes = reader.read("!Q")[0]
-        obj.tx_packets = reader.read("!Q")[0]
-        obj.tx_errors = reader.read("!Q")[0]
-        obj.duration_sec = reader.read("!L")[0]
-        obj.duration_nsec = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.port_no != other.port_no: return False
-        if self.queue_id != other.queue_id: return False
-        if self.tx_bytes != other.tx_bytes: return False
-        if self.tx_packets != other.tx_packets: return False
-        if self.tx_errors != other.tx_errors: return False
-        if self.duration_sec != other.duration_sec: return False
-        if self.duration_nsec != other.duration_nsec: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("queue_id = ");
-                q.text("%#x" % self.queue_id)
-                q.text(","); q.breakable()
-                q.text("tx_bytes = ");
-                q.text("%#x" % self.tx_bytes)
-                q.text(","); q.breakable()
-                q.text("tx_packets = ");
-                q.text("%#x" % self.tx_packets)
-                q.text(","); q.breakable()
-                q.text("tx_errors = ");
-                q.text("%#x" % self.tx_errors)
-                q.text(","); q.breakable()
-                q.text("duration_sec = ");
-                q.text("%#x" % self.duration_sec)
-                q.text(","); q.breakable()
-                q.text("duration_nsec = ");
-                q.text("%#x" % self.duration_nsec)
-            q.breakable()
-        q.text('}')
-
-
-class table_feature_prop(loxi.OFObject):
-    subtypes = {}
-
-
-    def __init__(self, type=None):
-        if type != None:
-            self.type = type
-        else:
-            self.type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 0)
-        subclass = table_feature_prop.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = table_feature_prop()
-        obj.type = reader.read("!H")[0]
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type != other.type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_feature_prop {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-
-class table_feature_prop_apply_actions(table_feature_prop):
-    type = 6
-
-    def __init__(self, action_ids=None):
-        if action_ids != None:
-            self.action_ids = action_ids
-        else:
-            self.action_ids = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(loxi.generic_util.pack_list(self.action_ids))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        packed.append(loxi.generic_util.pad_to(8, length))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_feature_prop_apply_actions()
-        _type = reader.read("!H")[0]
-        assert(_type == 6)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.action_ids = loxi.generic_util.unpack_list(reader, ofp.action_id.action_id.unpack)
-        orig_reader.skip_align()
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.action_ids != other.action_ids: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_feature_prop_apply_actions {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("action_ids = ");
-                q.pp(self.action_ids)
-            q.breakable()
-        q.text('}')
-
-table_feature_prop.subtypes[6] = table_feature_prop_apply_actions
-
-class table_feature_prop_apply_actions_miss(table_feature_prop):
-    type = 7
-
-    def __init__(self, action_ids=None):
-        if action_ids != None:
-            self.action_ids = action_ids
-        else:
-            self.action_ids = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(loxi.generic_util.pack_list(self.action_ids))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        packed.append(loxi.generic_util.pad_to(8, length))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_feature_prop_apply_actions_miss()
-        _type = reader.read("!H")[0]
-        assert(_type == 7)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.action_ids = loxi.generic_util.unpack_list(reader, ofp.action_id.action_id.unpack)
-        orig_reader.skip_align()
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.action_ids != other.action_ids: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_feature_prop_apply_actions_miss {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("action_ids = ");
-                q.pp(self.action_ids)
-            q.breakable()
-        q.text('}')
-
-table_feature_prop.subtypes[7] = table_feature_prop_apply_actions_miss
-
-class table_feature_prop_apply_setfield(table_feature_prop):
-    type = 14
-
-    def __init__(self, oxm_ids=None):
-        if oxm_ids != None:
-            self.oxm_ids = oxm_ids
-        else:
-            self.oxm_ids = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(loxi.generic_util.pack_list(self.oxm_ids))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        packed.append(loxi.generic_util.pad_to(8, length))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_feature_prop_apply_setfield()
-        _type = reader.read("!H")[0]
-        assert(_type == 14)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.oxm_ids = loxi.generic_util.unpack_list(reader, ofp.common.uint32.unpack)
-        orig_reader.skip_align()
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.oxm_ids != other.oxm_ids: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_feature_prop_apply_setfield {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("oxm_ids = ");
-                q.pp(self.oxm_ids)
-            q.breakable()
-        q.text('}')
-
-table_feature_prop.subtypes[14] = table_feature_prop_apply_setfield
-
-class table_feature_prop_apply_setfield_miss(table_feature_prop):
-    type = 15
-
-    def __init__(self, oxm_ids=None):
-        if oxm_ids != None:
-            self.oxm_ids = oxm_ids
-        else:
-            self.oxm_ids = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(loxi.generic_util.pack_list(self.oxm_ids))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        packed.append(loxi.generic_util.pad_to(8, length))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_feature_prop_apply_setfield_miss()
-        _type = reader.read("!H")[0]
-        assert(_type == 15)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.oxm_ids = loxi.generic_util.unpack_list(reader, ofp.common.uint32.unpack)
-        orig_reader.skip_align()
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.oxm_ids != other.oxm_ids: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_feature_prop_apply_setfield_miss {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("oxm_ids = ");
-                q.pp(self.oxm_ids)
-            q.breakable()
-        q.text('}')
-
-table_feature_prop.subtypes[15] = table_feature_prop_apply_setfield_miss
-
-class table_feature_prop_experimenter(table_feature_prop):
-    subtypes = {}
-
-    type = 65534
-
-    def __init__(self, experimenter=None, subtype=None, experimenter_data=None):
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        if experimenter_data != None:
-            self.experimenter_data = experimenter_data
-        else:
-            self.experimenter_data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(self.experimenter_data)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        packed.append(loxi.generic_util.pad_to(8, length))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 4)
-        subclass = table_feature_prop_experimenter.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = table_feature_prop_experimenter()
-        _type = reader.read("!H")[0]
-        assert(_type == 65534)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.experimenter = reader.read("!L")[0]
-        obj.subtype = reader.read("!L")[0]
-        obj.experimenter_data = str(reader.read_all())
-        orig_reader.skip_align()
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.experimenter != other.experimenter: return False
-        if self.subtype != other.subtype: return False
-        if self.experimenter_data != other.experimenter_data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_feature_prop_experimenter {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("subtype = ");
-                q.text("%#x" % self.subtype)
-                q.text(","); q.breakable()
-                q.text("experimenter_data = ");
-                q.pp(self.experimenter_data)
-            q.breakable()
-        q.text('}')
-
-table_feature_prop.subtypes[65534] = table_feature_prop_experimenter
-
-class table_feature_prop_experimenter_miss(table_feature_prop):
-    subtypes = {}
-
-    type = 65535
-
-    def __init__(self, experimenter=None, subtype=None, experimenter_data=None):
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        if experimenter_data != None:
-            self.experimenter_data = experimenter_data
-        else:
-            self.experimenter_data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(self.experimenter_data)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        packed.append(loxi.generic_util.pad_to(8, length))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 4)
-        subclass = table_feature_prop_experimenter_miss.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = table_feature_prop_experimenter_miss()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.experimenter = reader.read("!L")[0]
-        obj.subtype = reader.read("!L")[0]
-        obj.experimenter_data = str(reader.read_all())
-        orig_reader.skip_align()
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.experimenter != other.experimenter: return False
-        if self.subtype != other.subtype: return False
-        if self.experimenter_data != other.experimenter_data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_feature_prop_experimenter_miss {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("subtype = ");
-                q.text("%#x" % self.subtype)
-                q.text(","); q.breakable()
-                q.text("experimenter_data = ");
-                q.pp(self.experimenter_data)
-            q.breakable()
-        q.text('}')
-
-table_feature_prop.subtypes[65535] = table_feature_prop_experimenter_miss
-
-class table_feature_prop_instructions(table_feature_prop):
-    type = 0
-
-    def __init__(self, instruction_ids=None):
-        if instruction_ids != None:
-            self.instruction_ids = instruction_ids
-        else:
-            self.instruction_ids = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(loxi.generic_util.pack_list(self.instruction_ids))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        packed.append(loxi.generic_util.pad_to(8, length))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_feature_prop_instructions()
-        _type = reader.read("!H")[0]
-        assert(_type == 0)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.instruction_ids = loxi.generic_util.unpack_list(reader, ofp.instruction_id.instruction_id.unpack)
-        orig_reader.skip_align()
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.instruction_ids != other.instruction_ids: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_feature_prop_instructions {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("instruction_ids = ");
-                q.pp(self.instruction_ids)
-            q.breakable()
-        q.text('}')
-
-table_feature_prop.subtypes[0] = table_feature_prop_instructions
-
-class table_feature_prop_instructions_miss(table_feature_prop):
-    type = 1
-
-    def __init__(self, instruction_ids=None):
-        if instruction_ids != None:
-            self.instruction_ids = instruction_ids
-        else:
-            self.instruction_ids = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(loxi.generic_util.pack_list(self.instruction_ids))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        packed.append(loxi.generic_util.pad_to(8, length))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_feature_prop_instructions_miss()
-        _type = reader.read("!H")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.instruction_ids = loxi.generic_util.unpack_list(reader, ofp.instruction_id.instruction_id.unpack)
-        orig_reader.skip_align()
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.instruction_ids != other.instruction_ids: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_feature_prop_instructions_miss {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("instruction_ids = ");
-                q.pp(self.instruction_ids)
-            q.breakable()
-        q.text('}')
-
-table_feature_prop.subtypes[1] = table_feature_prop_instructions_miss
-
-class table_feature_prop_match(table_feature_prop):
-    type = 8
-
-    def __init__(self, oxm_ids=None):
-        if oxm_ids != None:
-            self.oxm_ids = oxm_ids
-        else:
-            self.oxm_ids = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(loxi.generic_util.pack_list(self.oxm_ids))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        packed.append(loxi.generic_util.pad_to(8, length))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_feature_prop_match()
-        _type = reader.read("!H")[0]
-        assert(_type == 8)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.oxm_ids = loxi.generic_util.unpack_list(reader, ofp.common.uint32.unpack)
-        orig_reader.skip_align()
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.oxm_ids != other.oxm_ids: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_feature_prop_match {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("oxm_ids = ");
-                q.pp(self.oxm_ids)
-            q.breakable()
-        q.text('}')
-
-table_feature_prop.subtypes[8] = table_feature_prop_match
-
-class table_feature_prop_next_tables(table_feature_prop):
-    type = 2
-
-    def __init__(self, next_table_ids=None):
-        if next_table_ids != None:
-            self.next_table_ids = next_table_ids
-        else:
-            self.next_table_ids = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(loxi.generic_util.pack_list(self.next_table_ids))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        packed.append(loxi.generic_util.pad_to(8, length))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_feature_prop_next_tables()
-        _type = reader.read("!H")[0]
-        assert(_type == 2)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.next_table_ids = loxi.generic_util.unpack_list(reader, ofp.common.uint8.unpack)
-        orig_reader.skip_align()
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.next_table_ids != other.next_table_ids: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_feature_prop_next_tables {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("next_table_ids = ");
-                q.pp(self.next_table_ids)
-            q.breakable()
-        q.text('}')
-
-table_feature_prop.subtypes[2] = table_feature_prop_next_tables
-
-class table_feature_prop_next_tables_miss(table_feature_prop):
-    type = 3
-
-    def __init__(self, next_table_ids=None):
-        if next_table_ids != None:
-            self.next_table_ids = next_table_ids
-        else:
-            self.next_table_ids = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(loxi.generic_util.pack_list(self.next_table_ids))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        packed.append(loxi.generic_util.pad_to(8, length))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_feature_prop_next_tables_miss()
-        _type = reader.read("!H")[0]
-        assert(_type == 3)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.next_table_ids = loxi.generic_util.unpack_list(reader, ofp.common.uint8.unpack)
-        orig_reader.skip_align()
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.next_table_ids != other.next_table_ids: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_feature_prop_next_tables_miss {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("next_table_ids = ");
-                q.pp(self.next_table_ids)
-            q.breakable()
-        q.text('}')
-
-table_feature_prop.subtypes[3] = table_feature_prop_next_tables_miss
-
-class table_feature_prop_wildcards(table_feature_prop):
-    type = 10
-
-    def __init__(self, oxm_ids=None):
-        if oxm_ids != None:
-            self.oxm_ids = oxm_ids
-        else:
-            self.oxm_ids = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(loxi.generic_util.pack_list(self.oxm_ids))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        packed.append(loxi.generic_util.pad_to(8, length))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_feature_prop_wildcards()
-        _type = reader.read("!H")[0]
-        assert(_type == 10)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.oxm_ids = loxi.generic_util.unpack_list(reader, ofp.common.uint32.unpack)
-        orig_reader.skip_align()
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.oxm_ids != other.oxm_ids: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_feature_prop_wildcards {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("oxm_ids = ");
-                q.pp(self.oxm_ids)
-            q.breakable()
-        q.text('}')
-
-table_feature_prop.subtypes[10] = table_feature_prop_wildcards
-
-class table_feature_prop_write_actions(table_feature_prop):
-    type = 4
-
-    def __init__(self, action_ids=None):
-        if action_ids != None:
-            self.action_ids = action_ids
-        else:
-            self.action_ids = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(loxi.generic_util.pack_list(self.action_ids))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        packed.append(loxi.generic_util.pad_to(8, length))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_feature_prop_write_actions()
-        _type = reader.read("!H")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.action_ids = loxi.generic_util.unpack_list(reader, ofp.action_id.action_id.unpack)
-        orig_reader.skip_align()
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.action_ids != other.action_ids: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_feature_prop_write_actions {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("action_ids = ");
-                q.pp(self.action_ids)
-            q.breakable()
-        q.text('}')
-
-table_feature_prop.subtypes[4] = table_feature_prop_write_actions
-
-class table_feature_prop_write_actions_miss(table_feature_prop):
-    type = 5
-
-    def __init__(self, action_ids=None):
-        if action_ids != None:
-            self.action_ids = action_ids
-        else:
-            self.action_ids = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(loxi.generic_util.pack_list(self.action_ids))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        packed.append(loxi.generic_util.pad_to(8, length))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_feature_prop_write_actions_miss()
-        _type = reader.read("!H")[0]
-        assert(_type == 5)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.action_ids = loxi.generic_util.unpack_list(reader, ofp.action_id.action_id.unpack)
-        orig_reader.skip_align()
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.action_ids != other.action_ids: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_feature_prop_write_actions_miss {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("action_ids = ");
-                q.pp(self.action_ids)
-            q.breakable()
-        q.text('}')
-
-table_feature_prop.subtypes[5] = table_feature_prop_write_actions_miss
-
-class table_feature_prop_write_setfield(table_feature_prop):
-    type = 12
-
-    def __init__(self, oxm_ids=None):
-        if oxm_ids != None:
-            self.oxm_ids = oxm_ids
-        else:
-            self.oxm_ids = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(loxi.generic_util.pack_list(self.oxm_ids))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        packed.append(loxi.generic_util.pad_to(8, length))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_feature_prop_write_setfield()
-        _type = reader.read("!H")[0]
-        assert(_type == 12)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.oxm_ids = loxi.generic_util.unpack_list(reader, ofp.common.uint32.unpack)
-        orig_reader.skip_align()
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.oxm_ids != other.oxm_ids: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_feature_prop_write_setfield {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("oxm_ids = ");
-                q.pp(self.oxm_ids)
-            q.breakable()
-        q.text('}')
-
-table_feature_prop.subtypes[12] = table_feature_prop_write_setfield
-
-class table_feature_prop_write_setfield_miss(table_feature_prop):
-    type = 13
-
-    def __init__(self, oxm_ids=None):
-        if oxm_ids != None:
-            self.oxm_ids = oxm_ids
-        else:
-            self.oxm_ids = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(loxi.generic_util.pack_list(self.oxm_ids))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        packed.append(loxi.generic_util.pad_to(8, length))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_feature_prop_write_setfield_miss()
-        _type = reader.read("!H")[0]
-        assert(_type == 13)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.oxm_ids = loxi.generic_util.unpack_list(reader, ofp.common.uint32.unpack)
-        orig_reader.skip_align()
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.oxm_ids != other.oxm_ids: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_feature_prop_write_setfield_miss {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("oxm_ids = ");
-                q.pp(self.oxm_ids)
-            q.breakable()
-        q.text('}')
-
-table_feature_prop.subtypes[13] = table_feature_prop_write_setfield_miss
-
-class table_features(loxi.OFObject):
-
-    def __init__(self, table_id=None, name=None, metadata_match=None, metadata_write=None, config=None, max_entries=None, properties=None):
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if name != None:
-            self.name = name
-        else:
-            self.name = ""
-        if metadata_match != None:
-            self.metadata_match = metadata_match
-        else:
-            self.metadata_match = 0
-        if metadata_write != None:
-            self.metadata_write = metadata_write
-        else:
-            self.metadata_write = 0
-        if config != None:
-            self.config = config
-        else:
-            self.config = 0
-        if max_entries != None:
-            self.max_entries = max_entries
-        else:
-            self.max_entries = 0
-        if properties != None:
-            self.properties = properties
-        else:
-            self.properties = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 0
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append('\x00' * 5)
-        packed.append(struct.pack("!32s", self.name))
-        packed.append(struct.pack("!Q", self.metadata_match))
-        packed.append(struct.pack("!Q", self.metadata_write))
-        packed.append(struct.pack("!L", self.config))
-        packed.append(struct.pack("!L", self.max_entries))
-        packed.append(loxi.generic_util.pack_list(self.properties))
-        length = sum([len(x) for x in packed])
-        packed[0] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_features()
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 2)
-        obj.table_id = reader.read("!B")[0]
-        reader.skip(5)
-        obj.name = reader.read("!32s")[0].rstrip("\x00")
-        obj.metadata_match = reader.read("!Q")[0]
-        obj.metadata_write = reader.read("!Q")[0]
-        obj.config = reader.read("!L")[0]
-        obj.max_entries = reader.read("!L")[0]
-        obj.properties = loxi.generic_util.unpack_list(reader, ofp.common.table_feature_prop.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.table_id != other.table_id: return False
-        if self.name != other.name: return False
-        if self.metadata_match != other.metadata_match: return False
-        if self.metadata_write != other.metadata_write: return False
-        if self.config != other.config: return False
-        if self.max_entries != other.max_entries: return False
-        if self.properties != other.properties: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_features {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("name = ");
-                q.pp(self.name)
-                q.text(","); q.breakable()
-                q.text("metadata_match = ");
-                q.text("%#x" % self.metadata_match)
-                q.text(","); q.breakable()
-                q.text("metadata_write = ");
-                q.text("%#x" % self.metadata_write)
-                q.text(","); q.breakable()
-                q.text("config = ");
-                q.text("%#x" % self.config)
-                q.text(","); q.breakable()
-                q.text("max_entries = ");
-                q.text("%#x" % self.max_entries)
-                q.text(","); q.breakable()
-                q.text("properties = ");
-                q.pp(self.properties)
-            q.breakable()
-        q.text('}')
-
-
-class table_stats_entry(loxi.OFObject):
-
-    def __init__(self, table_id=None, active_count=None, lookup_count=None, matched_count=None):
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if active_count != None:
-            self.active_count = active_count
-        else:
-            self.active_count = 0
-        if lookup_count != None:
-            self.lookup_count = lookup_count
-        else:
-            self.lookup_count = 0
-        if matched_count != None:
-            self.matched_count = matched_count
-        else:
-            self.matched_count = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append('\x00' * 3)
-        packed.append(struct.pack("!L", self.active_count))
-        packed.append(struct.pack("!Q", self.lookup_count))
-        packed.append(struct.pack("!Q", self.matched_count))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_stats_entry()
-        obj.table_id = reader.read("!B")[0]
-        reader.skip(3)
-        obj.active_count = reader.read("!L")[0]
-        obj.lookup_count = reader.read("!Q")[0]
-        obj.matched_count = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.table_id != other.table_id: return False
-        if self.active_count != other.active_count: return False
-        if self.lookup_count != other.lookup_count: return False
-        if self.matched_count != other.matched_count: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("active_count = ");
-                q.text("%#x" % self.active_count)
-                q.text(","); q.breakable()
-                q.text("lookup_count = ");
-                q.text("%#x" % self.lookup_count)
-                q.text(","); q.breakable()
-                q.text("matched_count = ");
-                q.text("%#x" % self.matched_count)
-            q.breakable()
-        q.text('}')
-
-
-class uint32(loxi.OFObject):
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = uint32()
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("uint32 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-
-class uint64(loxi.OFObject):
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!Q", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = uint64()
-        obj.value = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("uint64 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-
-class uint8(loxi.OFObject):
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = uint8()
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("uint8 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-
-
-match = match_v3
diff --git a/python/ofagent/loxi/of13/const.py b/python/ofagent/loxi/of13/const.py
deleted file mode 100644
index 7a33f3e..0000000
--- a/python/ofagent/loxi/of13/const.py
+++ /dev/null
@@ -1,1425 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template const.py
-# Do not modify
-
-OFP_VERSION = 4
-
-# Identifiers from group macro_definitions
-OFP_MAX_TABLE_NAME_LEN = 32
-OFP_MAX_PORT_NAME_LEN = 16
-OFP_TCP_PORT = 6653
-OFP_SSL_PORT = 6653
-OFP_ETH_ALEN = 6
-OFP_DEFAULT_MISS_SEND_LEN = 128
-OFP_VLAN_NONE = 0
-OFP_FLOW_PERMANENT = 0
-OFP_DEFAULT_PRIORITY = 32768
-OFP_NO_BUFFER = 4294967295
-DESC_STR_LEN = 256
-SERIAL_NUM_LEN = 32
-OFPQ_ALL = 4294967295
-OFPQ_MAX_RATE_UNCFG = 65535
-OFPQ_MIN_RATE_UNCFG = 65535
-
-# Identifiers from group of_bsn_hash_packet_field
-OFP_BSN_HASH_FIELD_DISABLE = 1
-OFP_BSN_HASH_FIELD_DST_MAC = 2
-OFP_BSN_HASH_FIELD_SRC_MAC = 4
-OFP_BSN_HASH_FIELD_ETH_TYPE = 8
-OFP_BSN_HASH_FIELD_VLAN_ID = 16
-OFP_BSN_HASH_FIELD_INNER_L2 = 32
-OFP_BSN_HASH_FIELD_INNER_L3 = 64
-OFP_BSN_HASH_FIELD_SRC_IP = 128
-OFP_BSN_HASH_FIELD_DST_IP = 256
-OFP_BSN_HASH_FIELD_IP_PROTO = 512
-OFP_BSN_HASH_FIELD_SRC_L4_PORT = 1024
-OFP_BSN_HASH_FIELD_DST_L4_PORT = 2048
-OFP_BSN_HASH_FIELD_MPLS_LABEL1 = 4096
-OFP_BSN_HASH_FIELD_MPLS_LABEL2 = 8192
-OFP_BSN_HASH_FIELD_MPLS_LABEL3 = 16384
-OFP_BSN_HASH_FIELD_MPLS_LABEL_HI_BITS = 32768
-OFP_BSN_HASH_FIELD_MPLS_PAYLOAD_SRC_IP = 65536
-OFP_BSN_HASH_FIELD_MPLS_PAYLOAD_DST_IP = 131072
-OFP_BSN_HASH_FIELD_SYMMETRIC = 262144
-
-of_bsn_hash_packet_field_map = {
-    1: 'OFP_BSN_HASH_FIELD_DISABLE',
-    2: 'OFP_BSN_HASH_FIELD_DST_MAC',
-    4: 'OFP_BSN_HASH_FIELD_SRC_MAC',
-    8: 'OFP_BSN_HASH_FIELD_ETH_TYPE',
-    16: 'OFP_BSN_HASH_FIELD_VLAN_ID',
-    32: 'OFP_BSN_HASH_FIELD_INNER_L2',
-    64: 'OFP_BSN_HASH_FIELD_INNER_L3',
-    128: 'OFP_BSN_HASH_FIELD_SRC_IP',
-    256: 'OFP_BSN_HASH_FIELD_DST_IP',
-    512: 'OFP_BSN_HASH_FIELD_IP_PROTO',
-    1024: 'OFP_BSN_HASH_FIELD_SRC_L4_PORT',
-    2048: 'OFP_BSN_HASH_FIELD_DST_L4_PORT',
-    4096: 'OFP_BSN_HASH_FIELD_MPLS_LABEL1',
-    8192: 'OFP_BSN_HASH_FIELD_MPLS_LABEL2',
-    16384: 'OFP_BSN_HASH_FIELD_MPLS_LABEL3',
-    32768: 'OFP_BSN_HASH_FIELD_MPLS_LABEL_HI_BITS',
-    65536: 'OFP_BSN_HASH_FIELD_MPLS_PAYLOAD_SRC_IP',
-    131072: 'OFP_BSN_HASH_FIELD_MPLS_PAYLOAD_DST_IP',
-    262144: 'OFP_BSN_HASH_FIELD_SYMMETRIC',
-}
-
-# Identifiers from group of_bsn_hash_packet_type
-OF_BSN_HASH_PACKET_L2 = 0
-OF_BSN_HASH_PACKET_L2GRE = 1
-OF_BSN_HASH_PACKET_IPV4 = 3
-OF_BSN_HASH_PACKET_IPV6 = 4
-OF_BSN_HASH_PACKET_GTP = 5
-OF_BSN_HASH_PACKET_MPLS = 6
-OF_BSN_HASH_PACKET_SYMMETRIC = 7
-
-of_bsn_hash_packet_type_map = {
-    0: 'OF_BSN_HASH_PACKET_L2',
-    1: 'OF_BSN_HASH_PACKET_L2GRE',
-    3: 'OF_BSN_HASH_PACKET_IPV4',
-    4: 'OF_BSN_HASH_PACKET_IPV6',
-    5: 'OF_BSN_HASH_PACKET_GTP',
-    6: 'OF_BSN_HASH_PACKET_MPLS',
-    7: 'OF_BSN_HASH_PACKET_SYMMETRIC',
-}
-
-# Identifiers from group of_bsn_hash_type
-OFP_BSN_HASH_TYPE_L2 = 0
-OFP_BSN_HASH_TYPE_L3 = 1
-OFP_BSN_HASH_TYPE_ENHANCED = 2
-
-of_bsn_hash_type_map = {
-    0: 'OFP_BSN_HASH_TYPE_L2',
-    1: 'OFP_BSN_HASH_TYPE_L3',
-    2: 'OFP_BSN_HASH_TYPE_ENHANCED',
-}
-
-# Identifiers from group of_bsn_lacp_convergence_status
-LACP_SUCCESS = 0
-LACP_TIMEDOUT = 1
-LACP_OUT_OF_SYNC = 2
-
-of_bsn_lacp_convergence_status_map = {
-    0: 'LACP_SUCCESS',
-    1: 'LACP_TIMEDOUT',
-    2: 'LACP_OUT_OF_SYNC',
-}
-
-# Identifiers from group of_bsn_pdu_slot_num
-BSN_PDU_SLOT_NUM_ANY = 255
-
-of_bsn_pdu_slot_num_map = {
-    255: 'BSN_PDU_SLOT_NUM_ANY',
-}
-
-# Identifiers from group of_bsn_vlan_counter
-OFP_BSN_VLAN_COUNTER_RX_BYTES = 0
-OFP_BSN_VLAN_COUNTER_RX_PACKETS = 1
-OFP_BSN_VLAN_COUNTER_TX_BYTES = 2
-OFP_BSN_VLAN_COUNTER_TX_PACKETS = 3
-
-of_bsn_vlan_counter_map = {
-    0: 'OFP_BSN_VLAN_COUNTER_RX_BYTES',
-    1: 'OFP_BSN_VLAN_COUNTER_RX_PACKETS',
-    2: 'OFP_BSN_VLAN_COUNTER_TX_BYTES',
-    3: 'OFP_BSN_VLAN_COUNTER_TX_PACKETS',
-}
-
-# Identifiers from group of_bsn_vrf_counter
-OFP_BSN_VRF_COUNTER_BYTES = 0
-OFP_BSN_VRF_COUNTER_PACKETS = 1
-
-of_bsn_vrf_counter_map = {
-    0: 'OFP_BSN_VRF_COUNTER_BYTES',
-    1: 'OFP_BSN_VRF_COUNTER_PACKETS',
-}
-
-# Identifiers from group ofp_action_type
-OFPAT_OUTPUT = 0
-OFPAT_COPY_TTL_OUT = 11
-OFPAT_COPY_TTL_IN = 12
-OFPAT_SET_MPLS_TTL = 15
-OFPAT_DEC_MPLS_TTL = 16
-OFPAT_PUSH_VLAN = 17
-OFPAT_POP_VLAN = 18
-OFPAT_PUSH_MPLS = 19
-OFPAT_POP_MPLS = 20
-OFPAT_SET_QUEUE = 21
-OFPAT_GROUP = 22
-OFPAT_SET_NW_TTL = 23
-OFPAT_DEC_NW_TTL = 24
-OFPAT_SET_FIELD = 25
-OFPAT_PUSH_PBB = 26
-OFPAT_POP_PBB = 27
-OFPAT_EXPERIMENTER = 65535
-
-ofp_action_type_map = {
-    0: 'OFPAT_OUTPUT',
-    11: 'OFPAT_COPY_TTL_OUT',
-    12: 'OFPAT_COPY_TTL_IN',
-    15: 'OFPAT_SET_MPLS_TTL',
-    16: 'OFPAT_DEC_MPLS_TTL',
-    17: 'OFPAT_PUSH_VLAN',
-    18: 'OFPAT_POP_VLAN',
-    19: 'OFPAT_PUSH_MPLS',
-    20: 'OFPAT_POP_MPLS',
-    21: 'OFPAT_SET_QUEUE',
-    22: 'OFPAT_GROUP',
-    23: 'OFPAT_SET_NW_TTL',
-    24: 'OFPAT_DEC_NW_TTL',
-    25: 'OFPAT_SET_FIELD',
-    26: 'OFPAT_PUSH_PBB',
-    27: 'OFPAT_POP_PBB',
-    65535: 'OFPAT_EXPERIMENTER',
-}
-
-# Identifiers from group ofp_bad_action_code
-OFPBAC_BAD_TYPE = 0
-OFPBAC_BAD_LEN = 1
-OFPBAC_BAD_EXPERIMENTER = 2
-OFPBAC_BAD_EXPERIMENTER_TYPE = 3
-OFPBAC_BAD_OUT_PORT = 4
-OFPBAC_BAD_ARGUMENT = 5
-OFPBAC_EPERM = 6
-OFPBAC_TOO_MANY = 7
-OFPBAC_BAD_QUEUE = 8
-OFPBAC_BAD_OUT_GROUP = 9
-OFPBAC_MATCH_INCONSISTENT = 10
-OFPBAC_UNSUPPORTED_ORDER = 11
-OFPBAC_BAD_TAG = 12
-OFPBAC_BAD_SET_TYPE = 13
-OFPBAC_BAD_SET_LEN = 14
-OFPBAC_BAD_SET_ARGUMENT = 15
-
-ofp_bad_action_code_map = {
-    0: 'OFPBAC_BAD_TYPE',
-    1: 'OFPBAC_BAD_LEN',
-    2: 'OFPBAC_BAD_EXPERIMENTER',
-    3: 'OFPBAC_BAD_EXPERIMENTER_TYPE',
-    4: 'OFPBAC_BAD_OUT_PORT',
-    5: 'OFPBAC_BAD_ARGUMENT',
-    6: 'OFPBAC_EPERM',
-    7: 'OFPBAC_TOO_MANY',
-    8: 'OFPBAC_BAD_QUEUE',
-    9: 'OFPBAC_BAD_OUT_GROUP',
-    10: 'OFPBAC_MATCH_INCONSISTENT',
-    11: 'OFPBAC_UNSUPPORTED_ORDER',
-    12: 'OFPBAC_BAD_TAG',
-    13: 'OFPBAC_BAD_SET_TYPE',
-    14: 'OFPBAC_BAD_SET_LEN',
-    15: 'OFPBAC_BAD_SET_ARGUMENT',
-}
-
-# Identifiers from group ofp_bad_instruction_code
-OFPBIC_UNKNOWN_INST = 0
-OFPBIC_UNSUP_INST = 1
-OFPBIC_BAD_TABLE_ID = 2
-OFPBIC_UNSUP_METADATA = 3
-OFPBIC_UNSUP_METADATA_MASK = 4
-OFPBIC_BAD_EXPERIMENTER = 5
-OFPBIC_BAD_EXPERIMENTER_TYPE = 6
-OFPBIC_BAD_LEN = 7
-OFPBIC_EPERM = 8
-
-ofp_bad_instruction_code_map = {
-    0: 'OFPBIC_UNKNOWN_INST',
-    1: 'OFPBIC_UNSUP_INST',
-    2: 'OFPBIC_BAD_TABLE_ID',
-    3: 'OFPBIC_UNSUP_METADATA',
-    4: 'OFPBIC_UNSUP_METADATA_MASK',
-    5: 'OFPBIC_BAD_EXPERIMENTER',
-    6: 'OFPBIC_BAD_EXPERIMENTER_TYPE',
-    7: 'OFPBIC_BAD_LEN',
-    8: 'OFPBIC_EPERM',
-}
-
-# Identifiers from group ofp_bad_match_code
-OFPBMC_BAD_TYPE = 0
-OFPBMC_BAD_LEN = 1
-OFPBMC_BAD_TAG = 2
-OFPBMC_BAD_DL_ADDR_MASK = 3
-OFPBMC_BAD_NW_ADDR_MASK = 4
-OFPBMC_BAD_WILDCARDS = 5
-OFPBMC_BAD_FIELD = 6
-OFPBMC_BAD_VALUE = 7
-OFPBMC_BAD_MASK = 8
-OFPBMC_BAD_PREREQ = 9
-OFPBMC_DUP_FIELD = 10
-OFPBMC_EPERM = 11
-
-ofp_bad_match_code_map = {
-    0: 'OFPBMC_BAD_TYPE',
-    1: 'OFPBMC_BAD_LEN',
-    2: 'OFPBMC_BAD_TAG',
-    3: 'OFPBMC_BAD_DL_ADDR_MASK',
-    4: 'OFPBMC_BAD_NW_ADDR_MASK',
-    5: 'OFPBMC_BAD_WILDCARDS',
-    6: 'OFPBMC_BAD_FIELD',
-    7: 'OFPBMC_BAD_VALUE',
-    8: 'OFPBMC_BAD_MASK',
-    9: 'OFPBMC_BAD_PREREQ',
-    10: 'OFPBMC_DUP_FIELD',
-    11: 'OFPBMC_EPERM',
-}
-
-# Identifiers from group ofp_bad_request_code
-OFPBRC_BAD_VERSION = 0
-OFPBRC_BAD_TYPE = 1
-OFPBRC_BAD_STAT = 2
-OFPBRC_BAD_EXPERIMENTER = 3
-OFPBRC_BAD_EXPERIMENTER_TYPE = 4
-OFPBRC_EPERM = 5
-OFPBRC_BAD_LEN = 6
-OFPBRC_BUFFER_EMPTY = 7
-OFPBRC_BUFFER_UNKNOWN = 8
-OFPBRC_BAD_TABLE_ID = 9
-OFPBRC_IS_SLAVE = 10
-OFPBRC_BAD_PORT = 11
-OFPBRC_BAD_PACKET = 12
-OFPBRC_MULTIPART_BUFFER_OVERFLOW = 13
-
-ofp_bad_request_code_map = {
-    0: 'OFPBRC_BAD_VERSION',
-    1: 'OFPBRC_BAD_TYPE',
-    2: 'OFPBRC_BAD_STAT',
-    3: 'OFPBRC_BAD_EXPERIMENTER',
-    4: 'OFPBRC_BAD_EXPERIMENTER_TYPE',
-    5: 'OFPBRC_EPERM',
-    6: 'OFPBRC_BAD_LEN',
-    7: 'OFPBRC_BUFFER_EMPTY',
-    8: 'OFPBRC_BUFFER_UNKNOWN',
-    9: 'OFPBRC_BAD_TABLE_ID',
-    10: 'OFPBRC_IS_SLAVE',
-    11: 'OFPBRC_BAD_PORT',
-    12: 'OFPBRC_BAD_PACKET',
-    13: 'OFPBRC_MULTIPART_BUFFER_OVERFLOW',
-}
-
-# Identifiers from group ofp_bsn_anchor
-OFP_BSN_ANCHOR_PACKET_START = 0
-OFP_BSN_ANCHOR_L3_HEADER_START = 1
-OFP_BSN_ANCHOR_L4_HEADER_START = 2
-OFP_BSN_ANCHOR_L4_PAYLOAD_START = 3
-
-ofp_bsn_anchor_map = {
-    0: 'OFP_BSN_ANCHOR_PACKET_START',
-    1: 'OFP_BSN_ANCHOR_L3_HEADER_START',
-    2: 'OFP_BSN_ANCHOR_L4_HEADER_START',
-    3: 'OFP_BSN_ANCHOR_L4_PAYLOAD_START',
-}
-
-# Identifiers from group ofp_bsn_controller_connection_state
-OFP_BSN_CONTROLLER_CONNECTION_STATE_DISCONNECTED = 0
-OFP_BSN_CONTROLLER_CONNECTION_STATE_CONNECTED = 1
-
-ofp_bsn_controller_connection_state_map = {
-    0: 'OFP_BSN_CONTROLLER_CONNECTION_STATE_DISCONNECTED',
-    1: 'OFP_BSN_CONTROLLER_CONNECTION_STATE_CONNECTED',
-}
-
-# Identifiers from group ofp_bsn_controller_role_reason
-OFP_BSN_CONTROLLER_ROLE_REASON_MASTER_REQUEST = 0
-OFP_BSN_CONTROLLER_ROLE_REASON_CONFIG = 1
-OFP_BSN_CONTROLLER_ROLE_REASON_EXPERIMENTER = 2
-
-ofp_bsn_controller_role_reason_map = {
-    0: 'OFP_BSN_CONTROLLER_ROLE_REASON_MASTER_REQUEST',
-    1: 'OFP_BSN_CONTROLLER_ROLE_REASON_CONFIG',
-    2: 'OFP_BSN_CONTROLLER_ROLE_REASON_EXPERIMENTER',
-}
-
-# Identifiers from group ofp_bsn_decap
-OFP_BSN_DECAP_VXLAN = 0
-OFP_BSN_DECAP_ERSPAN = 1
-OFP_BSN_DECAP_L2_GRE = 2
-OFP_BSN_DECAP_NVGRE = 3
-OFP_BSN_DECAP_CAPWAP = 4
-OFP_BSN_DECAP_L2_MPLS = 5
-OFP_BSN_DECAP_L3_GRE = 6
-OFP_BSN_DECAP_GTP = 7
-OFP_BSN_DECAP_L3_MPLS = 8
-
-ofp_bsn_decap_map = {
-    0: 'OFP_BSN_DECAP_VXLAN',
-    1: 'OFP_BSN_DECAP_ERSPAN',
-    2: 'OFP_BSN_DECAP_L2_GRE',
-    3: 'OFP_BSN_DECAP_NVGRE',
-    4: 'OFP_BSN_DECAP_CAPWAP',
-    5: 'OFP_BSN_DECAP_L2_MPLS',
-    6: 'OFP_BSN_DECAP_L3_GRE',
-    7: 'OFP_BSN_DECAP_GTP',
-    8: 'OFP_BSN_DECAP_L3_MPLS',
-}
-
-# Identifiers from group ofp_bsn_lacp_state
-OFP_BSN_LACP_STATE_ACTIVITY = 1
-OFP_BSN_LACP_STATE_TIMEOUT = 2
-OFP_BSN_LACP_STATE_AGGREGATION = 4
-OFP_BSN_LACP_STATE_SYNCHRONIZATION = 8
-OFP_BSN_LACP_STATE_COLLECTING = 16
-OFP_BSN_LACP_STATE_DISTRIBUTING = 32
-OFP_BSN_LACP_STATE_DEFAULTED = 64
-OFP_BSN_LACP_STATE_EXPIRED = 128
-
-ofp_bsn_lacp_state_map = {
-    1: 'OFP_BSN_LACP_STATE_ACTIVITY',
-    2: 'OFP_BSN_LACP_STATE_TIMEOUT',
-    4: 'OFP_BSN_LACP_STATE_AGGREGATION',
-    8: 'OFP_BSN_LACP_STATE_SYNCHRONIZATION',
-    16: 'OFP_BSN_LACP_STATE_COLLECTING',
-    32: 'OFP_BSN_LACP_STATE_DISTRIBUTING',
-    64: 'OFP_BSN_LACP_STATE_DEFAULTED',
-    128: 'OFP_BSN_LACP_STATE_EXPIRED',
-}
-
-# Identifiers from group ofp_bsn_loglevel
-OFP_BSN_LOGLEVEL_MSG = 0
-OFP_BSN_LOGLEVEL_ERROR = 1
-OFP_BSN_LOGLEVEL_WARN = 2
-OFP_BSN_LOGLEVEL_INFO = 3
-OFP_BSN_LOGLEVEL_VERBOSE = 4
-OFP_BSN_LOGLEVEL_TRACE = 5
-
-ofp_bsn_loglevel_map = {
-    0: 'OFP_BSN_LOGLEVEL_MSG',
-    1: 'OFP_BSN_LOGLEVEL_ERROR',
-    2: 'OFP_BSN_LOGLEVEL_WARN',
-    3: 'OFP_BSN_LOGLEVEL_INFO',
-    4: 'OFP_BSN_LOGLEVEL_VERBOSE',
-    5: 'OFP_BSN_LOGLEVEL_TRACE',
-}
-
-# Identifiers from group ofp_bsn_lua_upload_flags
-OFP_BSN_LUA_UPLOAD_MORE = 1
-OFP_BSN_LUA_UPLOAD_FORCE = 2
-
-ofp_bsn_lua_upload_flags_map = {
-    1: 'OFP_BSN_LUA_UPLOAD_MORE',
-    2: 'OFP_BSN_LUA_UPLOAD_FORCE',
-}
-
-# Identifiers from group ofp_bsn_pktin_flag
-OFP_BSN_PKTIN_FLAG_PDU = 1
-OFP_BSN_PKTIN_FLAG_NEW_HOST = 2
-OFP_BSN_PKTIN_FLAG_STATION_MOVE = 4
-OFP_BSN_PKTIN_FLAG_ARP = 8
-OFP_BSN_PKTIN_FLAG_DHCP = 16
-OFP_BSN_PKTIN_FLAG_L2_CPU = 32
-OFP_BSN_PKTIN_FLAG_DEBUG = 64
-OFP_BSN_PKTIN_FLAG_TTL_EXPIRED = 128
-OFP_BSN_PKTIN_FLAG_L3_MISS = 256
-OFP_BSN_PKTIN_FLAG_L3_CPU = 512
-OFP_BSN_PKTIN_FLAG_INGRESS_ACL = 1024
-OFP_BSN_PKTIN_FLAG_SFLOW = 2048
-OFP_BSN_PKTIN_FLAG_ARP_CACHE = 4096
-OFP_BSN_PKTIN_FLAG_ARP_TARGET = 8192
-OFP_BSN_PKTIN_FLAG_IGMP = 16384
-OFP_BSN_PKTIN_FLAG_PIM = 32768
-OFP_BSN_PKTIN_FLAG_VXLAN_SIP_MISS = 65536
-OFP_BSN_PKTIN_FLAG_MC_RESERVED = 131072
-
-ofp_bsn_pktin_flag_map = {
-    1: 'OFP_BSN_PKTIN_FLAG_PDU',
-    2: 'OFP_BSN_PKTIN_FLAG_NEW_HOST',
-    4: 'OFP_BSN_PKTIN_FLAG_STATION_MOVE',
-    8: 'OFP_BSN_PKTIN_FLAG_ARP',
-    16: 'OFP_BSN_PKTIN_FLAG_DHCP',
-    32: 'OFP_BSN_PKTIN_FLAG_L2_CPU',
-    64: 'OFP_BSN_PKTIN_FLAG_DEBUG',
-    128: 'OFP_BSN_PKTIN_FLAG_TTL_EXPIRED',
-    256: 'OFP_BSN_PKTIN_FLAG_L3_MISS',
-    512: 'OFP_BSN_PKTIN_FLAG_L3_CPU',
-    1024: 'OFP_BSN_PKTIN_FLAG_INGRESS_ACL',
-    2048: 'OFP_BSN_PKTIN_FLAG_SFLOW',
-    4096: 'OFP_BSN_PKTIN_FLAG_ARP_CACHE',
-    8192: 'OFP_BSN_PKTIN_FLAG_ARP_TARGET',
-    16384: 'OFP_BSN_PKTIN_FLAG_IGMP',
-    32768: 'OFP_BSN_PKTIN_FLAG_PIM',
-    65536: 'OFP_BSN_PKTIN_FLAG_VXLAN_SIP_MISS',
-    131072: 'OFP_BSN_PKTIN_FLAG_MC_RESERVED',
-}
-
-# Identifiers from group ofp_bsn_port_counter
-OFP_BSN_PORT_COUNTER_RX_BYTES = 0
-OFP_BSN_PORT_COUNTER_RX_PACKETS_UNICAST = 1
-OFP_BSN_PORT_COUNTER_RX_PACKETS_BROADCAST = 2
-OFP_BSN_PORT_COUNTER_RX_PACKETS_MULTICAST = 3
-OFP_BSN_PORT_COUNTER_RX_DROPPED = 4
-OFP_BSN_PORT_COUNTER_RX_ERRORS = 5
-OFP_BSN_PORT_COUNTER_TX_BYTES = 6
-OFP_BSN_PORT_COUNTER_TX_PACKETS_UNICAST = 7
-OFP_BSN_PORT_COUNTER_TX_PACKETS_BROADCAST = 8
-OFP_BSN_PORT_COUNTER_TX_PACKETS_MULTICAST = 9
-OFP_BSN_PORT_COUNTER_TX_DROPPED = 10
-OFP_BSN_PORT_COUNTER_TX_ERRORS = 11
-OFP_BSN_PORT_COUNTER_RX_RUNTS = 12
-OFP_BSN_PORT_COUNTER_RX_GIANTS = 13
-OFP_BSN_PORT_COUNTER_RX_CRC_ERRORS = 14
-OFP_BSN_PORT_COUNTER_RX_ALIGNMENT_ERRORS = 15
-OFP_BSN_PORT_COUNTER_RX_SYMBOL_ERRORS = 16
-OFP_BSN_PORT_COUNTER_RX_PAUSE_INPUT = 17
-OFP_BSN_PORT_COUNTER_TX_COLLISIONS = 18
-OFP_BSN_PORT_COUNTER_TX_LATE_COLLISIONS = 19
-OFP_BSN_PORT_COUNTER_TX_DEFERRED = 20
-OFP_BSN_PORT_COUNTER_TX_PAUSE_OUTPUT = 21
-OFP_BSN_PORT_COUNTER_RX_PACKETS = 22
-OFP_BSN_PORT_COUNTER_TX_PACKETS = 23
-OFP_BSN_PORT_COUNTER_RX_LENGTH_ERRORS = 24
-OFP_BSN_PORT_COUNTER_RX_OVERFLOW_ERRORS = 25
-OFP_BSN_PORT_COUNTER_TX_CARRIER_ERRORS = 26
-OFP_BSN_PORT_COUNTER_RX_PACKETS_BAD_VLAN = 27
-OFP_BSN_PORT_COUNTER_LINK_UP = 28
-OFP_BSN_PORT_COUNTER_LINK_DOWN = 29
-
-ofp_bsn_port_counter_map = {
-    0: 'OFP_BSN_PORT_COUNTER_RX_BYTES',
-    1: 'OFP_BSN_PORT_COUNTER_RX_PACKETS_UNICAST',
-    2: 'OFP_BSN_PORT_COUNTER_RX_PACKETS_BROADCAST',
-    3: 'OFP_BSN_PORT_COUNTER_RX_PACKETS_MULTICAST',
-    4: 'OFP_BSN_PORT_COUNTER_RX_DROPPED',
-    5: 'OFP_BSN_PORT_COUNTER_RX_ERRORS',
-    6: 'OFP_BSN_PORT_COUNTER_TX_BYTES',
-    7: 'OFP_BSN_PORT_COUNTER_TX_PACKETS_UNICAST',
-    8: 'OFP_BSN_PORT_COUNTER_TX_PACKETS_BROADCAST',
-    9: 'OFP_BSN_PORT_COUNTER_TX_PACKETS_MULTICAST',
-    10: 'OFP_BSN_PORT_COUNTER_TX_DROPPED',
-    11: 'OFP_BSN_PORT_COUNTER_TX_ERRORS',
-    12: 'OFP_BSN_PORT_COUNTER_RX_RUNTS',
-    13: 'OFP_BSN_PORT_COUNTER_RX_GIANTS',
-    14: 'OFP_BSN_PORT_COUNTER_RX_CRC_ERRORS',
-    15: 'OFP_BSN_PORT_COUNTER_RX_ALIGNMENT_ERRORS',
-    16: 'OFP_BSN_PORT_COUNTER_RX_SYMBOL_ERRORS',
-    17: 'OFP_BSN_PORT_COUNTER_RX_PAUSE_INPUT',
-    18: 'OFP_BSN_PORT_COUNTER_TX_COLLISIONS',
-    19: 'OFP_BSN_PORT_COUNTER_TX_LATE_COLLISIONS',
-    20: 'OFP_BSN_PORT_COUNTER_TX_DEFERRED',
-    21: 'OFP_BSN_PORT_COUNTER_TX_PAUSE_OUTPUT',
-    22: 'OFP_BSN_PORT_COUNTER_RX_PACKETS',
-    23: 'OFP_BSN_PORT_COUNTER_TX_PACKETS',
-    24: 'OFP_BSN_PORT_COUNTER_RX_LENGTH_ERRORS',
-    25: 'OFP_BSN_PORT_COUNTER_RX_OVERFLOW_ERRORS',
-    26: 'OFP_BSN_PORT_COUNTER_TX_CARRIER_ERRORS',
-    27: 'OFP_BSN_PORT_COUNTER_RX_PACKETS_BAD_VLAN',
-    28: 'OFP_BSN_PORT_COUNTER_LINK_UP',
-    29: 'OFP_BSN_PORT_COUNTER_LINK_DOWN',
-}
-
-# Identifiers from group ofp_bsn_port_vxlan_mode
-OFP_BSN_PORT_VXLAN_RECIRCULATION_ENABLE = 0
-OFP_BSN_PORT_VXLAN_TERMINATION_ENABLE = 1
-
-ofp_bsn_port_vxlan_mode_map = {
-    0: 'OFP_BSN_PORT_VXLAN_RECIRCULATION_ENABLE',
-    1: 'OFP_BSN_PORT_VXLAN_TERMINATION_ENABLE',
-}
-
-# Identifiers from group ofp_bsn_rate_unit
-OFP_BSN_RATE_UNIT_PPS = 0
-OFP_BSN_RATE_UNIT_KBITPS = 1
-
-ofp_bsn_rate_unit_map = {
-    0: 'OFP_BSN_RATE_UNIT_PPS',
-    1: 'OFP_BSN_RATE_UNIT_KBITPS',
-}
-
-# Identifiers from group ofp_bsn_status
-OFP_BSN_STATUS_DISABLE = 0
-OFP_BSN_STATUS_ENABLE = 1
-
-ofp_bsn_status_map = {
-    0: 'OFP_BSN_STATUS_DISABLE',
-    1: 'OFP_BSN_STATUS_ENABLE',
-}
-
-# Identifiers from group ofp_bsn_tcp_flag
-OFP_BSN_TCP_FLAG_FIN = 1
-OFP_BSN_TCP_FLAG_SYN = 2
-OFP_BSN_TCP_FLAG_RST = 4
-OFP_BSN_TCP_FLAG_PSH = 8
-OFP_BSN_TCP_FLAG_ACK = 16
-OFP_BSN_TCP_FLAG_URG = 32
-OFP_BSN_TCP_FLAG_ECE = 64
-OFP_BSN_TCP_FLAG_CWR = 128
-OFP_BSN_TCP_FLAG_NS = 256
-
-ofp_bsn_tcp_flag_map = {
-    1: 'OFP_BSN_TCP_FLAG_FIN',
-    2: 'OFP_BSN_TCP_FLAG_SYN',
-    4: 'OFP_BSN_TCP_FLAG_RST',
-    8: 'OFP_BSN_TCP_FLAG_PSH',
-    16: 'OFP_BSN_TCP_FLAG_ACK',
-    32: 'OFP_BSN_TCP_FLAG_URG',
-    64: 'OFP_BSN_TCP_FLAG_ECE',
-    128: 'OFP_BSN_TCP_FLAG_CWR',
-    256: 'OFP_BSN_TCP_FLAG_NS',
-}
-
-# Identifiers from group ofp_bsn_udf_anchor
-OFP_BSN_UDF_ANCHOR_PACKET_START = 0
-OFP_BSN_UDF_ANCHOR_L3_HEADER_START = 1
-OFP_BSN_UDF_ANCHOR_L4_HEADER_START = 2
-
-ofp_bsn_udf_anchor_map = {
-    0: 'OFP_BSN_UDF_ANCHOR_PACKET_START',
-    1: 'OFP_BSN_UDF_ANCHOR_L3_HEADER_START',
-    2: 'OFP_BSN_UDF_ANCHOR_L4_HEADER_START',
-}
-
-# Identifiers from group ofp_bsn_vlan_counter_constants
-OFP_BSN_VLAN_ALL = 65535
-
-ofp_bsn_vlan_counter_constants_map = {
-    65535: 'OFP_BSN_VLAN_ALL',
-}
-
-# Identifiers from group ofp_bsn_vport_l2gre_flags
-OF_BSN_VPORT_L2GRE_LOCAL_MAC_IS_VALID = 1
-OF_BSN_VPORT_L2GRE_DSCP_ASSIGN = 2
-OF_BSN_VPORT_L2GRE_DSCP_COPY = 4
-OF_BSN_VPORT_L2GRE_LOOPBACK_IS_VALID = 8
-OF_BSN_VPORT_L2GRE_RATE_LIMIT_IS_VALID = 16
-
-ofp_bsn_vport_l2gre_flags_map = {
-    1: 'OF_BSN_VPORT_L2GRE_LOCAL_MAC_IS_VALID',
-    2: 'OF_BSN_VPORT_L2GRE_DSCP_ASSIGN',
-    4: 'OF_BSN_VPORT_L2GRE_DSCP_COPY',
-    8: 'OF_BSN_VPORT_L2GRE_LOOPBACK_IS_VALID',
-    16: 'OF_BSN_VPORT_L2GRE_RATE_LIMIT_IS_VALID',
-}
-
-# Identifiers from group ofp_bsn_vport_q_in_q_untagged
-OF_BSN_VPORT_Q_IN_Q_UNTAGGED = 65535
-
-ofp_bsn_vport_q_in_q_untagged_map = {
-    65535: 'OF_BSN_VPORT_Q_IN_Q_UNTAGGED',
-}
-
-# Identifiers from group ofp_bsn_vport_status
-OF_BSN_VPORT_STATUS_OK = 0
-OF_BSN_VPORT_STATUS_FAILED = 1
-
-ofp_bsn_vport_status_map = {
-    0: 'OF_BSN_VPORT_STATUS_OK',
-    1: 'OF_BSN_VPORT_STATUS_FAILED',
-}
-
-# Identifiers from group ofp_bsn_vrf_counter_constants
-OFP_BSN_VRF_ALL = 4294967295
-
-ofp_bsn_vrf_counter_constants_map = {
-    4294967295: 'OFP_BSN_VRF_ALL',
-}
-
-# Identifiers from group ofp_capabilities
-OFPC_FLOW_STATS = 1
-OFPC_TABLE_STATS = 2
-OFPC_PORT_STATS = 4
-OFPC_GROUP_STATS = 8
-OFPC_IP_REASM = 32
-OFPC_QUEUE_STATS = 64
-OFPC_PORT_BLOCKED = 256
-
-ofp_capabilities_map = {
-    1: 'OFPC_FLOW_STATS',
-    2: 'OFPC_TABLE_STATS',
-    4: 'OFPC_PORT_STATS',
-    8: 'OFPC_GROUP_STATS',
-    32: 'OFPC_IP_REASM',
-    64: 'OFPC_QUEUE_STATS',
-    256: 'OFPC_PORT_BLOCKED',
-}
-
-# Identifiers from group ofp_config_flags
-OFPC_FRAG_NORMAL = 0
-OFPC_FRAG_DROP = 1
-OFPC_FRAG_REASM = 2
-OFPC_FRAG_MASK = 3
-
-ofp_config_flags_map = {
-    0: 'OFPC_FRAG_NORMAL',
-    1: 'OFPC_FRAG_DROP',
-    2: 'OFPC_FRAG_REASM',
-    3: 'OFPC_FRAG_MASK',
-}
-
-# Identifiers from group ofp_controller_max_len
-OFPCML_MAX = 65509
-OFPCML_NO_BUFFER = 65535
-
-ofp_controller_max_len_map = {
-    65509: 'OFPCML_MAX',
-    65535: 'OFPCML_NO_BUFFER',
-}
-
-# Identifiers from group ofp_controller_role
-OFPCR_ROLE_NOCHANGE = 0
-OFPCR_ROLE_EQUAL = 1
-OFPCR_ROLE_MASTER = 2
-OFPCR_ROLE_SLAVE = 3
-
-ofp_controller_role_map = {
-    0: 'OFPCR_ROLE_NOCHANGE',
-    1: 'OFPCR_ROLE_EQUAL',
-    2: 'OFPCR_ROLE_MASTER',
-    3: 'OFPCR_ROLE_SLAVE',
-}
-
-# Identifiers from group ofp_error_type
-OFPET_HELLO_FAILED = 0
-OFPET_BAD_REQUEST = 1
-OFPET_BAD_ACTION = 2
-OFPET_BAD_INSTRUCTION = 3
-OFPET_BAD_MATCH = 4
-OFPET_FLOW_MOD_FAILED = 5
-OFPET_GROUP_MOD_FAILED = 6
-OFPET_PORT_MOD_FAILED = 7
-OFPET_TABLE_MOD_FAILED = 8
-OFPET_QUEUE_OP_FAILED = 9
-OFPET_SWITCH_CONFIG_FAILED = 10
-OFPET_ROLE_REQUEST_FAILED = 11
-OFPET_METER_MOD_FAILED = 12
-OFPET_TABLE_FEATURES_FAILED = 13
-OFPET_EXPERIMENTER = 65535
-
-ofp_error_type_map = {
-    0: 'OFPET_HELLO_FAILED',
-    1: 'OFPET_BAD_REQUEST',
-    2: 'OFPET_BAD_ACTION',
-    3: 'OFPET_BAD_INSTRUCTION',
-    4: 'OFPET_BAD_MATCH',
-    5: 'OFPET_FLOW_MOD_FAILED',
-    6: 'OFPET_GROUP_MOD_FAILED',
-    7: 'OFPET_PORT_MOD_FAILED',
-    8: 'OFPET_TABLE_MOD_FAILED',
-    9: 'OFPET_QUEUE_OP_FAILED',
-    10: 'OFPET_SWITCH_CONFIG_FAILED',
-    11: 'OFPET_ROLE_REQUEST_FAILED',
-    12: 'OFPET_METER_MOD_FAILED',
-    13: 'OFPET_TABLE_FEATURES_FAILED',
-    65535: 'OFPET_EXPERIMENTER',
-}
-
-# Identifiers from group ofp_flow_mod_command
-OFPFC_ADD = 0
-OFPFC_MODIFY = 1
-OFPFC_MODIFY_STRICT = 2
-OFPFC_DELETE = 3
-OFPFC_DELETE_STRICT = 4
-
-ofp_flow_mod_command_map = {
-    0: 'OFPFC_ADD',
-    1: 'OFPFC_MODIFY',
-    2: 'OFPFC_MODIFY_STRICT',
-    3: 'OFPFC_DELETE',
-    4: 'OFPFC_DELETE_STRICT',
-}
-
-# Identifiers from group ofp_flow_mod_failed_code
-OFPFMFC_UNKNOWN = 0
-OFPFMFC_TABLE_FULL = 1
-OFPFMFC_BAD_TABLE_ID = 2
-OFPFMFC_OVERLAP = 3
-OFPFMFC_EPERM = 4
-OFPFMFC_BAD_TIMEOUT = 5
-OFPFMFC_BAD_COMMAND = 6
-OFPFMFC_BAD_FLAGS = 7
-
-ofp_flow_mod_failed_code_map = {
-    0: 'OFPFMFC_UNKNOWN',
-    1: 'OFPFMFC_TABLE_FULL',
-    2: 'OFPFMFC_BAD_TABLE_ID',
-    3: 'OFPFMFC_OVERLAP',
-    4: 'OFPFMFC_EPERM',
-    5: 'OFPFMFC_BAD_TIMEOUT',
-    6: 'OFPFMFC_BAD_COMMAND',
-    7: 'OFPFMFC_BAD_FLAGS',
-}
-
-# Identifiers from group ofp_flow_mod_flags
-OFPFF_SEND_FLOW_REM = 1
-OFPFF_CHECK_OVERLAP = 2
-OFPFF_RESET_COUNTS = 4
-OFPFF_NO_PKT_COUNTS = 8
-OFPFF_NO_BYT_COUNTS = 16
-OFPFF_BSN_SEND_IDLE = 128
-
-ofp_flow_mod_flags_map = {
-    1: 'OFPFF_SEND_FLOW_REM',
-    2: 'OFPFF_CHECK_OVERLAP',
-    4: 'OFPFF_RESET_COUNTS',
-    8: 'OFPFF_NO_PKT_COUNTS',
-    16: 'OFPFF_NO_BYT_COUNTS',
-    128: 'OFPFF_BSN_SEND_IDLE',
-}
-
-# Identifiers from group ofp_flow_removed_reason
-OFPRR_IDLE_TIMEOUT = 0
-OFPRR_HARD_TIMEOUT = 1
-OFPRR_DELETE = 2
-OFPRR_GROUP_DELETE = 3
-
-ofp_flow_removed_reason_map = {
-    0: 'OFPRR_IDLE_TIMEOUT',
-    1: 'OFPRR_HARD_TIMEOUT',
-    2: 'OFPRR_DELETE',
-    3: 'OFPRR_GROUP_DELETE',
-}
-
-# Identifiers from group ofp_group
-OFPG_MAX = 4294967040
-OFPG_ALL = 4294967292
-OFPG_ANY = 4294967295
-
-ofp_group_map = {
-    4294967040: 'OFPG_MAX',
-    4294967292: 'OFPG_ALL',
-    4294967295: 'OFPG_ANY',
-}
-
-# Identifiers from group ofp_group_capabilities
-OFPGFC_SELECT_WEIGHT = 1
-OFPGFC_SELECT_LIVENESS = 2
-OFPGFC_CHAINING = 4
-OFPGFC_CHAINING_CHECKS = 8
-
-ofp_group_capabilities_map = {
-    1: 'OFPGFC_SELECT_WEIGHT',
-    2: 'OFPGFC_SELECT_LIVENESS',
-    4: 'OFPGFC_CHAINING',
-    8: 'OFPGFC_CHAINING_CHECKS',
-}
-
-# Identifiers from group ofp_group_mod_command
-OFPGC_ADD = 0
-OFPGC_MODIFY = 1
-OFPGC_DELETE = 2
-
-ofp_group_mod_command_map = {
-    0: 'OFPGC_ADD',
-    1: 'OFPGC_MODIFY',
-    2: 'OFPGC_DELETE',
-}
-
-# Identifiers from group ofp_group_mod_failed_code
-OFPGMFC_GROUP_EXISTS = 0
-OFPGMFC_INVALID_GROUP = 1
-OFPGMFC_WEIGHT_UNSUPPORTED = 2
-OFPGMFC_OUT_OF_GROUPS = 3
-OFPGMFC_OUT_OF_BUCKETS = 4
-OFPGMFC_CHAINING_UNSUPPORTED = 5
-OFPGMFC_WATCH_UNSUPPORTED = 6
-OFPGMFC_LOOP = 7
-OFPGMFC_UNKNOWN_GROUP = 8
-OFPGMFC_CHAINED_GROUP = 9
-OFPGMFC_BAD_TYPE = 10
-OFPGMFC_BAD_COMMAND = 11
-OFPGMFC_BAD_BUCKET = 12
-OFPGMFC_BAD_WATCH = 13
-OFPGMFC_EPERM = 14
-
-ofp_group_mod_failed_code_map = {
-    0: 'OFPGMFC_GROUP_EXISTS',
-    1: 'OFPGMFC_INVALID_GROUP',
-    2: 'OFPGMFC_WEIGHT_UNSUPPORTED',
-    3: 'OFPGMFC_OUT_OF_GROUPS',
-    4: 'OFPGMFC_OUT_OF_BUCKETS',
-    5: 'OFPGMFC_CHAINING_UNSUPPORTED',
-    6: 'OFPGMFC_WATCH_UNSUPPORTED',
-    7: 'OFPGMFC_LOOP',
-    8: 'OFPGMFC_UNKNOWN_GROUP',
-    9: 'OFPGMFC_CHAINED_GROUP',
-    10: 'OFPGMFC_BAD_TYPE',
-    11: 'OFPGMFC_BAD_COMMAND',
-    12: 'OFPGMFC_BAD_BUCKET',
-    13: 'OFPGMFC_BAD_WATCH',
-    14: 'OFPGMFC_EPERM',
-}
-
-# Identifiers from group ofp_group_type
-OFPGT_ALL = 0
-OFPGT_SELECT = 1
-OFPGT_INDIRECT = 2
-OFPGT_FF = 3
-
-ofp_group_type_map = {
-    0: 'OFPGT_ALL',
-    1: 'OFPGT_SELECT',
-    2: 'OFPGT_INDIRECT',
-    3: 'OFPGT_FF',
-}
-
-# Identifiers from group ofp_hello_elem_type
-OFPHET_VERSIONBITMAP = 1
-
-ofp_hello_elem_type_map = {
-    1: 'OFPHET_VERSIONBITMAP',
-}
-
-# Identifiers from group ofp_hello_failed_code
-OFPHFC_INCOMPATIBLE = 0
-OFPHFC_EPERM = 1
-
-ofp_hello_failed_code_map = {
-    0: 'OFPHFC_INCOMPATIBLE',
-    1: 'OFPHFC_EPERM',
-}
-
-# Identifiers from group ofp_instruction_type
-OFPIT_GOTO_TABLE = 1
-OFPIT_WRITE_METADATA = 2
-OFPIT_WRITE_ACTIONS = 3
-OFPIT_APPLY_ACTIONS = 4
-OFPIT_CLEAR_ACTIONS = 5
-OFPIT_METER = 6
-OFPIT_EXPERIMENTER = 65535
-
-ofp_instruction_type_map = {
-    1: 'OFPIT_GOTO_TABLE',
-    2: 'OFPIT_WRITE_METADATA',
-    3: 'OFPIT_WRITE_ACTIONS',
-    4: 'OFPIT_APPLY_ACTIONS',
-    5: 'OFPIT_CLEAR_ACTIONS',
-    6: 'OFPIT_METER',
-    65535: 'OFPIT_EXPERIMENTER',
-}
-
-# Identifiers from group ofp_ipv6exthdr_flags
-OFPIEH_NONEXT = 1
-OFPIEH_ESP = 2
-OFPIEH_AUTH = 4
-OFPIEH_DEST = 8
-OFPIEH_FRAG = 16
-OFPIEH_ROUTER = 32
-OFPIEH_HOP = 64
-OFPIEH_UNREP = 128
-OFPIEH_UNSEQ = 256
-
-ofp_ipv6exthdr_flags_map = {
-    1: 'OFPIEH_NONEXT',
-    2: 'OFPIEH_ESP',
-    4: 'OFPIEH_AUTH',
-    8: 'OFPIEH_DEST',
-    16: 'OFPIEH_FRAG',
-    32: 'OFPIEH_ROUTER',
-    64: 'OFPIEH_HOP',
-    128: 'OFPIEH_UNREP',
-    256: 'OFPIEH_UNSEQ',
-}
-
-# Identifiers from group ofp_match_type
-OFPMT_STANDARD = 0
-OFPMT_OXM = 1
-
-ofp_match_type_map = {
-    0: 'OFPMT_STANDARD',
-    1: 'OFPMT_OXM',
-}
-
-# Identifiers from group ofp_meter
-OFPM_MAX = 4294901760
-OFPM_SLOWPATH = 4294967293
-OFPM_CONTROLLER = 4294967294
-OFPM_ALL = 4294967295
-
-ofp_meter_map = {
-    4294901760: 'OFPM_MAX',
-    4294967293: 'OFPM_SLOWPATH',
-    4294967294: 'OFPM_CONTROLLER',
-    4294967295: 'OFPM_ALL',
-}
-
-# Identifiers from group ofp_meter_band_type
-OFPMBT_DROP = 1
-OFPMBT_DSCP_REMARK = 2
-OFPMBT_EXPERIMENTER = 65535
-
-ofp_meter_band_type_map = {
-    1: 'OFPMBT_DROP',
-    2: 'OFPMBT_DSCP_REMARK',
-    65535: 'OFPMBT_EXPERIMENTER',
-}
-
-# Identifiers from group ofp_meter_flags
-OFPMF_KBPS = 1
-OFPMF_PKTPS = 2
-OFPMF_BURST = 4
-OFPMF_STATS = 8
-
-ofp_meter_flags_map = {
-    1: 'OFPMF_KBPS',
-    2: 'OFPMF_PKTPS',
-    4: 'OFPMF_BURST',
-    8: 'OFPMF_STATS',
-}
-
-# Identifiers from group ofp_meter_mod_command
-OFPMC_ADD = 0
-OFPMC_MODIFY = 1
-OFPMC_DELETE = 2
-
-ofp_meter_mod_command_map = {
-    0: 'OFPMC_ADD',
-    1: 'OFPMC_MODIFY',
-    2: 'OFPMC_DELETE',
-}
-
-# Identifiers from group ofp_meter_mod_failed_code
-OFPMMFC_UNKNOWN = 0
-OFPMMFC_METER_EXISTS = 1
-OFPMMFC_INVALID_METER = 2
-OFPMMFC_UNKNOWN_METER = 3
-OFPMMFC_BAD_COMMAND = 4
-OFPMMFC_BAD_FLAGS = 5
-OFPMMFC_BAD_RATE = 6
-OFPMMFC_BAD_BURST = 7
-OFPMMFC_BAD_BAND = 8
-OFPMMFC_BAD_BAND_VALUE = 9
-OFPMMFC_OUT_OF_METERS = 10
-OFPMMFC_OUT_OF_BANDS = 11
-
-ofp_meter_mod_failed_code_map = {
-    0: 'OFPMMFC_UNKNOWN',
-    1: 'OFPMMFC_METER_EXISTS',
-    2: 'OFPMMFC_INVALID_METER',
-    3: 'OFPMMFC_UNKNOWN_METER',
-    4: 'OFPMMFC_BAD_COMMAND',
-    5: 'OFPMMFC_BAD_FLAGS',
-    6: 'OFPMMFC_BAD_RATE',
-    7: 'OFPMMFC_BAD_BURST',
-    8: 'OFPMMFC_BAD_BAND',
-    9: 'OFPMMFC_BAD_BAND_VALUE',
-    10: 'OFPMMFC_OUT_OF_METERS',
-    11: 'OFPMMFC_OUT_OF_BANDS',
-}
-
-# Identifiers from group ofp_oxm_class
-OFPXMC_NXM_0 = 0
-OFPXMC_NXM_1 = 1
-OFPXMC_OPENFLOW_BASIC = 32768
-OFPXMC_EXPERIMENTER = 65535
-
-ofp_oxm_class_map = {
-    0: 'OFPXMC_NXM_0',
-    1: 'OFPXMC_NXM_1',
-    32768: 'OFPXMC_OPENFLOW_BASIC',
-    65535: 'OFPXMC_EXPERIMENTER',
-}
-
-# Identifiers from group ofp_packet_in_reason
-OFPR_NO_MATCH = 0
-OFPR_ACTION = 1
-OFPR_INVALID_TTL = 2
-OFPR_BSN_NEW_HOST = 128
-OFPR_BSN_STATION_MOVE = 129
-OFPR_BSN_BAD_VLAN = 130
-OFPR_BSN_DESTINATION_LOOKUP_FAILURE = 131
-OFPR_BSN_NO_ROUTE = 132
-OFPR_BSN_ICMP_ECHO_REQUEST = 133
-OFPR_BSN_DEST_NETWORK_UNREACHABLE = 134
-OFPR_BSN_DEST_HOST_UNREACHABLE = 135
-OFPR_BSN_DEST_PORT_UNREACHABLE = 136
-OFPR_BSN_FRAGMENTATION_REQUIRED = 137
-OFPR_BSN_ARP = 139
-OFPR_BSN_DHCP = 140
-OFPR_BSN_DEBUG = 141
-OFPR_BSN_PACKET_OF_DEATH = 142
-
-ofp_packet_in_reason_map = {
-    0: 'OFPR_NO_MATCH',
-    1: 'OFPR_ACTION',
-    2: 'OFPR_INVALID_TTL',
-    128: 'OFPR_BSN_NEW_HOST',
-    129: 'OFPR_BSN_STATION_MOVE',
-    130: 'OFPR_BSN_BAD_VLAN',
-    131: 'OFPR_BSN_DESTINATION_LOOKUP_FAILURE',
-    132: 'OFPR_BSN_NO_ROUTE',
-    133: 'OFPR_BSN_ICMP_ECHO_REQUEST',
-    134: 'OFPR_BSN_DEST_NETWORK_UNREACHABLE',
-    135: 'OFPR_BSN_DEST_HOST_UNREACHABLE',
-    136: 'OFPR_BSN_DEST_PORT_UNREACHABLE',
-    137: 'OFPR_BSN_FRAGMENTATION_REQUIRED',
-    139: 'OFPR_BSN_ARP',
-    140: 'OFPR_BSN_DHCP',
-    141: 'OFPR_BSN_DEBUG',
-    142: 'OFPR_BSN_PACKET_OF_DEATH',
-}
-
-# Identifiers from group ofp_port
-OFPP_MAX = 4294967040
-OFPP_IN_PORT = 4294967288
-OFPP_TABLE = 4294967289
-OFPP_NORMAL = 4294967290
-OFPP_FLOOD = 4294967291
-OFPP_ALL = 4294967292
-OFPP_CONTROLLER = 4294967293
-OFPP_LOCAL = 4294967294
-OFPP_ANY = 4294967295
-
-ofp_port_map = {
-    4294967040: 'OFPP_MAX',
-    4294967288: 'OFPP_IN_PORT',
-    4294967289: 'OFPP_TABLE',
-    4294967290: 'OFPP_NORMAL',
-    4294967291: 'OFPP_FLOOD',
-    4294967292: 'OFPP_ALL',
-    4294967293: 'OFPP_CONTROLLER',
-    4294967294: 'OFPP_LOCAL',
-    4294967295: 'OFPP_ANY',
-}
-
-# Identifiers from group ofp_port_config
-OFPPC_PORT_DOWN = 1
-OFPPC_NO_RECV = 4
-OFPPC_NO_FWD = 32
-OFPPC_NO_PACKET_IN = 64
-OFPPC_BSN_MIRROR_DEST = 2147483648
-
-ofp_port_config_map = {
-    1: 'OFPPC_PORT_DOWN',
-    4: 'OFPPC_NO_RECV',
-    32: 'OFPPC_NO_FWD',
-    64: 'OFPPC_NO_PACKET_IN',
-    2147483648: 'OFPPC_BSN_MIRROR_DEST',
-}
-
-# Identifiers from group ofp_port_features
-OFPPF_10MB_HD = 1
-OFPPF_10MB_FD = 2
-OFPPF_100MB_HD = 4
-OFPPF_100MB_FD = 8
-OFPPF_1GB_HD = 16
-OFPPF_1GB_FD = 32
-OFPPF_10GB_FD = 64
-OFPPF_40GB_FD = 128
-OFPPF_100GB_FD = 256
-OFPPF_1TB_FD = 512
-OFPPF_OTHER = 1024
-OFPPF_COPPER = 2048
-OFPPF_FIBER = 4096
-OFPPF_AUTONEG = 8192
-OFPPF_PAUSE = 16384
-OFPPF_PAUSE_ASYM = 32768
-OFPPF_BSN_BREAKOUT_CAPABLE = 2147483648
-
-ofp_port_features_map = {
-    1: 'OFPPF_10MB_HD',
-    2: 'OFPPF_10MB_FD',
-    4: 'OFPPF_100MB_HD',
-    8: 'OFPPF_100MB_FD',
-    16: 'OFPPF_1GB_HD',
-    32: 'OFPPF_1GB_FD',
-    64: 'OFPPF_10GB_FD',
-    128: 'OFPPF_40GB_FD',
-    256: 'OFPPF_100GB_FD',
-    512: 'OFPPF_1TB_FD',
-    1024: 'OFPPF_OTHER',
-    2048: 'OFPPF_COPPER',
-    4096: 'OFPPF_FIBER',
-    8192: 'OFPPF_AUTONEG',
-    16384: 'OFPPF_PAUSE',
-    32768: 'OFPPF_PAUSE_ASYM',
-    2147483648: 'OFPPF_BSN_BREAKOUT_CAPABLE',
-}
-
-# Identifiers from group ofp_port_mod_failed_code
-OFPPMFC_BAD_PORT = 0
-OFPPMFC_BAD_HW_ADDR = 1
-OFPPMFC_BAD_CONFIG = 2
-OFPPMFC_BAD_ADVERTISE = 3
-OFPPMFC_EPERM = 4
-
-ofp_port_mod_failed_code_map = {
-    0: 'OFPPMFC_BAD_PORT',
-    1: 'OFPPMFC_BAD_HW_ADDR',
-    2: 'OFPPMFC_BAD_CONFIG',
-    3: 'OFPPMFC_BAD_ADVERTISE',
-    4: 'OFPPMFC_EPERM',
-}
-
-# Identifiers from group ofp_port_reason
-OFPPR_ADD = 0
-OFPPR_DELETE = 1
-OFPPR_MODIFY = 2
-
-ofp_port_reason_map = {
-    0: 'OFPPR_ADD',
-    1: 'OFPPR_DELETE',
-    2: 'OFPPR_MODIFY',
-}
-
-# Identifiers from group ofp_port_state
-OFPPS_LINK_DOWN = 1
-OFPPS_BLOCKED = 2
-OFPPS_LIVE = 4
-
-ofp_port_state_map = {
-    1: 'OFPPS_LINK_DOWN',
-    2: 'OFPPS_BLOCKED',
-    4: 'OFPPS_LIVE',
-}
-
-# Identifiers from group ofp_queue_op_failed_code
-OFPQOFC_BAD_PORT = 0
-OFPQOFC_BAD_QUEUE = 1
-OFPQOFC_EPERM = 2
-
-ofp_queue_op_failed_code_map = {
-    0: 'OFPQOFC_BAD_PORT',
-    1: 'OFPQOFC_BAD_QUEUE',
-    2: 'OFPQOFC_EPERM',
-}
-
-# Identifiers from group ofp_queue_properties
-OFPQT_MIN_RATE = 1
-OFPQT_MAX_RATE = 2
-OFPQT_EXPERIMENTER = 65535
-
-ofp_queue_properties_map = {
-    1: 'OFPQT_MIN_RATE',
-    2: 'OFPQT_MAX_RATE',
-    65535: 'OFPQT_EXPERIMENTER',
-}
-
-# Identifiers from group ofp_role_request_failed_code
-OFPRRFC_STALE = 0
-OFPRRFC_UNSUP = 1
-OFPRRFC_BAD_ROLE = 2
-
-ofp_role_request_failed_code_map = {
-    0: 'OFPRRFC_STALE',
-    1: 'OFPRRFC_UNSUP',
-    2: 'OFPRRFC_BAD_ROLE',
-}
-
-# Identifiers from group ofp_stats_reply_flags
-OFPSF_REPLY_MORE = 1
-
-ofp_stats_reply_flags_map = {
-    1: 'OFPSF_REPLY_MORE',
-}
-
-# Identifiers from group ofp_stats_request_flags
-OFPSF_REQ_MORE = 1
-
-ofp_stats_request_flags_map = {
-    1: 'OFPSF_REQ_MORE',
-}
-
-# Identifiers from group ofp_stats_type
-OFPST_DESC = 0
-OFPST_FLOW = 1
-OFPST_AGGREGATE = 2
-OFPST_TABLE = 3
-OFPST_PORT = 4
-OFPST_QUEUE = 5
-OFPST_GROUP = 6
-OFPST_GROUP_DESC = 7
-OFPST_GROUP_FEATURES = 8
-OFPST_METER = 9
-OFPST_METER_CONFIG = 10
-OFPST_METER_FEATURES = 11
-OFPST_TABLE_FEATURES = 12
-OFPST_PORT_DESC = 13
-OFPST_EXPERIMENTER = 65535
-
-ofp_stats_type_map = {
-    0: 'OFPST_DESC',
-    1: 'OFPST_FLOW',
-    2: 'OFPST_AGGREGATE',
-    3: 'OFPST_TABLE',
-    4: 'OFPST_PORT',
-    5: 'OFPST_QUEUE',
-    6: 'OFPST_GROUP',
-    7: 'OFPST_GROUP_DESC',
-    8: 'OFPST_GROUP_FEATURES',
-    9: 'OFPST_METER',
-    10: 'OFPST_METER_CONFIG',
-    11: 'OFPST_METER_FEATURES',
-    12: 'OFPST_TABLE_FEATURES',
-    13: 'OFPST_PORT_DESC',
-    65535: 'OFPST_EXPERIMENTER',
-}
-
-# Identifiers from group ofp_switch_config_failed_code
-OFPSCFC_BAD_FLAGS = 0
-OFPSCFC_BAD_LEN = 1
-OFPSCFC_EPERM = 2
-
-ofp_switch_config_failed_code_map = {
-    0: 'OFPSCFC_BAD_FLAGS',
-    1: 'OFPSCFC_BAD_LEN',
-    2: 'OFPSCFC_EPERM',
-}
-
-# Identifiers from group ofp_table
-OFPTT_MAX = 254
-OFPTT_ALL = 255
-
-ofp_table_map = {
-    254: 'OFPTT_MAX',
-    255: 'OFPTT_ALL',
-}
-
-# Identifiers from group ofp_table_config
-OFPTC_DEPRECATED_MASK = 3
-
-ofp_table_config_map = {
-    3: 'OFPTC_DEPRECATED_MASK',
-}
-
-# Identifiers from group ofp_table_feature_prop_type
-OFPTFPT_INSTRUCTIONS = 0
-OFPTFPT_INSTRUCTIONS_MISS = 1
-OFPTFPT_NEXT_TABLES = 2
-OFPTFPT_NEXT_TABLES_MISS = 3
-OFPTFPT_WRITE_ACTIONS = 4
-OFPTFPT_WRITE_ACTIONS_MISS = 5
-OFPTFPT_APPLY_ACTIONS = 6
-OFPTFPT_APPLY_ACTIONS_MISS = 7
-OFPTFPT_MATCH = 8
-OFPTFPT_WILDCARDS = 10
-OFPTFPT_WRITE_SETFIELD = 12
-OFPTFPT_WRITE_SETFIELD_MISS = 13
-OFPTFPT_APPLY_SETFIELD = 14
-OFPTFPT_APPLY_SETFIELD_MISS = 15
-OFPTFPT_EXPERIMENTER = 65534
-OFPTFPT_EXPERIMENTER_MISS = 65535
-
-ofp_table_feature_prop_type_map = {
-    0: 'OFPTFPT_INSTRUCTIONS',
-    1: 'OFPTFPT_INSTRUCTIONS_MISS',
-    2: 'OFPTFPT_NEXT_TABLES',
-    3: 'OFPTFPT_NEXT_TABLES_MISS',
-    4: 'OFPTFPT_WRITE_ACTIONS',
-    5: 'OFPTFPT_WRITE_ACTIONS_MISS',
-    6: 'OFPTFPT_APPLY_ACTIONS',
-    7: 'OFPTFPT_APPLY_ACTIONS_MISS',
-    8: 'OFPTFPT_MATCH',
-    10: 'OFPTFPT_WILDCARDS',
-    12: 'OFPTFPT_WRITE_SETFIELD',
-    13: 'OFPTFPT_WRITE_SETFIELD_MISS',
-    14: 'OFPTFPT_APPLY_SETFIELD',
-    15: 'OFPTFPT_APPLY_SETFIELD_MISS',
-    65534: 'OFPTFPT_EXPERIMENTER',
-    65535: 'OFPTFPT_EXPERIMENTER_MISS',
-}
-
-# Identifiers from group ofp_table_features_failed_code
-OFPTFFC_BAD_TABLE = 0
-OFPTFFC_BAD_METADATA = 1
-OFPTFFC_BAD_TYPE = 2
-OFPTFFC_BAD_LEN = 3
-OFPTFFC_BAD_ARGUMENT = 4
-OFPTFFC_EPERM = 5
-
-ofp_table_features_failed_code_map = {
-    0: 'OFPTFFC_BAD_TABLE',
-    1: 'OFPTFFC_BAD_METADATA',
-    2: 'OFPTFFC_BAD_TYPE',
-    3: 'OFPTFFC_BAD_LEN',
-    4: 'OFPTFFC_BAD_ARGUMENT',
-    5: 'OFPTFFC_EPERM',
-}
-
-# Identifiers from group ofp_table_mod_failed_code
-OFPTMFC_BAD_TABLE = 0
-OFPTMFC_BAD_CONFIG = 1
-OFPTMFC_EPERM = 2
-
-ofp_table_mod_failed_code_map = {
-    0: 'OFPTMFC_BAD_TABLE',
-    1: 'OFPTMFC_BAD_CONFIG',
-    2: 'OFPTMFC_EPERM',
-}
-
-# Identifiers from group ofp_type
-OFPT_HELLO = 0
-OFPT_ERROR = 1
-OFPT_ECHO_REQUEST = 2
-OFPT_ECHO_REPLY = 3
-OFPT_EXPERIMENTER = 4
-OFPT_FEATURES_REQUEST = 5
-OFPT_FEATURES_REPLY = 6
-OFPT_GET_CONFIG_REQUEST = 7
-OFPT_GET_CONFIG_REPLY = 8
-OFPT_SET_CONFIG = 9
-OFPT_PACKET_IN = 10
-OFPT_FLOW_REMOVED = 11
-OFPT_PORT_STATUS = 12
-OFPT_PACKET_OUT = 13
-OFPT_FLOW_MOD = 14
-OFPT_GROUP_MOD = 15
-OFPT_PORT_MOD = 16
-OFPT_TABLE_MOD = 17
-OFPT_STATS_REQUEST = 18
-OFPT_STATS_REPLY = 19
-OFPT_BARRIER_REQUEST = 20
-OFPT_BARRIER_REPLY = 21
-OFPT_QUEUE_GET_CONFIG_REQUEST = 22
-OFPT_QUEUE_GET_CONFIG_REPLY = 23
-OFPT_ROLE_REQUEST = 24
-OFPT_ROLE_REPLY = 25
-OFPT_GET_ASYNC_REQUEST = 26
-OFPT_GET_ASYNC_REPLY = 27
-OFPT_SET_ASYNC = 28
-OFPT_METER_MOD = 29
-
-ofp_type_map = {
-    0: 'OFPT_HELLO',
-    1: 'OFPT_ERROR',
-    2: 'OFPT_ECHO_REQUEST',
-    3: 'OFPT_ECHO_REPLY',
-    4: 'OFPT_EXPERIMENTER',
-    5: 'OFPT_FEATURES_REQUEST',
-    6: 'OFPT_FEATURES_REPLY',
-    7: 'OFPT_GET_CONFIG_REQUEST',
-    8: 'OFPT_GET_CONFIG_REPLY',
-    9: 'OFPT_SET_CONFIG',
-    10: 'OFPT_PACKET_IN',
-    11: 'OFPT_FLOW_REMOVED',
-    12: 'OFPT_PORT_STATUS',
-    13: 'OFPT_PACKET_OUT',
-    14: 'OFPT_FLOW_MOD',
-    15: 'OFPT_GROUP_MOD',
-    16: 'OFPT_PORT_MOD',
-    17: 'OFPT_TABLE_MOD',
-    18: 'OFPT_STATS_REQUEST',
-    19: 'OFPT_STATS_REPLY',
-    20: 'OFPT_BARRIER_REQUEST',
-    21: 'OFPT_BARRIER_REPLY',
-    22: 'OFPT_QUEUE_GET_CONFIG_REQUEST',
-    23: 'OFPT_QUEUE_GET_CONFIG_REPLY',
-    24: 'OFPT_ROLE_REQUEST',
-    25: 'OFPT_ROLE_REPLY',
-    26: 'OFPT_GET_ASYNC_REQUEST',
-    27: 'OFPT_GET_ASYNC_REPLY',
-    28: 'OFPT_SET_ASYNC',
-    29: 'OFPT_METER_MOD',
-}
-
-# Identifiers from group ofp_vlan_id
-OFPVID_NONE = 0
-OFPVID_PRESENT = 4096
-
-ofp_vlan_id_map = {
-    0: 'OFPVID_NONE',
-    4096: 'OFPVID_PRESENT',
-}
-
diff --git a/python/ofagent/loxi/of13/instruction.py b/python/ofagent/loxi/of13/instruction.py
deleted file mode 100644
index e839429..0000000
--- a/python/ofagent/loxi/of13/instruction.py
+++ /dev/null
@@ -1,1168 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template module.py
-# Do not modify
-
-import struct
-import loxi
-import util
-import loxi.generic_util
-
-import sys
-ofp = sys.modules['loxi.of13']
-
-class instruction(loxi.OFObject):
-    subtypes = {}
-
-
-    def __init__(self, type=None):
-        if type != None:
-            self.type = type
-        else:
-            self.type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 0)
-        subclass = instruction.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = instruction()
-        obj.type = reader.read("!H")[0]
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type != other.type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("instruction {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-
-class apply_actions(instruction):
-    type = 4
-
-    def __init__(self, actions=None):
-        if actions != None:
-            self.actions = actions
-        else:
-            self.actions = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.actions))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = apply_actions()
-        _type = reader.read("!H")[0]
-        assert(_type == 4)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        obj.actions = loxi.generic_util.unpack_list(reader, ofp.action.action.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.actions != other.actions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("apply_actions {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("actions = ");
-                q.pp(self.actions)
-            q.breakable()
-        q.text('}')
-
-instruction.subtypes[4] = apply_actions
-
-class experimenter(instruction):
-    subtypes = {}
-
-    type = 65535
-
-    def __init__(self, experimenter=None, data=None):
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 4)
-        subclass = experimenter.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = experimenter()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.experimenter = reader.read("!L")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.experimenter != other.experimenter: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("experimenter {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-instruction.subtypes[65535] = experimenter
-
-class bsn(experimenter):
-    subtypes = {}
-
-    type = 65535
-    experimenter = 6035143
-
-    def __init__(self, subtype=None):
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 8)
-        subclass = bsn.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = bsn()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        obj.subtype = reader.read("!L")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.subtype != other.subtype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-experimenter.subtypes[6035143] = bsn
-
-class bsn_arp_offload(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 1
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_arp_offload()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 1)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_arp_offload {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[1] = bsn_arp_offload
-
-class bsn_auto_negotiation(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 11
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_auto_negotiation()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 11)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_auto_negotiation {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[11] = bsn_auto_negotiation
-
-class bsn_deny(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 5
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_deny()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 5)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_deny {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[5] = bsn_deny
-
-class bsn_dhcp_offload(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 2
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_dhcp_offload()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 2)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_dhcp_offload {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[2] = bsn_dhcp_offload
-
-class bsn_disable_l3(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 13
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_disable_l3()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 13)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_disable_l3 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[13] = bsn_disable_l3
-
-class bsn_disable_split_horizon_check(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 3
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_disable_split_horizon_check()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 3)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_disable_split_horizon_check {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[3] = bsn_disable_split_horizon_check
-
-class bsn_disable_src_mac_check(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 0
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_disable_src_mac_check()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 0)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_disable_src_mac_check {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[0] = bsn_disable_src_mac_check
-
-class bsn_disable_vlan_counters(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 9
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_disable_vlan_counters()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 9)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_disable_vlan_counters {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[9] = bsn_disable_vlan_counters
-
-class bsn_internal_priority(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 12
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_internal_priority()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 12)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_internal_priority {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[12] = bsn_internal_priority
-
-class bsn_packet_of_death(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 6
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_packet_of_death()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 6)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_packet_of_death {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[6] = bsn_packet_of_death
-
-class bsn_permit(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 4
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_permit()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 4)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_permit {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[4] = bsn_permit
-
-class bsn_prioritize_pdus(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 7
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_prioritize_pdus()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 7)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_prioritize_pdus {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[7] = bsn_prioritize_pdus
-
-class bsn_require_vlan_xlate(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 8
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_require_vlan_xlate()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 8)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_require_vlan_xlate {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[8] = bsn_require_vlan_xlate
-
-class bsn_span_destination(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 10
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_span_destination()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 10)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_span_destination {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[10] = bsn_span_destination
-
-class clear_actions(instruction):
-    type = 5
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = clear_actions()
-        _type = reader.read("!H")[0]
-        assert(_type == 5)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("clear_actions {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-instruction.subtypes[5] = clear_actions
-
-class goto_table(instruction):
-    type = 1
-
-    def __init__(self, table_id=None):
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append('\x00' * 3)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = goto_table()
-        _type = reader.read("!H")[0]
-        assert(_type == 1)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.table_id = reader.read("!B")[0]
-        reader.skip(3)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.table_id != other.table_id: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("goto_table {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-            q.breakable()
-        q.text('}')
-
-instruction.subtypes[1] = goto_table
-
-class meter(instruction):
-    type = 6
-
-    def __init__(self, meter_id=None):
-        if meter_id != None:
-            self.meter_id = meter_id
-        else:
-            self.meter_id = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.meter_id))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = meter()
-        _type = reader.read("!H")[0]
-        assert(_type == 6)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.meter_id = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.meter_id != other.meter_id: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("meter {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("meter_id = ");
-                q.text("%#x" % self.meter_id)
-            q.breakable()
-        q.text('}')
-
-instruction.subtypes[6] = meter
-
-class write_actions(instruction):
-    type = 3
-
-    def __init__(self, actions=None):
-        if actions != None:
-            self.actions = actions
-        else:
-            self.actions = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.actions))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = write_actions()
-        _type = reader.read("!H")[0]
-        assert(_type == 3)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        obj.actions = loxi.generic_util.unpack_list(reader, ofp.action.action.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.actions != other.actions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("write_actions {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("actions = ");
-                q.pp(self.actions)
-            q.breakable()
-        q.text('}')
-
-instruction.subtypes[3] = write_actions
-
-class write_metadata(instruction):
-    type = 2
-
-    def __init__(self, metadata=None, metadata_mask=None):
-        if metadata != None:
-            self.metadata = metadata
-        else:
-            self.metadata = 0
-        if metadata_mask != None:
-            self.metadata_mask = metadata_mask
-        else:
-            self.metadata_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!Q", self.metadata))
-        packed.append(struct.pack("!Q", self.metadata_mask))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = write_metadata()
-        _type = reader.read("!H")[0]
-        assert(_type == 2)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        obj.metadata = reader.read("!Q")[0]
-        obj.metadata_mask = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.metadata != other.metadata: return False
-        if self.metadata_mask != other.metadata_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("write_metadata {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("metadata = ");
-                q.text("%#x" % self.metadata)
-                q.text(","); q.breakable()
-                q.text("metadata_mask = ");
-                q.text("%#x" % self.metadata_mask)
-            q.breakable()
-        q.text('}')
-
-instruction.subtypes[2] = write_metadata
-
-
diff --git a/python/ofagent/loxi/of13/instruction_id.py b/python/ofagent/loxi/of13/instruction_id.py
deleted file mode 100644
index c5f0ca6..0000000
--- a/python/ofagent/loxi/of13/instruction_id.py
+++ /dev/null
@@ -1,1057 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template module.py
-# Do not modify
-
-import struct
-import loxi
-import util
-import loxi.generic_util
-
-import sys
-ofp = sys.modules['loxi.of13']
-
-class instruction_id(loxi.OFObject):
-    subtypes = {}
-
-
-    def __init__(self, type=None):
-        if type != None:
-            self.type = type
-        else:
-            self.type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 0)
-        subclass = instruction_id.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = instruction_id()
-        obj.type = reader.read("!H")[0]
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type != other.type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("instruction_id {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-
-class apply_actions(instruction_id):
-    type = 4
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = apply_actions()
-        _type = reader.read("!H")[0]
-        assert(_type == 4)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("apply_actions {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-instruction_id.subtypes[4] = apply_actions
-
-class experimenter(instruction_id):
-    subtypes = {}
-
-    type = 65535
-
-    def __init__(self, experimenter=None):
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 4)
-        subclass = experimenter.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = experimenter()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.experimenter = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.experimenter != other.experimenter: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("experimenter {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-instruction_id.subtypes[65535] = experimenter
-
-class bsn(experimenter):
-    subtypes = {}
-
-    type = 65535
-    experimenter = 6035143
-
-    def __init__(self, subtype=None):
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 8)
-        subclass = bsn.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = bsn()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        obj.subtype = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.subtype != other.subtype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-experimenter.subtypes[6035143] = bsn
-
-class bsn_arp_offload(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 1
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_arp_offload()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 1)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_arp_offload {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[1] = bsn_arp_offload
-
-class bsn_auto_negotiation(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 11
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_auto_negotiation()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 11)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_auto_negotiation {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[11] = bsn_auto_negotiation
-
-class bsn_deny(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 5
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_deny()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 5)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_deny {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[5] = bsn_deny
-
-class bsn_dhcp_offload(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 2
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_dhcp_offload()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 2)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_dhcp_offload {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[2] = bsn_dhcp_offload
-
-class bsn_disable_l3(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 13
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_disable_l3()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 13)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_disable_l3 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[13] = bsn_disable_l3
-
-class bsn_disable_split_horizon_check(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 3
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_disable_split_horizon_check()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 3)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_disable_split_horizon_check {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[3] = bsn_disable_split_horizon_check
-
-class bsn_disable_src_mac_check(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 0
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_disable_src_mac_check()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 0)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_disable_src_mac_check {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[0] = bsn_disable_src_mac_check
-
-class bsn_disable_vlan_counters(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 9
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_disable_vlan_counters()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 9)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_disable_vlan_counters {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[9] = bsn_disable_vlan_counters
-
-class bsn_internal_priority(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 12
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_internal_priority()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 12)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_internal_priority {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[12] = bsn_internal_priority
-
-class bsn_packet_of_death(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 6
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_packet_of_death()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 6)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_packet_of_death {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[6] = bsn_packet_of_death
-
-class bsn_permit(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 4
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_permit()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_permit {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[4] = bsn_permit
-
-class bsn_prioritize_pdus(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 7
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_prioritize_pdus()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 7)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_prioritize_pdus {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[7] = bsn_prioritize_pdus
-
-class bsn_require_vlan_xlate(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 8
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_require_vlan_xlate()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 8)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_require_vlan_xlate {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[8] = bsn_require_vlan_xlate
-
-class bsn_span_destination(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 10
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_span_destination()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 10)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_span_destination {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[10] = bsn_span_destination
-
-class clear_actions(instruction_id):
-    type = 5
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = clear_actions()
-        _type = reader.read("!H")[0]
-        assert(_type == 5)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("clear_actions {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-instruction_id.subtypes[5] = clear_actions
-
-class goto_table(instruction_id):
-    type = 1
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = goto_table()
-        _type = reader.read("!H")[0]
-        assert(_type == 1)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("goto_table {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-instruction_id.subtypes[1] = goto_table
-
-class meter(instruction_id):
-    type = 6
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = meter()
-        _type = reader.read("!H")[0]
-        assert(_type == 6)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("meter {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-instruction_id.subtypes[6] = meter
-
-class write_actions(instruction_id):
-    type = 3
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = write_actions()
-        _type = reader.read("!H")[0]
-        assert(_type == 3)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("write_actions {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-instruction_id.subtypes[3] = write_actions
-
-class write_metadata(instruction_id):
-    type = 2
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = write_metadata()
-        _type = reader.read("!H")[0]
-        assert(_type == 2)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("write_metadata {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-instruction_id.subtypes[2] = write_metadata
-
-
diff --git a/python/ofagent/loxi/of13/message.py b/python/ofagent/loxi/of13/message.py
deleted file mode 100644
index 036aa54..0000000
--- a/python/ofagent/loxi/of13/message.py
+++ /dev/null
@@ -1,15419 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template module.py
-# Do not modify
-
-import struct
-import loxi
-import util
-import loxi.generic_util
-
-import sys
-ofp = sys.modules['loxi.of13']
-
-class message(loxi.OFObject):
-    subtypes = {}
-
-    version = 4
-
-    def __init__(self, type=None, xid=None):
-        if type != None:
-            self.type = type
-        else:
-            self.type = 0
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('B', 1)
-        subclass = message.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = message()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        obj.type = reader.read("!B")[0]
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type != other.type: return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("message {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-
-class stats_reply(message):
-    subtypes = {}
-
-    version = 4
-    type = 19
-
-    def __init__(self, xid=None, stats_type=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if stats_type != None:
-            self.stats_type = stats_type
-        else:
-            self.stats_type = 0
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 8)
-        subclass = stats_reply.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.stats_type = reader.read("!H")[0]
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.stats_type != other.stats_type: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[19] = stats_reply
-
-class aggregate_stats_reply(stats_reply):
-    version = 4
-    type = 19
-    stats_type = 2
-
-    def __init__(self, xid=None, flags=None, packet_count=None, byte_count=None, flow_count=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if packet_count != None:
-            self.packet_count = packet_count
-        else:
-            self.packet_count = 0
-        if byte_count != None:
-            self.byte_count = byte_count
-        else:
-            self.byte_count = 0
-        if flow_count != None:
-            self.flow_count = flow_count
-        else:
-            self.flow_count = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!Q", self.packet_count))
-        packed.append(struct.pack("!Q", self.byte_count))
-        packed.append(struct.pack("!L", self.flow_count))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = aggregate_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 2)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.packet_count = reader.read("!Q")[0]
-        obj.byte_count = reader.read("!Q")[0]
-        obj.flow_count = reader.read("!L")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.packet_count != other.packet_count: return False
-        if self.byte_count != other.byte_count: return False
-        if self.flow_count != other.flow_count: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("aggregate_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("packet_count = ");
-                q.text("%#x" % self.packet_count)
-                q.text(","); q.breakable()
-                q.text("byte_count = ");
-                q.text("%#x" % self.byte_count)
-                q.text(","); q.breakable()
-                q.text("flow_count = ");
-                q.text("%#x" % self.flow_count)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[2] = aggregate_stats_reply
-
-class stats_request(message):
-    subtypes = {}
-
-    version = 4
-    type = 18
-
-    def __init__(self, xid=None, stats_type=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if stats_type != None:
-            self.stats_type = stats_type
-        else:
-            self.stats_type = 0
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 8)
-        subclass = stats_request.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.stats_type = reader.read("!H")[0]
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.stats_type != other.stats_type: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[18] = stats_request
-
-class aggregate_stats_request(stats_request):
-    version = 4
-    type = 18
-    stats_type = 2
-
-    def __init__(self, xid=None, flags=None, table_id=None, out_port=None, out_group=None, cookie=None, cookie_mask=None, match=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if out_port != None:
-            self.out_port = out_port
-        else:
-            self.out_port = 0
-        if out_group != None:
-            self.out_group = out_group
-        else:
-            self.out_group = 0
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if cookie_mask != None:
-            self.cookie_mask = cookie_mask
-        else:
-            self.cookie_mask = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append('\x00' * 3)
-        packed.append(util.pack_port_no(self.out_port))
-        packed.append(struct.pack("!L", self.out_group))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(struct.pack("!Q", self.cookie_mask))
-        packed.append(self.match.pack())
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = aggregate_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 2)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.table_id = reader.read("!B")[0]
-        reader.skip(3)
-        obj.out_port = util.unpack_port_no(reader)
-        obj.out_group = reader.read("!L")[0]
-        reader.skip(4)
-        obj.cookie = reader.read("!Q")[0]
-        obj.cookie_mask = reader.read("!Q")[0]
-        obj.match = ofp.match.unpack(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.table_id != other.table_id: return False
-        if self.out_port != other.out_port: return False
-        if self.out_group != other.out_group: return False
-        if self.cookie != other.cookie: return False
-        if self.cookie_mask != other.cookie_mask: return False
-        if self.match != other.match: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("aggregate_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("out_port = ");
-                q.text(util.pretty_port(self.out_port))
-                q.text(","); q.breakable()
-                q.text("out_group = ");
-                q.text("%#x" % self.out_group)
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("cookie_mask = ");
-                q.text("%#x" % self.cookie_mask)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[2] = aggregate_stats_request
-
-class async_get_reply(message):
-    version = 4
-    type = 27
-
-    def __init__(self, xid=None, packet_in_mask_equal_master=None, packet_in_mask_slave=None, port_status_mask_equal_master=None, port_status_mask_slave=None, flow_removed_mask_equal_master=None, flow_removed_mask_slave=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if packet_in_mask_equal_master != None:
-            self.packet_in_mask_equal_master = packet_in_mask_equal_master
-        else:
-            self.packet_in_mask_equal_master = 0
-        if packet_in_mask_slave != None:
-            self.packet_in_mask_slave = packet_in_mask_slave
-        else:
-            self.packet_in_mask_slave = 0
-        if port_status_mask_equal_master != None:
-            self.port_status_mask_equal_master = port_status_mask_equal_master
-        else:
-            self.port_status_mask_equal_master = 0
-        if port_status_mask_slave != None:
-            self.port_status_mask_slave = port_status_mask_slave
-        else:
-            self.port_status_mask_slave = 0
-        if flow_removed_mask_equal_master != None:
-            self.flow_removed_mask_equal_master = flow_removed_mask_equal_master
-        else:
-            self.flow_removed_mask_equal_master = 0
-        if flow_removed_mask_slave != None:
-            self.flow_removed_mask_slave = flow_removed_mask_slave
-        else:
-            self.flow_removed_mask_slave = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.packet_in_mask_equal_master))
-        packed.append(struct.pack("!L", self.packet_in_mask_slave))
-        packed.append(struct.pack("!L", self.port_status_mask_equal_master))
-        packed.append(struct.pack("!L", self.port_status_mask_slave))
-        packed.append(struct.pack("!L", self.flow_removed_mask_equal_master))
-        packed.append(struct.pack("!L", self.flow_removed_mask_slave))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = async_get_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 27)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.packet_in_mask_equal_master = reader.read("!L")[0]
-        obj.packet_in_mask_slave = reader.read("!L")[0]
-        obj.port_status_mask_equal_master = reader.read("!L")[0]
-        obj.port_status_mask_slave = reader.read("!L")[0]
-        obj.flow_removed_mask_equal_master = reader.read("!L")[0]
-        obj.flow_removed_mask_slave = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.packet_in_mask_equal_master != other.packet_in_mask_equal_master: return False
-        if self.packet_in_mask_slave != other.packet_in_mask_slave: return False
-        if self.port_status_mask_equal_master != other.port_status_mask_equal_master: return False
-        if self.port_status_mask_slave != other.port_status_mask_slave: return False
-        if self.flow_removed_mask_equal_master != other.flow_removed_mask_equal_master: return False
-        if self.flow_removed_mask_slave != other.flow_removed_mask_slave: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("async_get_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("packet_in_mask_equal_master = ");
-                q.text("%#x" % self.packet_in_mask_equal_master)
-                q.text(","); q.breakable()
-                q.text("packet_in_mask_slave = ");
-                q.text("%#x" % self.packet_in_mask_slave)
-                q.text(","); q.breakable()
-                q.text("port_status_mask_equal_master = ");
-                q.text("%#x" % self.port_status_mask_equal_master)
-                q.text(","); q.breakable()
-                q.text("port_status_mask_slave = ");
-                q.text("%#x" % self.port_status_mask_slave)
-                q.text(","); q.breakable()
-                q.text("flow_removed_mask_equal_master = ");
-                q.text("%#x" % self.flow_removed_mask_equal_master)
-                q.text(","); q.breakable()
-                q.text("flow_removed_mask_slave = ");
-                q.text("%#x" % self.flow_removed_mask_slave)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[27] = async_get_reply
-
-class async_get_request(message):
-    version = 4
-    type = 26
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = async_get_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 26)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("async_get_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-message.subtypes[26] = async_get_request
-
-class async_set(message):
-    version = 4
-    type = 28
-
-    def __init__(self, xid=None, packet_in_mask_equal_master=None, packet_in_mask_slave=None, port_status_mask_equal_master=None, port_status_mask_slave=None, flow_removed_mask_equal_master=None, flow_removed_mask_slave=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if packet_in_mask_equal_master != None:
-            self.packet_in_mask_equal_master = packet_in_mask_equal_master
-        else:
-            self.packet_in_mask_equal_master = 0
-        if packet_in_mask_slave != None:
-            self.packet_in_mask_slave = packet_in_mask_slave
-        else:
-            self.packet_in_mask_slave = 0
-        if port_status_mask_equal_master != None:
-            self.port_status_mask_equal_master = port_status_mask_equal_master
-        else:
-            self.port_status_mask_equal_master = 0
-        if port_status_mask_slave != None:
-            self.port_status_mask_slave = port_status_mask_slave
-        else:
-            self.port_status_mask_slave = 0
-        if flow_removed_mask_equal_master != None:
-            self.flow_removed_mask_equal_master = flow_removed_mask_equal_master
-        else:
-            self.flow_removed_mask_equal_master = 0
-        if flow_removed_mask_slave != None:
-            self.flow_removed_mask_slave = flow_removed_mask_slave
-        else:
-            self.flow_removed_mask_slave = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.packet_in_mask_equal_master))
-        packed.append(struct.pack("!L", self.packet_in_mask_slave))
-        packed.append(struct.pack("!L", self.port_status_mask_equal_master))
-        packed.append(struct.pack("!L", self.port_status_mask_slave))
-        packed.append(struct.pack("!L", self.flow_removed_mask_equal_master))
-        packed.append(struct.pack("!L", self.flow_removed_mask_slave))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = async_set()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 28)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.packet_in_mask_equal_master = reader.read("!L")[0]
-        obj.packet_in_mask_slave = reader.read("!L")[0]
-        obj.port_status_mask_equal_master = reader.read("!L")[0]
-        obj.port_status_mask_slave = reader.read("!L")[0]
-        obj.flow_removed_mask_equal_master = reader.read("!L")[0]
-        obj.flow_removed_mask_slave = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.packet_in_mask_equal_master != other.packet_in_mask_equal_master: return False
-        if self.packet_in_mask_slave != other.packet_in_mask_slave: return False
-        if self.port_status_mask_equal_master != other.port_status_mask_equal_master: return False
-        if self.port_status_mask_slave != other.port_status_mask_slave: return False
-        if self.flow_removed_mask_equal_master != other.flow_removed_mask_equal_master: return False
-        if self.flow_removed_mask_slave != other.flow_removed_mask_slave: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("async_set {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("packet_in_mask_equal_master = ");
-                q.text("%#x" % self.packet_in_mask_equal_master)
-                q.text(","); q.breakable()
-                q.text("packet_in_mask_slave = ");
-                q.text("%#x" % self.packet_in_mask_slave)
-                q.text(","); q.breakable()
-                q.text("port_status_mask_equal_master = ");
-                q.text("%#x" % self.port_status_mask_equal_master)
-                q.text(","); q.breakable()
-                q.text("port_status_mask_slave = ");
-                q.text("%#x" % self.port_status_mask_slave)
-                q.text(","); q.breakable()
-                q.text("flow_removed_mask_equal_master = ");
-                q.text("%#x" % self.flow_removed_mask_equal_master)
-                q.text(","); q.breakable()
-                q.text("flow_removed_mask_slave = ");
-                q.text("%#x" % self.flow_removed_mask_slave)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[28] = async_set
-
-class error_msg(message):
-    subtypes = {}
-
-    version = 4
-    type = 1
-
-    def __init__(self, xid=None, err_type=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if err_type != None:
-            self.err_type = err_type
-        else:
-            self.err_type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 8)
-        subclass = error_msg.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.err_type = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.err_type != other.err_type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-message.subtypes[1] = error_msg
-
-class bad_action_error_msg(error_msg):
-    version = 4
-    type = 1
-    err_type = 2
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bad_action_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 2)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bad_action_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[2] = bad_action_error_msg
-
-class bad_instruction_error_msg(error_msg):
-    version = 4
-    type = 1
-    err_type = 3
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bad_instruction_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 3)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bad_instruction_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[3] = bad_instruction_error_msg
-
-class bad_match_error_msg(error_msg):
-    version = 4
-    type = 1
-    err_type = 4
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bad_match_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 4)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bad_match_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[4] = bad_match_error_msg
-
-class bad_request_error_msg(error_msg):
-    version = 4
-    type = 1
-    err_type = 1
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bad_request_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 1)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bad_request_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[1] = bad_request_error_msg
-
-class barrier_reply(message):
-    version = 4
-    type = 21
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = barrier_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 21)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("barrier_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-message.subtypes[21] = barrier_reply
-
-class barrier_request(message):
-    version = 4
-    type = 20
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = barrier_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 20)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("barrier_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-message.subtypes[20] = barrier_request
-
-class experimenter(message):
-    subtypes = {}
-
-    version = 4
-    type = 4
-
-    def __init__(self, xid=None, experimenter=None, subtype=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 8)
-        subclass = experimenter.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = experimenter()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.experimenter = reader.read("!L")[0]
-        obj.subtype = reader.read("!L")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.experimenter != other.experimenter: return False
-        if self.subtype != other.subtype: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("experimenter {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("subtype = ");
-                q.text("%#x" % self.subtype)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[4] = experimenter
-
-class bsn_header(experimenter):
-    subtypes = {}
-
-    version = 4
-    type = 4
-    experimenter = 6035143
-
-    def __init__(self, xid=None, subtype=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 12)
-        subclass = bsn_header.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = bsn_header()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        obj.subtype = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.subtype != other.subtype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_header {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-experimenter.subtypes[6035143] = bsn_header
-
-class bsn_arp_idle(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 60
-
-    def __init__(self, xid=None, vlan_vid=None, ipv4_addr=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if vlan_vid != None:
-            self.vlan_vid = vlan_vid
-        else:
-            self.vlan_vid = 0
-        if ipv4_addr != None:
-            self.ipv4_addr = ipv4_addr
-        else:
-            self.ipv4_addr = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!H", self.vlan_vid))
-        packed.append('\x00' * 2)
-        packed.append(struct.pack("!L", self.ipv4_addr))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_arp_idle()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 60)
-        obj.vlan_vid = reader.read("!H")[0]
-        reader.skip(2)
-        obj.ipv4_addr = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.vlan_vid != other.vlan_vid: return False
-        if self.ipv4_addr != other.ipv4_addr: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_arp_idle {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("vlan_vid = ");
-                q.text("%#x" % self.vlan_vid)
-                q.text(","); q.breakable()
-                q.text("ipv4_addr = ");
-                q.text(util.pretty_ipv4(self.ipv4_addr))
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[60] = bsn_arp_idle
-
-class experimenter_error_msg(error_msg):
-    subtypes = {}
-
-    version = 4
-    type = 1
-    err_type = 65535
-
-    def __init__(self, xid=None, subtype=None, experimenter=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.subtype))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 12)
-        subclass = experimenter_error_msg.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = experimenter_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 65535)
-        obj.subtype = reader.read("!H")[0]
-        obj.experimenter = reader.read("!L")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.subtype != other.subtype: return False
-        if self.experimenter != other.experimenter: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("experimenter_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("subtype = ");
-                q.text("%#x" % self.subtype)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[65535] = experimenter_error_msg
-
-class bsn_base_error(experimenter_error_msg):
-    subtypes = {}
-
-    version = 4
-    type = 1
-    err_type = 65535
-    experimenter = 6035143
-
-    def __init__(self, xid=None, subtype=None, err_msg=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        if err_msg != None:
-            self.err_msg = err_msg
-        else:
-            self.err_msg = ""
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.subtype))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!256s", self.err_msg))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 10)
-        subclass = bsn_base_error.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = bsn_base_error()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 65535)
-        obj.subtype = reader.read("!H")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        obj.err_msg = reader.read("!256s")[0].rstrip("\x00")
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.subtype != other.subtype: return False
-        if self.err_msg != other.err_msg: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_base_error {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("err_msg = ");
-                q.pp(self.err_msg)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-experimenter_error_msg.subtypes[6035143] = bsn_base_error
-
-class bsn_bw_clear_data_reply(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 22
-
-    def __init__(self, xid=None, status=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if status != None:
-            self.status = status
-        else:
-            self.status = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.status))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_bw_clear_data_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 22)
-        obj.status = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.status != other.status: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_bw_clear_data_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("status = ");
-                q.text("%#x" % self.status)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[22] = bsn_bw_clear_data_reply
-
-class bsn_bw_clear_data_request(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 21
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_bw_clear_data_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 21)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_bw_clear_data_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[21] = bsn_bw_clear_data_request
-
-class bsn_bw_enable_get_reply(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 20
-
-    def __init__(self, xid=None, enabled=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if enabled != None:
-            self.enabled = enabled
-        else:
-            self.enabled = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.enabled))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_bw_enable_get_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 20)
-        obj.enabled = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.enabled != other.enabled: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_bw_enable_get_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("enabled = ");
-                q.text("%#x" % self.enabled)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[20] = bsn_bw_enable_get_reply
-
-class bsn_bw_enable_get_request(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 19
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_bw_enable_get_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 19)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_bw_enable_get_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[19] = bsn_bw_enable_get_request
-
-class bsn_bw_enable_set_reply(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 23
-
-    def __init__(self, xid=None, enable=None, status=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if enable != None:
-            self.enable = enable
-        else:
-            self.enable = 0
-        if status != None:
-            self.status = status
-        else:
-            self.status = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.enable))
-        packed.append(struct.pack("!L", self.status))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_bw_enable_set_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 23)
-        obj.enable = reader.read("!L")[0]
-        obj.status = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.enable != other.enable: return False
-        if self.status != other.status: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_bw_enable_set_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("enable = ");
-                q.text("%#x" % self.enable)
-                q.text(","); q.breakable()
-                q.text("status = ");
-                q.text("%#x" % self.status)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[23] = bsn_bw_enable_set_reply
-
-class bsn_bw_enable_set_request(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 18
-
-    def __init__(self, xid=None, enable=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if enable != None:
-            self.enable = enable
-        else:
-            self.enable = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.enable))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_bw_enable_set_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 18)
-        obj.enable = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.enable != other.enable: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_bw_enable_set_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("enable = ");
-                q.text("%#x" % self.enable)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[18] = bsn_bw_enable_set_request
-
-class bsn_controller_connections_reply(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 57
-
-    def __init__(self, xid=None, connections=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if connections != None:
-            self.connections = connections
-        else:
-            self.connections = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(loxi.generic_util.pack_list(self.connections))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_controller_connections_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 57)
-        obj.connections = loxi.generic_util.unpack_list(reader, ofp.common.bsn_controller_connection.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.connections != other.connections: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_controller_connections_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("connections = ");
-                q.pp(self.connections)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[57] = bsn_controller_connections_reply
-
-class bsn_controller_connections_request(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 56
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_controller_connections_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 56)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_controller_connections_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[56] = bsn_controller_connections_request
-
-class experimenter_stats_reply(stats_reply):
-    subtypes = {}
-
-    version = 4
-    type = 19
-    stats_type = 65535
-
-    def __init__(self, xid=None, flags=None, experimenter=None, subtype=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 16)
-        subclass = experimenter_stats_reply.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = experimenter_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.experimenter = reader.read("!L")[0]
-        obj.subtype = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.experimenter != other.experimenter: return False
-        if self.subtype != other.subtype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("experimenter_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("subtype = ");
-                q.text("%#x" % self.subtype)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[65535] = experimenter_stats_reply
-
-class bsn_stats_reply(experimenter_stats_reply):
-    subtypes = {}
-
-    version = 4
-    type = 19
-    stats_type = 65535
-    experimenter = 6035143
-
-    def __init__(self, xid=None, flags=None, subtype=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 20)
-        subclass = bsn_stats_reply.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = bsn_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        obj.subtype = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.subtype != other.subtype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-experimenter_stats_reply.subtypes[6035143] = bsn_stats_reply
-
-class bsn_debug_counter_desc_stats_reply(bsn_stats_reply):
-    version = 4
-    type = 19
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 13
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_debug_counter_desc_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 13)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.bsn_debug_counter_desc_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_debug_counter_desc_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_reply.subtypes[13] = bsn_debug_counter_desc_stats_reply
-
-class experimenter_stats_request(stats_request):
-    subtypes = {}
-
-    version = 4
-    type = 18
-    stats_type = 65535
-
-    def __init__(self, xid=None, flags=None, experimenter=None, subtype=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 16)
-        subclass = experimenter_stats_request.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = experimenter_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.experimenter = reader.read("!L")[0]
-        obj.subtype = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.experimenter != other.experimenter: return False
-        if self.subtype != other.subtype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("experimenter_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("subtype = ");
-                q.text("%#x" % self.subtype)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[65535] = experimenter_stats_request
-
-class bsn_stats_request(experimenter_stats_request):
-    subtypes = {}
-
-    version = 4
-    type = 18
-    stats_type = 65535
-    experimenter = 6035143
-
-    def __init__(self, xid=None, flags=None, subtype=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 20)
-        subclass = bsn_stats_request.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = bsn_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        obj.subtype = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.subtype != other.subtype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-experimenter_stats_request.subtypes[6035143] = bsn_stats_request
-
-class bsn_debug_counter_desc_stats_request(bsn_stats_request):
-    version = 4
-    type = 18
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 13
-
-    def __init__(self, xid=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_debug_counter_desc_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 13)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_debug_counter_desc_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_request.subtypes[13] = bsn_debug_counter_desc_stats_request
-
-class bsn_debug_counter_stats_reply(bsn_stats_reply):
-    version = 4
-    type = 19
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 12
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_debug_counter_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 12)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.bsn_debug_counter_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_debug_counter_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_reply.subtypes[12] = bsn_debug_counter_stats_reply
-
-class bsn_debug_counter_stats_request(bsn_stats_request):
-    version = 4
-    type = 18
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 12
-
-    def __init__(self, xid=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_debug_counter_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 12)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_debug_counter_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_request.subtypes[12] = bsn_debug_counter_stats_request
-
-class bsn_error(bsn_base_error):
-    version = 4
-    type = 1
-    err_type = 65535
-    subtype = 1
-    experimenter = 6035143
-
-    def __init__(self, xid=None, err_msg=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if err_msg != None:
-            self.err_msg = err_msg
-        else:
-            self.err_msg = ""
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.subtype))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!256s", self.err_msg))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_error()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 65535)
-        _subtype = reader.read("!H")[0]
-        assert(_subtype == 1)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        obj.err_msg = reader.read("!256s")[0].rstrip("\x00")
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.err_msg != other.err_msg: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_error {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("err_msg = ");
-                q.pp(self.err_msg)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-bsn_base_error.subtypes[1] = bsn_error
-
-class bsn_flow_checksum_bucket_stats_reply(bsn_stats_reply):
-    version = 4
-    type = 19
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 10
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_flow_checksum_bucket_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 10)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.bsn_flow_checksum_bucket_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_flow_checksum_bucket_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_reply.subtypes[10] = bsn_flow_checksum_bucket_stats_reply
-
-class bsn_flow_checksum_bucket_stats_request(bsn_stats_request):
-    version = 4
-    type = 18
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 10
-
-    def __init__(self, xid=None, flags=None, table_id=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!B", self.table_id))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_flow_checksum_bucket_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 10)
-        obj.table_id = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.table_id != other.table_id: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_flow_checksum_bucket_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_request.subtypes[10] = bsn_flow_checksum_bucket_stats_request
-
-class bsn_flow_idle(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 40
-
-    def __init__(self, xid=None, cookie=None, priority=None, table_id=None, match=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if priority != None:
-            self.priority = priority
-        else:
-            self.priority = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(struct.pack("!H", self.priority))
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append('\x00' * 5)
-        packed.append(self.match.pack())
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_flow_idle()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 40)
-        obj.cookie = reader.read("!Q")[0]
-        obj.priority = reader.read("!H")[0]
-        obj.table_id = reader.read("!B")[0]
-        reader.skip(5)
-        obj.match = ofp.match.unpack(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.cookie != other.cookie: return False
-        if self.priority != other.priority: return False
-        if self.table_id != other.table_id: return False
-        if self.match != other.match: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_flow_idle {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("priority = ");
-                q.text("%#x" % self.priority)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[40] = bsn_flow_idle
-
-class bsn_flow_idle_enable_get_reply(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 39
-
-    def __init__(self, xid=None, enabled=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if enabled != None:
-            self.enabled = enabled
-        else:
-            self.enabled = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.enabled))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_flow_idle_enable_get_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 39)
-        obj.enabled = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.enabled != other.enabled: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_flow_idle_enable_get_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("enabled = ");
-                q.text("%#x" % self.enabled)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[39] = bsn_flow_idle_enable_get_reply
-
-class bsn_flow_idle_enable_get_request(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 38
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_flow_idle_enable_get_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 38)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_flow_idle_enable_get_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[38] = bsn_flow_idle_enable_get_request
-
-class bsn_flow_idle_enable_set_reply(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 37
-
-    def __init__(self, xid=None, enable=None, status=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if enable != None:
-            self.enable = enable
-        else:
-            self.enable = 0
-        if status != None:
-            self.status = status
-        else:
-            self.status = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.enable))
-        packed.append(struct.pack("!L", self.status))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_flow_idle_enable_set_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 37)
-        obj.enable = reader.read("!L")[0]
-        obj.status = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.enable != other.enable: return False
-        if self.status != other.status: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_flow_idle_enable_set_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("enable = ");
-                q.text("%#x" % self.enable)
-                q.text(","); q.breakable()
-                q.text("status = ");
-                q.text("%#x" % self.status)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[37] = bsn_flow_idle_enable_set_reply
-
-class bsn_flow_idle_enable_set_request(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 36
-
-    def __init__(self, xid=None, enable=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if enable != None:
-            self.enable = enable
-        else:
-            self.enable = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.enable))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_flow_idle_enable_set_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 36)
-        obj.enable = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.enable != other.enable: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_flow_idle_enable_set_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("enable = ");
-                q.text("%#x" % self.enable)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[36] = bsn_flow_idle_enable_set_request
-
-class bsn_generic_stats_reply(bsn_stats_reply):
-    version = 4
-    type = 19
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 16
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_generic_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 16)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.bsn_generic_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_generic_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_reply.subtypes[16] = bsn_generic_stats_reply
-
-class bsn_generic_stats_request(bsn_stats_request):
-    version = 4
-    type = 18
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 16
-
-    def __init__(self, xid=None, flags=None, name=None, tlvs=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if name != None:
-            self.name = name
-        else:
-            self.name = ""
-        if tlvs != None:
-            self.tlvs = tlvs
-        else:
-            self.tlvs = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!64s", self.name))
-        packed.append(loxi.generic_util.pack_list(self.tlvs))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_generic_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 16)
-        obj.name = reader.read("!64s")[0].rstrip("\x00")
-        obj.tlvs = loxi.generic_util.unpack_list(reader, ofp.bsn_tlv.bsn_tlv.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.name != other.name: return False
-        if self.tlvs != other.tlvs: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_generic_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("name = ");
-                q.pp(self.name)
-                q.text(","); q.breakable()
-                q.text("tlvs = ");
-                q.pp(self.tlvs)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_request.subtypes[16] = bsn_generic_stats_request
-
-class bsn_gentable_bucket_stats_reply(bsn_stats_reply):
-    version = 4
-    type = 19
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 5
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_gentable_bucket_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 5)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.bsn_gentable_bucket_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_gentable_bucket_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_reply.subtypes[5] = bsn_gentable_bucket_stats_reply
-
-class bsn_gentable_bucket_stats_request(bsn_stats_request):
-    version = 4
-    type = 18
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 5
-
-    def __init__(self, xid=None, flags=None, table_id=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!H", self.table_id))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_gentable_bucket_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 5)
-        obj.table_id = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.table_id != other.table_id: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_gentable_bucket_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_request.subtypes[5] = bsn_gentable_bucket_stats_request
-
-class bsn_gentable_clear_reply(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 49
-
-    def __init__(self, xid=None, table_id=None, deleted_count=None, error_count=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if deleted_count != None:
-            self.deleted_count = deleted_count
-        else:
-            self.deleted_count = 0
-        if error_count != None:
-            self.error_count = error_count
-        else:
-            self.error_count = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!H", self.table_id))
-        packed.append('\x00' * 2)
-        packed.append(struct.pack("!L", self.deleted_count))
-        packed.append(struct.pack("!L", self.error_count))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_gentable_clear_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 49)
-        obj.table_id = reader.read("!H")[0]
-        reader.skip(2)
-        obj.deleted_count = reader.read("!L")[0]
-        obj.error_count = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.table_id != other.table_id: return False
-        if self.deleted_count != other.deleted_count: return False
-        if self.error_count != other.error_count: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_gentable_clear_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("deleted_count = ");
-                q.text("%#x" % self.deleted_count)
-                q.text(","); q.breakable()
-                q.text("error_count = ");
-                q.text("%#x" % self.error_count)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[49] = bsn_gentable_clear_reply
-
-class bsn_gentable_clear_request(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 48
-
-    def __init__(self, xid=None, table_id=None, checksum=None, checksum_mask=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if checksum != None:
-            self.checksum = checksum
-        else:
-            self.checksum = 0
-        if checksum_mask != None:
-            self.checksum_mask = checksum_mask
-        else:
-            self.checksum_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!H", self.table_id))
-        packed.append('\x00' * 2)
-        packed.append(util.pack_checksum_128(self.checksum))
-        packed.append(util.pack_checksum_128(self.checksum_mask))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_gentable_clear_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 48)
-        obj.table_id = reader.read("!H")[0]
-        reader.skip(2)
-        obj.checksum = util.unpack_checksum_128(reader)
-        obj.checksum_mask = util.unpack_checksum_128(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.table_id != other.table_id: return False
-        if self.checksum != other.checksum: return False
-        if self.checksum_mask != other.checksum_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_gentable_clear_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("checksum = ");
-                q.pp(self.checksum)
-                q.text(","); q.breakable()
-                q.text("checksum_mask = ");
-                q.pp(self.checksum_mask)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[48] = bsn_gentable_clear_request
-
-class bsn_gentable_desc_stats_reply(bsn_stats_reply):
-    version = 4
-    type = 19
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 4
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_gentable_desc_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 4)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.bsn_gentable_desc_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_gentable_desc_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_reply.subtypes[4] = bsn_gentable_desc_stats_reply
-
-class bsn_gentable_desc_stats_request(bsn_stats_request):
-    version = 4
-    type = 18
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 4
-
-    def __init__(self, xid=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_gentable_desc_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_gentable_desc_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_request.subtypes[4] = bsn_gentable_desc_stats_request
-
-class bsn_gentable_entry_add(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 46
-
-    def __init__(self, xid=None, table_id=None, checksum=None, key=None, value=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if checksum != None:
-            self.checksum = checksum
-        else:
-            self.checksum = 0
-        if key != None:
-            self.key = key
-        else:
-            self.key = []
-        if value != None:
-            self.value = value
-        else:
-            self.value = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!H", self.table_id))
-        packed.append(struct.pack("!H", 0)) # placeholder for key_length at index 7
-        packed.append(util.pack_checksum_128(self.checksum))
-        packed.append(loxi.generic_util.pack_list(self.key))
-        packed[7] = struct.pack("!H", len(packed[-1]))
-        packed.append(loxi.generic_util.pack_list(self.value))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_gentable_entry_add()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 46)
-        obj.table_id = reader.read("!H")[0]
-        _key_length = reader.read("!H")[0]
-        obj.checksum = util.unpack_checksum_128(reader)
-        obj.key = loxi.generic_util.unpack_list(reader.slice(_key_length), ofp.bsn_tlv.bsn_tlv.unpack)
-        obj.value = loxi.generic_util.unpack_list(reader, ofp.bsn_tlv.bsn_tlv.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.table_id != other.table_id: return False
-        if self.checksum != other.checksum: return False
-        if self.key != other.key: return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_gentable_entry_add {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("checksum = ");
-                q.pp(self.checksum)
-                q.text(","); q.breakable()
-                q.text("key = ");
-                q.pp(self.key)
-                q.text(","); q.breakable()
-                q.text("value = ");
-                q.pp(self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[46] = bsn_gentable_entry_add
-
-class bsn_gentable_entry_delete(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 47
-
-    def __init__(self, xid=None, table_id=None, key=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if key != None:
-            self.key = key
-        else:
-            self.key = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!H", self.table_id))
-        packed.append(loxi.generic_util.pack_list(self.key))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_gentable_entry_delete()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 47)
-        obj.table_id = reader.read("!H")[0]
-        obj.key = loxi.generic_util.unpack_list(reader, ofp.bsn_tlv.bsn_tlv.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.table_id != other.table_id: return False
-        if self.key != other.key: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_gentable_entry_delete {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("key = ");
-                q.pp(self.key)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[47] = bsn_gentable_entry_delete
-
-class bsn_gentable_entry_desc_stats_reply(bsn_stats_reply):
-    version = 4
-    type = 19
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 2
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_gentable_entry_desc_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 2)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.bsn_gentable_entry_desc_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_gentable_entry_desc_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_reply.subtypes[2] = bsn_gentable_entry_desc_stats_reply
-
-class bsn_gentable_entry_desc_stats_request(bsn_stats_request):
-    version = 4
-    type = 18
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 2
-
-    def __init__(self, xid=None, flags=None, table_id=None, checksum=None, checksum_mask=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if checksum != None:
-            self.checksum = checksum
-        else:
-            self.checksum = 0
-        if checksum_mask != None:
-            self.checksum_mask = checksum_mask
-        else:
-            self.checksum_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!H", self.table_id))
-        packed.append('\x00' * 2)
-        packed.append(util.pack_checksum_128(self.checksum))
-        packed.append(util.pack_checksum_128(self.checksum_mask))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_gentable_entry_desc_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 2)
-        obj.table_id = reader.read("!H")[0]
-        reader.skip(2)
-        obj.checksum = util.unpack_checksum_128(reader)
-        obj.checksum_mask = util.unpack_checksum_128(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.table_id != other.table_id: return False
-        if self.checksum != other.checksum: return False
-        if self.checksum_mask != other.checksum_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_gentable_entry_desc_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("checksum = ");
-                q.pp(self.checksum)
-                q.text(","); q.breakable()
-                q.text("checksum_mask = ");
-                q.pp(self.checksum_mask)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_request.subtypes[2] = bsn_gentable_entry_desc_stats_request
-
-class bsn_gentable_entry_stats_reply(bsn_stats_reply):
-    version = 4
-    type = 19
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 3
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_gentable_entry_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 3)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.bsn_gentable_entry_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_gentable_entry_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_reply.subtypes[3] = bsn_gentable_entry_stats_reply
-
-class bsn_gentable_entry_stats_request(bsn_stats_request):
-    version = 4
-    type = 18
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 3
-
-    def __init__(self, xid=None, flags=None, table_id=None, checksum=None, checksum_mask=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if checksum != None:
-            self.checksum = checksum
-        else:
-            self.checksum = 0
-        if checksum_mask != None:
-            self.checksum_mask = checksum_mask
-        else:
-            self.checksum_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!H", self.table_id))
-        packed.append('\x00' * 2)
-        packed.append(util.pack_checksum_128(self.checksum))
-        packed.append(util.pack_checksum_128(self.checksum_mask))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_gentable_entry_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 3)
-        obj.table_id = reader.read("!H")[0]
-        reader.skip(2)
-        obj.checksum = util.unpack_checksum_128(reader)
-        obj.checksum_mask = util.unpack_checksum_128(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.table_id != other.table_id: return False
-        if self.checksum != other.checksum: return False
-        if self.checksum_mask != other.checksum_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_gentable_entry_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("checksum = ");
-                q.pp(self.checksum)
-                q.text(","); q.breakable()
-                q.text("checksum_mask = ");
-                q.pp(self.checksum_mask)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_request.subtypes[3] = bsn_gentable_entry_stats_request
-
-class bsn_gentable_set_buckets_size(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 50
-
-    def __init__(self, xid=None, table_id=None, buckets_size=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if buckets_size != None:
-            self.buckets_size = buckets_size
-        else:
-            self.buckets_size = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!H", self.table_id))
-        packed.append('\x00' * 2)
-        packed.append(struct.pack("!L", self.buckets_size))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_gentable_set_buckets_size()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 50)
-        obj.table_id = reader.read("!H")[0]
-        reader.skip(2)
-        obj.buckets_size = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.table_id != other.table_id: return False
-        if self.buckets_size != other.buckets_size: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_gentable_set_buckets_size {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("buckets_size = ");
-                q.text("%#x" % self.buckets_size)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[50] = bsn_gentable_set_buckets_size
-
-class bsn_gentable_stats_reply(bsn_stats_reply):
-    version = 4
-    type = 19
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 7
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_gentable_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 7)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.bsn_gentable_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_gentable_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_reply.subtypes[7] = bsn_gentable_stats_reply
-
-class bsn_gentable_stats_request(bsn_stats_request):
-    version = 4
-    type = 18
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 7
-
-    def __init__(self, xid=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_gentable_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 7)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_gentable_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_request.subtypes[7] = bsn_gentable_stats_request
-
-class bsn_get_interfaces_reply(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 10
-
-    def __init__(self, xid=None, interfaces=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if interfaces != None:
-            self.interfaces = interfaces
-        else:
-            self.interfaces = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(loxi.generic_util.pack_list(self.interfaces))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_get_interfaces_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 10)
-        obj.interfaces = loxi.generic_util.unpack_list(reader, ofp.common.bsn_interface.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.interfaces != other.interfaces: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_get_interfaces_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("interfaces = ");
-                q.pp(self.interfaces)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[10] = bsn_get_interfaces_reply
-
-class bsn_get_interfaces_request(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 9
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_get_interfaces_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 9)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_get_interfaces_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[9] = bsn_get_interfaces_request
-
-class bsn_get_mirroring_reply(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 5
-
-    def __init__(self, xid=None, report_mirror_ports=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if report_mirror_ports != None:
-            self.report_mirror_ports = report_mirror_ports
-        else:
-            self.report_mirror_ports = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!B", self.report_mirror_ports))
-        packed.append('\x00' * 3)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_get_mirroring_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 5)
-        obj.report_mirror_ports = reader.read("!B")[0]
-        reader.skip(3)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.report_mirror_ports != other.report_mirror_ports: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_get_mirroring_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("report_mirror_ports = ");
-                q.text("%#x" % self.report_mirror_ports)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[5] = bsn_get_mirroring_reply
-
-class bsn_get_mirroring_request(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 4
-
-    def __init__(self, xid=None, report_mirror_ports=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if report_mirror_ports != None:
-            self.report_mirror_ports = report_mirror_ports
-        else:
-            self.report_mirror_ports = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!B", self.report_mirror_ports))
-        packed.append('\x00' * 3)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_get_mirroring_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 4)
-        obj.report_mirror_ports = reader.read("!B")[0]
-        reader.skip(3)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.report_mirror_ports != other.report_mirror_ports: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_get_mirroring_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("report_mirror_ports = ");
-                q.text("%#x" % self.report_mirror_ports)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[4] = bsn_get_mirroring_request
-
-class bsn_get_switch_pipeline_reply(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 52
-
-    def __init__(self, xid=None, pipeline=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if pipeline != None:
-            self.pipeline = pipeline
-        else:
-            self.pipeline = ""
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!256s", self.pipeline))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_get_switch_pipeline_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 52)
-        obj.pipeline = reader.read("!256s")[0].rstrip("\x00")
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.pipeline != other.pipeline: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_get_switch_pipeline_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("pipeline = ");
-                q.pp(self.pipeline)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[52] = bsn_get_switch_pipeline_reply
-
-class bsn_get_switch_pipeline_request(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 51
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_get_switch_pipeline_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 51)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_get_switch_pipeline_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[51] = bsn_get_switch_pipeline_request
-
-class bsn_image_desc_stats_reply(bsn_stats_reply):
-    version = 4
-    type = 19
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 14
-
-    def __init__(self, xid=None, flags=None, image_checksum=None, startup_config_checksum=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if image_checksum != None:
-            self.image_checksum = image_checksum
-        else:
-            self.image_checksum = ""
-        if startup_config_checksum != None:
-            self.startup_config_checksum = startup_config_checksum
-        else:
-            self.startup_config_checksum = ""
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!256s", self.image_checksum))
-        packed.append(struct.pack("!256s", self.startup_config_checksum))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_image_desc_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 14)
-        obj.image_checksum = reader.read("!256s")[0].rstrip("\x00")
-        obj.startup_config_checksum = reader.read("!256s")[0].rstrip("\x00")
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.image_checksum != other.image_checksum: return False
-        if self.startup_config_checksum != other.startup_config_checksum: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_image_desc_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("image_checksum = ");
-                q.pp(self.image_checksum)
-                q.text(","); q.breakable()
-                q.text("startup_config_checksum = ");
-                q.pp(self.startup_config_checksum)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_reply.subtypes[14] = bsn_image_desc_stats_reply
-
-class bsn_image_desc_stats_request(bsn_stats_request):
-    version = 4
-    type = 18
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 14
-
-    def __init__(self, xid=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_image_desc_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 14)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_image_desc_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_request.subtypes[14] = bsn_image_desc_stats_request
-
-class bsn_lacp_convergence_notif(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 43
-
-    def __init__(self, xid=None, convergence_status=None, port_no=None, actor_sys_priority=None, actor_sys_mac=None, actor_port_priority=None, actor_port_num=None, actor_key=None, partner_sys_priority=None, partner_sys_mac=None, partner_port_priority=None, partner_port_num=None, partner_key=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if convergence_status != None:
-            self.convergence_status = convergence_status
-        else:
-            self.convergence_status = 0
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if actor_sys_priority != None:
-            self.actor_sys_priority = actor_sys_priority
-        else:
-            self.actor_sys_priority = 0
-        if actor_sys_mac != None:
-            self.actor_sys_mac = actor_sys_mac
-        else:
-            self.actor_sys_mac = [0,0,0,0,0,0]
-        if actor_port_priority != None:
-            self.actor_port_priority = actor_port_priority
-        else:
-            self.actor_port_priority = 0
-        if actor_port_num != None:
-            self.actor_port_num = actor_port_num
-        else:
-            self.actor_port_num = 0
-        if actor_key != None:
-            self.actor_key = actor_key
-        else:
-            self.actor_key = 0
-        if partner_sys_priority != None:
-            self.partner_sys_priority = partner_sys_priority
-        else:
-            self.partner_sys_priority = 0
-        if partner_sys_mac != None:
-            self.partner_sys_mac = partner_sys_mac
-        else:
-            self.partner_sys_mac = [0,0,0,0,0,0]
-        if partner_port_priority != None:
-            self.partner_port_priority = partner_port_priority
-        else:
-            self.partner_port_priority = 0
-        if partner_port_num != None:
-            self.partner_port_num = partner_port_num
-        else:
-            self.partner_port_num = 0
-        if partner_key != None:
-            self.partner_key = partner_key
-        else:
-            self.partner_key = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!B", self.convergence_status))
-        packed.append('\x00' * 3)
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(struct.pack("!H", self.actor_sys_priority))
-        packed.append(struct.pack("!6B", *self.actor_sys_mac))
-        packed.append(struct.pack("!H", self.actor_port_priority))
-        packed.append(struct.pack("!H", self.actor_port_num))
-        packed.append(struct.pack("!H", self.actor_key))
-        packed.append(struct.pack("!H", self.partner_sys_priority))
-        packed.append(struct.pack("!6B", *self.partner_sys_mac))
-        packed.append(struct.pack("!H", self.partner_port_priority))
-        packed.append(struct.pack("!H", self.partner_port_num))
-        packed.append(struct.pack("!H", self.partner_key))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_lacp_convergence_notif()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 43)
-        obj.convergence_status = reader.read("!B")[0]
-        reader.skip(3)
-        obj.port_no = util.unpack_port_no(reader)
-        obj.actor_sys_priority = reader.read("!H")[0]
-        obj.actor_sys_mac = list(reader.read('!6B'))
-        obj.actor_port_priority = reader.read("!H")[0]
-        obj.actor_port_num = reader.read("!H")[0]
-        obj.actor_key = reader.read("!H")[0]
-        obj.partner_sys_priority = reader.read("!H")[0]
-        obj.partner_sys_mac = list(reader.read('!6B'))
-        obj.partner_port_priority = reader.read("!H")[0]
-        obj.partner_port_num = reader.read("!H")[0]
-        obj.partner_key = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.convergence_status != other.convergence_status: return False
-        if self.port_no != other.port_no: return False
-        if self.actor_sys_priority != other.actor_sys_priority: return False
-        if self.actor_sys_mac != other.actor_sys_mac: return False
-        if self.actor_port_priority != other.actor_port_priority: return False
-        if self.actor_port_num != other.actor_port_num: return False
-        if self.actor_key != other.actor_key: return False
-        if self.partner_sys_priority != other.partner_sys_priority: return False
-        if self.partner_sys_mac != other.partner_sys_mac: return False
-        if self.partner_port_priority != other.partner_port_priority: return False
-        if self.partner_port_num != other.partner_port_num: return False
-        if self.partner_key != other.partner_key: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_lacp_convergence_notif {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("convergence_status = ");
-                q.text("%#x" % self.convergence_status)
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("actor_sys_priority = ");
-                q.text("%#x" % self.actor_sys_priority)
-                q.text(","); q.breakable()
-                q.text("actor_sys_mac = ");
-                q.text(util.pretty_mac(self.actor_sys_mac))
-                q.text(","); q.breakable()
-                q.text("actor_port_priority = ");
-                q.text("%#x" % self.actor_port_priority)
-                q.text(","); q.breakable()
-                q.text("actor_port_num = ");
-                q.text("%#x" % self.actor_port_num)
-                q.text(","); q.breakable()
-                q.text("actor_key = ");
-                q.text("%#x" % self.actor_key)
-                q.text(","); q.breakable()
-                q.text("partner_sys_priority = ");
-                q.text("%#x" % self.partner_sys_priority)
-                q.text(","); q.breakable()
-                q.text("partner_sys_mac = ");
-                q.text(util.pretty_mac(self.partner_sys_mac))
-                q.text(","); q.breakable()
-                q.text("partner_port_priority = ");
-                q.text("%#x" % self.partner_port_priority)
-                q.text(","); q.breakable()
-                q.text("partner_port_num = ");
-                q.text("%#x" % self.partner_port_num)
-                q.text(","); q.breakable()
-                q.text("partner_key = ");
-                q.text("%#x" % self.partner_key)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[43] = bsn_lacp_convergence_notif
-
-class bsn_lacp_stats_reply(bsn_stats_reply):
-    version = 4
-    type = 19
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 1
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_lacp_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 1)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.bsn_lacp_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_lacp_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_reply.subtypes[1] = bsn_lacp_stats_reply
-
-class bsn_lacp_stats_request(bsn_stats_request):
-    version = 4
-    type = 18
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 1
-
-    def __init__(self, xid=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_lacp_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 1)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_lacp_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_request.subtypes[1] = bsn_lacp_stats_request
-
-class bsn_log(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 63
-
-    def __init__(self, xid=None, loglevel=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if loglevel != None:
-            self.loglevel = loglevel
-        else:
-            self.loglevel = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!B", self.loglevel))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_log()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 63)
-        obj.loglevel = reader.read("!B")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.loglevel != other.loglevel: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_log {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("loglevel = ");
-                q.text("%#x" % self.loglevel)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[63] = bsn_log
-
-class bsn_lua_command_reply(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 66
-
-    def __init__(self, xid=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_lua_command_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 66)
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_lua_command_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[66] = bsn_lua_command_reply
-
-class bsn_lua_command_request(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 65
-
-    def __init__(self, xid=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_lua_command_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 65)
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_lua_command_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[65] = bsn_lua_command_request
-
-class bsn_lua_notification(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 67
-
-    def __init__(self, xid=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_lua_notification()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 67)
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_lua_notification {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[67] = bsn_lua_notification
-
-class bsn_lua_upload(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 64
-
-    def __init__(self, xid=None, flags=None, filename=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if filename != None:
-            self.filename = filename
-        else:
-            self.filename = ""
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append(struct.pack("!64s", self.filename))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_lua_upload()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 64)
-        obj.flags = reader.read("!H")[0]
-        obj.filename = reader.read("!64s")[0].rstrip("\x00")
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.filename != other.filename: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_lua_upload {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("filename = ");
-                q.pp(self.filename)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[64] = bsn_lua_upload
-
-class bsn_pdu_rx_reply(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 34
-
-    def __init__(self, xid=None, status=None, port_no=None, slot_num=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if status != None:
-            self.status = status
-        else:
-            self.status = 0
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if slot_num != None:
-            self.slot_num = slot_num
-        else:
-            self.slot_num = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.status))
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(struct.pack("!B", self.slot_num))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_pdu_rx_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 34)
-        obj.status = reader.read("!L")[0]
-        obj.port_no = util.unpack_port_no(reader)
-        obj.slot_num = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.status != other.status: return False
-        if self.port_no != other.port_no: return False
-        if self.slot_num != other.slot_num: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_pdu_rx_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("status = ");
-                q.text("%#x" % self.status)
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("slot_num = ");
-                q.text("%#x" % self.slot_num)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[34] = bsn_pdu_rx_reply
-
-class bsn_pdu_rx_request(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 33
-
-    def __init__(self, xid=None, timeout_ms=None, port_no=None, slot_num=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if timeout_ms != None:
-            self.timeout_ms = timeout_ms
-        else:
-            self.timeout_ms = 0
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if slot_num != None:
-            self.slot_num = slot_num
-        else:
-            self.slot_num = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.timeout_ms))
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(struct.pack("!B", self.slot_num))
-        packed.append('\x00' * 3)
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_pdu_rx_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 33)
-        obj.timeout_ms = reader.read("!L")[0]
-        obj.port_no = util.unpack_port_no(reader)
-        obj.slot_num = reader.read("!B")[0]
-        reader.skip(3)
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.timeout_ms != other.timeout_ms: return False
-        if self.port_no != other.port_no: return False
-        if self.slot_num != other.slot_num: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_pdu_rx_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("timeout_ms = ");
-                q.text("%#x" % self.timeout_ms)
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("slot_num = ");
-                q.text("%#x" % self.slot_num)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[33] = bsn_pdu_rx_request
-
-class bsn_pdu_rx_timeout(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 35
-
-    def __init__(self, xid=None, port_no=None, slot_num=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if slot_num != None:
-            self.slot_num = slot_num
-        else:
-            self.slot_num = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(struct.pack("!B", self.slot_num))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_pdu_rx_timeout()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 35)
-        obj.port_no = util.unpack_port_no(reader)
-        obj.slot_num = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.port_no != other.port_no: return False
-        if self.slot_num != other.slot_num: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_pdu_rx_timeout {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("slot_num = ");
-                q.text("%#x" % self.slot_num)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[35] = bsn_pdu_rx_timeout
-
-class bsn_pdu_tx_reply(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 32
-
-    def __init__(self, xid=None, status=None, port_no=None, slot_num=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if status != None:
-            self.status = status
-        else:
-            self.status = 0
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if slot_num != None:
-            self.slot_num = slot_num
-        else:
-            self.slot_num = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.status))
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(struct.pack("!B", self.slot_num))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_pdu_tx_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 32)
-        obj.status = reader.read("!L")[0]
-        obj.port_no = util.unpack_port_no(reader)
-        obj.slot_num = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.status != other.status: return False
-        if self.port_no != other.port_no: return False
-        if self.slot_num != other.slot_num: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_pdu_tx_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("status = ");
-                q.text("%#x" % self.status)
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("slot_num = ");
-                q.text("%#x" % self.slot_num)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[32] = bsn_pdu_tx_reply
-
-class bsn_pdu_tx_request(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 31
-
-    def __init__(self, xid=None, tx_interval_ms=None, port_no=None, slot_num=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if tx_interval_ms != None:
-            self.tx_interval_ms = tx_interval_ms
-        else:
-            self.tx_interval_ms = 0
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if slot_num != None:
-            self.slot_num = slot_num
-        else:
-            self.slot_num = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.tx_interval_ms))
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(struct.pack("!B", self.slot_num))
-        packed.append('\x00' * 3)
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_pdu_tx_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 31)
-        obj.tx_interval_ms = reader.read("!L")[0]
-        obj.port_no = util.unpack_port_no(reader)
-        obj.slot_num = reader.read("!B")[0]
-        reader.skip(3)
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.tx_interval_ms != other.tx_interval_ms: return False
-        if self.port_no != other.port_no: return False
-        if self.slot_num != other.slot_num: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_pdu_tx_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("tx_interval_ms = ");
-                q.text("%#x" % self.tx_interval_ms)
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("slot_num = ");
-                q.text("%#x" % self.slot_num)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[31] = bsn_pdu_tx_request
-
-class bsn_port_counter_stats_reply(bsn_stats_reply):
-    version = 4
-    type = 19
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 8
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_port_counter_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 8)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.bsn_port_counter_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_port_counter_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_reply.subtypes[8] = bsn_port_counter_stats_reply
-
-class bsn_port_counter_stats_request(bsn_stats_request):
-    version = 4
-    type = 18
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 8
-
-    def __init__(self, xid=None, flags=None, port_no=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(util.pack_port_no(self.port_no))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_port_counter_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 8)
-        obj.port_no = util.unpack_port_no(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.port_no != other.port_no: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_port_counter_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-            q.breakable()
-        q.text('}')
-
-bsn_stats_request.subtypes[8] = bsn_port_counter_stats_request
-
-class bsn_role_status(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 55
-
-    def __init__(self, xid=None, role=None, reason=None, generation_id=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if role != None:
-            self.role = role
-        else:
-            self.role = 0
-        if reason != None:
-            self.reason = reason
-        else:
-            self.reason = 0
-        if generation_id != None:
-            self.generation_id = generation_id
-        else:
-            self.generation_id = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.role))
-        packed.append(struct.pack("!B", self.reason))
-        packed.append('\x00' * 3)
-        packed.append(struct.pack("!Q", self.generation_id))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_role_status()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 55)
-        obj.role = reader.read("!L")[0]
-        obj.reason = reader.read("!B")[0]
-        reader.skip(3)
-        obj.generation_id = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.role != other.role: return False
-        if self.reason != other.reason: return False
-        if self.generation_id != other.generation_id: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_role_status {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("role = ");
-                q.text("%#x" % self.role)
-                q.text(","); q.breakable()
-                q.text("reason = ");
-                q.text("%#x" % self.reason)
-                q.text(","); q.breakable()
-                q.text("generation_id = ");
-                q.text("%#x" % self.generation_id)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[55] = bsn_role_status
-
-class bsn_set_aux_cxns_reply(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 59
-
-    def __init__(self, xid=None, num_aux=None, status=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if num_aux != None:
-            self.num_aux = num_aux
-        else:
-            self.num_aux = 0
-        if status != None:
-            self.status = status
-        else:
-            self.status = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.num_aux))
-        packed.append(struct.pack("!L", self.status))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_set_aux_cxns_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 59)
-        obj.num_aux = reader.read("!L")[0]
-        obj.status = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.num_aux != other.num_aux: return False
-        if self.status != other.status: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_set_aux_cxns_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("num_aux = ");
-                q.text("%#x" % self.num_aux)
-                q.text(","); q.breakable()
-                q.text("status = ");
-                q.text("%#x" % self.status)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[59] = bsn_set_aux_cxns_reply
-
-class bsn_set_aux_cxns_request(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 58
-
-    def __init__(self, xid=None, num_aux=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if num_aux != None:
-            self.num_aux = num_aux
-        else:
-            self.num_aux = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.num_aux))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_set_aux_cxns_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 58)
-        obj.num_aux = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.num_aux != other.num_aux: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_set_aux_cxns_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("num_aux = ");
-                q.text("%#x" % self.num_aux)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[58] = bsn_set_aux_cxns_request
-
-class bsn_set_lacp_reply(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 42
-
-    def __init__(self, xid=None, status=None, port_no=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if status != None:
-            self.status = status
-        else:
-            self.status = 0
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.status))
-        packed.append(util.pack_port_no(self.port_no))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_set_lacp_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 42)
-        obj.status = reader.read("!L")[0]
-        obj.port_no = util.unpack_port_no(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.status != other.status: return False
-        if self.port_no != other.port_no: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_set_lacp_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("status = ");
-                q.text("%#x" % self.status)
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[42] = bsn_set_lacp_reply
-
-class bsn_set_lacp_request(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 41
-
-    def __init__(self, xid=None, enabled=None, port_no=None, actor_sys_priority=None, actor_sys_mac=None, actor_port_priority=None, actor_port_num=None, actor_key=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if enabled != None:
-            self.enabled = enabled
-        else:
-            self.enabled = 0
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if actor_sys_priority != None:
-            self.actor_sys_priority = actor_sys_priority
-        else:
-            self.actor_sys_priority = 0
-        if actor_sys_mac != None:
-            self.actor_sys_mac = actor_sys_mac
-        else:
-            self.actor_sys_mac = [0,0,0,0,0,0]
-        if actor_port_priority != None:
-            self.actor_port_priority = actor_port_priority
-        else:
-            self.actor_port_priority = 0
-        if actor_port_num != None:
-            self.actor_port_num = actor_port_num
-        else:
-            self.actor_port_num = 0
-        if actor_key != None:
-            self.actor_key = actor_key
-        else:
-            self.actor_key = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!B", self.enabled))
-        packed.append('\x00' * 3)
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(struct.pack("!H", self.actor_sys_priority))
-        packed.append(struct.pack("!6B", *self.actor_sys_mac))
-        packed.append(struct.pack("!H", self.actor_port_priority))
-        packed.append(struct.pack("!H", self.actor_port_num))
-        packed.append(struct.pack("!H", self.actor_key))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_set_lacp_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 41)
-        obj.enabled = reader.read("!B")[0]
-        reader.skip(3)
-        obj.port_no = util.unpack_port_no(reader)
-        obj.actor_sys_priority = reader.read("!H")[0]
-        obj.actor_sys_mac = list(reader.read('!6B'))
-        obj.actor_port_priority = reader.read("!H")[0]
-        obj.actor_port_num = reader.read("!H")[0]
-        obj.actor_key = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.enabled != other.enabled: return False
-        if self.port_no != other.port_no: return False
-        if self.actor_sys_priority != other.actor_sys_priority: return False
-        if self.actor_sys_mac != other.actor_sys_mac: return False
-        if self.actor_port_priority != other.actor_port_priority: return False
-        if self.actor_port_num != other.actor_port_num: return False
-        if self.actor_key != other.actor_key: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_set_lacp_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("enabled = ");
-                q.text("%#x" % self.enabled)
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("actor_sys_priority = ");
-                q.text("%#x" % self.actor_sys_priority)
-                q.text(","); q.breakable()
-                q.text("actor_sys_mac = ");
-                q.text(util.pretty_mac(self.actor_sys_mac))
-                q.text(","); q.breakable()
-                q.text("actor_port_priority = ");
-                q.text("%#x" % self.actor_port_priority)
-                q.text(","); q.breakable()
-                q.text("actor_port_num = ");
-                q.text("%#x" % self.actor_port_num)
-                q.text(","); q.breakable()
-                q.text("actor_key = ");
-                q.text("%#x" % self.actor_key)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[41] = bsn_set_lacp_request
-
-class bsn_set_mirroring(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 3
-
-    def __init__(self, xid=None, report_mirror_ports=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if report_mirror_ports != None:
-            self.report_mirror_ports = report_mirror_ports
-        else:
-            self.report_mirror_ports = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!B", self.report_mirror_ports))
-        packed.append('\x00' * 3)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_set_mirroring()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 3)
-        obj.report_mirror_ports = reader.read("!B")[0]
-        reader.skip(3)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.report_mirror_ports != other.report_mirror_ports: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_set_mirroring {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("report_mirror_ports = ");
-                q.text("%#x" % self.report_mirror_ports)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[3] = bsn_set_mirroring
-
-class bsn_set_pktin_suppression_reply(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 25
-
-    def __init__(self, xid=None, status=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if status != None:
-            self.status = status
-        else:
-            self.status = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.status))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_set_pktin_suppression_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 25)
-        obj.status = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.status != other.status: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_set_pktin_suppression_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("status = ");
-                q.text("%#x" % self.status)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[25] = bsn_set_pktin_suppression_reply
-
-class bsn_set_pktin_suppression_request(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 11
-
-    def __init__(self, xid=None, enabled=None, idle_timeout=None, hard_timeout=None, priority=None, cookie=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if enabled != None:
-            self.enabled = enabled
-        else:
-            self.enabled = 0
-        if idle_timeout != None:
-            self.idle_timeout = idle_timeout
-        else:
-            self.idle_timeout = 0
-        if hard_timeout != None:
-            self.hard_timeout = hard_timeout
-        else:
-            self.hard_timeout = 0
-        if priority != None:
-            self.priority = priority
-        else:
-            self.priority = 0
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!B", self.enabled))
-        packed.append('\x00' * 1)
-        packed.append(struct.pack("!H", self.idle_timeout))
-        packed.append(struct.pack("!H", self.hard_timeout))
-        packed.append(struct.pack("!H", self.priority))
-        packed.append(struct.pack("!Q", self.cookie))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_set_pktin_suppression_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 11)
-        obj.enabled = reader.read("!B")[0]
-        reader.skip(1)
-        obj.idle_timeout = reader.read("!H")[0]
-        obj.hard_timeout = reader.read("!H")[0]
-        obj.priority = reader.read("!H")[0]
-        obj.cookie = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.enabled != other.enabled: return False
-        if self.idle_timeout != other.idle_timeout: return False
-        if self.hard_timeout != other.hard_timeout: return False
-        if self.priority != other.priority: return False
-        if self.cookie != other.cookie: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_set_pktin_suppression_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("enabled = ");
-                q.text("%#x" % self.enabled)
-                q.text(","); q.breakable()
-                q.text("idle_timeout = ");
-                q.text("%#x" % self.idle_timeout)
-                q.text(","); q.breakable()
-                q.text("hard_timeout = ");
-                q.text("%#x" % self.hard_timeout)
-                q.text(","); q.breakable()
-                q.text("priority = ");
-                q.text("%#x" % self.priority)
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[11] = bsn_set_pktin_suppression_request
-
-class bsn_set_switch_pipeline_reply(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 54
-
-    def __init__(self, xid=None, status=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if status != None:
-            self.status = status
-        else:
-            self.status = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.status))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_set_switch_pipeline_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 54)
-        obj.status = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.status != other.status: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_set_switch_pipeline_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("status = ");
-                q.text("%#x" % self.status)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[54] = bsn_set_switch_pipeline_reply
-
-class bsn_set_switch_pipeline_request(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 53
-
-    def __init__(self, xid=None, pipeline=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if pipeline != None:
-            self.pipeline = pipeline
-        else:
-            self.pipeline = ""
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!256s", self.pipeline))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_set_switch_pipeline_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 53)
-        obj.pipeline = reader.read("!256s")[0].rstrip("\x00")
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.pipeline != other.pipeline: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_set_switch_pipeline_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("pipeline = ");
-                q.pp(self.pipeline)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[53] = bsn_set_switch_pipeline_request
-
-class bsn_switch_pipeline_stats_reply(bsn_stats_reply):
-    version = 4
-    type = 19
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 6
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_switch_pipeline_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 6)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.bsn_switch_pipeline_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_switch_pipeline_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_reply.subtypes[6] = bsn_switch_pipeline_stats_reply
-
-class bsn_switch_pipeline_stats_request(bsn_stats_request):
-    version = 4
-    type = 18
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 6
-
-    def __init__(self, xid=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_switch_pipeline_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 6)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_switch_pipeline_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_request.subtypes[6] = bsn_switch_pipeline_stats_request
-
-class bsn_table_checksum_stats_reply(bsn_stats_reply):
-    version = 4
-    type = 19
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 11
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_table_checksum_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 11)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.bsn_table_checksum_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_table_checksum_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_reply.subtypes[11] = bsn_table_checksum_stats_reply
-
-class bsn_table_checksum_stats_request(bsn_stats_request):
-    version = 4
-    type = 18
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 11
-
-    def __init__(self, xid=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_table_checksum_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 11)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_table_checksum_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_request.subtypes[11] = bsn_table_checksum_stats_request
-
-class bsn_table_set_buckets_size(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 61
-
-    def __init__(self, xid=None, table_id=None, buckets_size=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if buckets_size != None:
-            self.buckets_size = buckets_size
-        else:
-            self.buckets_size = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append('\x00' * 1)
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append('\x00' * 2)
-        packed.append(struct.pack("!L", self.buckets_size))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_table_set_buckets_size()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 61)
-        reader.skip(1)
-        obj.table_id = reader.read("!B")[0]
-        reader.skip(2)
-        obj.buckets_size = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.table_id != other.table_id: return False
-        if self.buckets_size != other.buckets_size: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_table_set_buckets_size {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("buckets_size = ");
-                q.text("%#x" % self.buckets_size)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[61] = bsn_table_set_buckets_size
-
-class bsn_time_reply(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 45
-
-    def __init__(self, xid=None, time_ms=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if time_ms != None:
-            self.time_ms = time_ms
-        else:
-            self.time_ms = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!Q", self.time_ms))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_time_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 45)
-        obj.time_ms = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.time_ms != other.time_ms: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_time_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("time_ms = ");
-                q.text("%#x" % self.time_ms)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[45] = bsn_time_reply
-
-class bsn_time_request(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 44
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_time_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 44)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_time_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[44] = bsn_time_request
-
-class bsn_virtual_port_create_reply(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 16
-
-    def __init__(self, xid=None, status=None, vport_no=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if status != None:
-            self.status = status
-        else:
-            self.status = 0
-        if vport_no != None:
-            self.vport_no = vport_no
-        else:
-            self.vport_no = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.status))
-        packed.append(struct.pack("!L", self.vport_no))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_virtual_port_create_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 16)
-        obj.status = reader.read("!L")[0]
-        obj.vport_no = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.status != other.status: return False
-        if self.vport_no != other.vport_no: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_virtual_port_create_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("status = ");
-                q.text("%#x" % self.status)
-                q.text(","); q.breakable()
-                q.text("vport_no = ");
-                q.text("%#x" % self.vport_no)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[16] = bsn_virtual_port_create_reply
-
-class bsn_virtual_port_create_request(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 15
-
-    def __init__(self, xid=None, vport=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if vport != None:
-            self.vport = vport
-        else:
-            self.vport = ofp.bsn_vport()
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(self.vport.pack())
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_virtual_port_create_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 15)
-        obj.vport = ofp.bsn_vport.unpack(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.vport != other.vport: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_virtual_port_create_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("vport = ");
-                q.pp(self.vport)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[15] = bsn_virtual_port_create_request
-
-class bsn_virtual_port_remove_reply(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 26
-
-    def __init__(self, xid=None, status=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if status != None:
-            self.status = status
-        else:
-            self.status = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.status))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_virtual_port_remove_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 26)
-        obj.status = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.status != other.status: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_virtual_port_remove_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("status = ");
-                q.text("%#x" % self.status)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[26] = bsn_virtual_port_remove_reply
-
-class bsn_virtual_port_remove_request(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 17
-
-    def __init__(self, xid=None, vport_no=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if vport_no != None:
-            self.vport_no = vport_no
-        else:
-            self.vport_no = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.vport_no))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_virtual_port_remove_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 17)
-        obj.vport_no = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.vport_no != other.vport_no: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_virtual_port_remove_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("vport_no = ");
-                q.text("%#x" % self.vport_no)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[17] = bsn_virtual_port_remove_request
-
-class bsn_vlan_counter_clear(bsn_header):
-    version = 4
-    type = 4
-    experimenter = 6035143
-    subtype = 70
-
-    def __init__(self, xid=None, vlan_vid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if vlan_vid != None:
-            self.vlan_vid = vlan_vid
-        else:
-            self.vlan_vid = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!H", self.vlan_vid))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_vlan_counter_clear()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 70)
-        obj.vlan_vid = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.vlan_vid != other.vlan_vid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vlan_counter_clear {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("vlan_vid = ");
-                q.text("%#x" % self.vlan_vid)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[70] = bsn_vlan_counter_clear
-
-class bsn_vlan_counter_stats_reply(bsn_stats_reply):
-    version = 4
-    type = 19
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 9
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_vlan_counter_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 9)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.bsn_vlan_counter_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vlan_counter_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_reply.subtypes[9] = bsn_vlan_counter_stats_reply
-
-class bsn_vlan_counter_stats_request(bsn_stats_request):
-    version = 4
-    type = 18
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 9
-
-    def __init__(self, xid=None, flags=None, vlan_vid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if vlan_vid != None:
-            self.vlan_vid = vlan_vid
-        else:
-            self.vlan_vid = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!H", self.vlan_vid))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_vlan_counter_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 9)
-        obj.vlan_vid = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.vlan_vid != other.vlan_vid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vlan_counter_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("vlan_vid = ");
-                q.text("%#x" % self.vlan_vid)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_request.subtypes[9] = bsn_vlan_counter_stats_request
-
-class bsn_vrf_counter_stats_reply(bsn_stats_reply):
-    version = 4
-    type = 19
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 15
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_vrf_counter_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 15)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.bsn_vrf_counter_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vrf_counter_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_reply.subtypes[15] = bsn_vrf_counter_stats_reply
-
-class bsn_vrf_counter_stats_request(bsn_stats_request):
-    version = 4
-    type = 18
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 15
-
-    def __init__(self, xid=None, flags=None, vrf=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if vrf != None:
-            self.vrf = vrf
-        else:
-            self.vrf = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.vrf))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_vrf_counter_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 15)
-        obj.vrf = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.vrf != other.vrf: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vrf_counter_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("vrf = ");
-                q.text("%#x" % self.vrf)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_request.subtypes[15] = bsn_vrf_counter_stats_request
-
-class desc_stats_reply(stats_reply):
-    version = 4
-    type = 19
-    stats_type = 0
-
-    def __init__(self, xid=None, flags=None, mfr_desc=None, hw_desc=None, sw_desc=None, serial_num=None, dp_desc=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if mfr_desc != None:
-            self.mfr_desc = mfr_desc
-        else:
-            self.mfr_desc = ""
-        if hw_desc != None:
-            self.hw_desc = hw_desc
-        else:
-            self.hw_desc = ""
-        if sw_desc != None:
-            self.sw_desc = sw_desc
-        else:
-            self.sw_desc = ""
-        if serial_num != None:
-            self.serial_num = serial_num
-        else:
-            self.serial_num = ""
-        if dp_desc != None:
-            self.dp_desc = dp_desc
-        else:
-            self.dp_desc = ""
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!256s", self.mfr_desc))
-        packed.append(struct.pack("!256s", self.hw_desc))
-        packed.append(struct.pack("!256s", self.sw_desc))
-        packed.append(struct.pack("!32s", self.serial_num))
-        packed.append(struct.pack("!256s", self.dp_desc))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = desc_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 0)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.mfr_desc = reader.read("!256s")[0].rstrip("\x00")
-        obj.hw_desc = reader.read("!256s")[0].rstrip("\x00")
-        obj.sw_desc = reader.read("!256s")[0].rstrip("\x00")
-        obj.serial_num = reader.read("!32s")[0].rstrip("\x00")
-        obj.dp_desc = reader.read("!256s")[0].rstrip("\x00")
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.mfr_desc != other.mfr_desc: return False
-        if self.hw_desc != other.hw_desc: return False
-        if self.sw_desc != other.sw_desc: return False
-        if self.serial_num != other.serial_num: return False
-        if self.dp_desc != other.dp_desc: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("desc_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("mfr_desc = ");
-                q.pp(self.mfr_desc)
-                q.text(","); q.breakable()
-                q.text("hw_desc = ");
-                q.pp(self.hw_desc)
-                q.text(","); q.breakable()
-                q.text("sw_desc = ");
-                q.pp(self.sw_desc)
-                q.text(","); q.breakable()
-                q.text("serial_num = ");
-                q.pp(self.serial_num)
-                q.text(","); q.breakable()
-                q.text("dp_desc = ");
-                q.pp(self.dp_desc)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[0] = desc_stats_reply
-
-class desc_stats_request(stats_request):
-    version = 4
-    type = 18
-    stats_type = 0
-
-    def __init__(self, xid=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = desc_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 0)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("desc_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[0] = desc_stats_request
-
-class echo_reply(message):
-    version = 4
-    type = 3
-
-    def __init__(self, xid=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = echo_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 3)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("echo_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[3] = echo_reply
-
-class echo_request(message):
-    version = 4
-    type = 2
-
-    def __init__(self, xid=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = echo_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 2)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("echo_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[2] = echo_request
-
-class features_reply(message):
-    version = 4
-    type = 6
-
-    def __init__(self, xid=None, datapath_id=None, n_buffers=None, n_tables=None, auxiliary_id=None, capabilities=None, reserved=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if datapath_id != None:
-            self.datapath_id = datapath_id
-        else:
-            self.datapath_id = 0
-        if n_buffers != None:
-            self.n_buffers = n_buffers
-        else:
-            self.n_buffers = 0
-        if n_tables != None:
-            self.n_tables = n_tables
-        else:
-            self.n_tables = 0
-        if auxiliary_id != None:
-            self.auxiliary_id = auxiliary_id
-        else:
-            self.auxiliary_id = 0
-        if capabilities != None:
-            self.capabilities = capabilities
-        else:
-            self.capabilities = 0
-        if reserved != None:
-            self.reserved = reserved
-        else:
-            self.reserved = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!Q", self.datapath_id))
-        packed.append(struct.pack("!L", self.n_buffers))
-        packed.append(struct.pack("!B", self.n_tables))
-        packed.append(struct.pack("!B", self.auxiliary_id))
-        packed.append('\x00' * 2)
-        packed.append(struct.pack("!L", self.capabilities))
-        packed.append(struct.pack("!L", self.reserved))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = features_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 6)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.datapath_id = reader.read("!Q")[0]
-        obj.n_buffers = reader.read("!L")[0]
-        obj.n_tables = reader.read("!B")[0]
-        obj.auxiliary_id = reader.read("!B")[0]
-        reader.skip(2)
-        obj.capabilities = reader.read("!L")[0]
-        obj.reserved = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.datapath_id != other.datapath_id: return False
-        if self.n_buffers != other.n_buffers: return False
-        if self.n_tables != other.n_tables: return False
-        if self.auxiliary_id != other.auxiliary_id: return False
-        if self.capabilities != other.capabilities: return False
-        if self.reserved != other.reserved: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("features_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("datapath_id = ");
-                q.text("%#x" % self.datapath_id)
-                q.text(","); q.breakable()
-                q.text("n_buffers = ");
-                q.text("%#x" % self.n_buffers)
-                q.text(","); q.breakable()
-                q.text("n_tables = ");
-                q.text("%#x" % self.n_tables)
-                q.text(","); q.breakable()
-                q.text("auxiliary_id = ");
-                q.text("%#x" % self.auxiliary_id)
-                q.text(","); q.breakable()
-                q.text("capabilities = ");
-                q.text("%#x" % self.capabilities)
-                q.text(","); q.breakable()
-                q.text("reserved = ");
-                q.text("%#x" % self.reserved)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[6] = features_reply
-
-class features_request(message):
-    version = 4
-    type = 5
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = features_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 5)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("features_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-message.subtypes[5] = features_request
-
-class flow_mod(message):
-    subtypes = {}
-
-    version = 4
-    type = 14
-
-    def __init__(self, xid=None, cookie=None, cookie_mask=None, table_id=None, _command=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, out_group=None, flags=None, match=None, instructions=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if cookie_mask != None:
-            self.cookie_mask = cookie_mask
-        else:
-            self.cookie_mask = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if _command != None:
-            self._command = _command
-        else:
-            self._command = 0
-        if idle_timeout != None:
-            self.idle_timeout = idle_timeout
-        else:
-            self.idle_timeout = 0
-        if hard_timeout != None:
-            self.hard_timeout = hard_timeout
-        else:
-            self.hard_timeout = 0
-        if priority != None:
-            self.priority = priority
-        else:
-            self.priority = 0
-        if buffer_id != None:
-            self.buffer_id = buffer_id
-        else:
-            self.buffer_id = 0
-        if out_port != None:
-            self.out_port = out_port
-        else:
-            self.out_port = 0
-        if out_group != None:
-            self.out_group = out_group
-        else:
-            self.out_group = 0
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        if instructions != None:
-            self.instructions = instructions
-        else:
-            self.instructions = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(struct.pack("!Q", self.cookie_mask))
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append(util.pack_fm_cmd(self._command))
-        packed.append(struct.pack("!H", self.idle_timeout))
-        packed.append(struct.pack("!H", self.hard_timeout))
-        packed.append(struct.pack("!H", self.priority))
-        packed.append(struct.pack("!L", self.buffer_id))
-        packed.append(util.pack_port_no(self.out_port))
-        packed.append(struct.pack("!L", self.out_group))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 2)
-        packed.append(self.match.pack())
-        packed.append(loxi.generic_util.pack_list(self.instructions))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('B', 25)
-        subclass = flow_mod.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = flow_mod()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 14)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.cookie = reader.read("!Q")[0]
-        obj.cookie_mask = reader.read("!Q")[0]
-        obj.table_id = reader.read("!B")[0]
-        obj._command = util.unpack_fm_cmd(reader)
-        obj.idle_timeout = reader.read("!H")[0]
-        obj.hard_timeout = reader.read("!H")[0]
-        obj.priority = reader.read("!H")[0]
-        obj.buffer_id = reader.read("!L")[0]
-        obj.out_port = util.unpack_port_no(reader)
-        obj.out_group = reader.read("!L")[0]
-        obj.flags = reader.read("!H")[0]
-        reader.skip(2)
-        obj.match = ofp.match.unpack(reader)
-        obj.instructions = loxi.generic_util.unpack_list(reader, ofp.instruction.instruction.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.cookie != other.cookie: return False
-        if self.cookie_mask != other.cookie_mask: return False
-        if self.table_id != other.table_id: return False
-        if self._command != other._command: return False
-        if self.idle_timeout != other.idle_timeout: return False
-        if self.hard_timeout != other.hard_timeout: return False
-        if self.priority != other.priority: return False
-        if self.buffer_id != other.buffer_id: return False
-        if self.out_port != other.out_port: return False
-        if self.out_group != other.out_group: return False
-        if self.flags != other.flags: return False
-        if self.match != other.match: return False
-        if self.instructions != other.instructions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_mod {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("cookie_mask = ");
-                q.text("%#x" % self.cookie_mask)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("idle_timeout = ");
-                q.text("%#x" % self.idle_timeout)
-                q.text(","); q.breakable()
-                q.text("hard_timeout = ");
-                q.text("%#x" % self.hard_timeout)
-                q.text(","); q.breakable()
-                q.text("priority = ");
-                q.text("%#x" % self.priority)
-                q.text(","); q.breakable()
-                q.text("buffer_id = ");
-                q.text("%#x" % self.buffer_id)
-                q.text(","); q.breakable()
-                q.text("out_port = ");
-                q.text(util.pretty_port(self.out_port))
-                q.text(","); q.breakable()
-                q.text("out_group = ");
-                q.text("%#x" % self.out_group)
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-                q.text(","); q.breakable()
-                q.text("instructions = ");
-                q.pp(self.instructions)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[14] = flow_mod
-
-class flow_add(flow_mod):
-    version = 4
-    type = 14
-    _command = 0
-
-    def __init__(self, xid=None, cookie=None, cookie_mask=None, table_id=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, out_group=None, flags=None, match=None, instructions=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if cookie_mask != None:
-            self.cookie_mask = cookie_mask
-        else:
-            self.cookie_mask = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if idle_timeout != None:
-            self.idle_timeout = idle_timeout
-        else:
-            self.idle_timeout = 0
-        if hard_timeout != None:
-            self.hard_timeout = hard_timeout
-        else:
-            self.hard_timeout = 0
-        if priority != None:
-            self.priority = priority
-        else:
-            self.priority = 0
-        if buffer_id != None:
-            self.buffer_id = buffer_id
-        else:
-            self.buffer_id = 0
-        if out_port != None:
-            self.out_port = out_port
-        else:
-            self.out_port = 0
-        if out_group != None:
-            self.out_group = out_group
-        else:
-            self.out_group = 0
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        if instructions != None:
-            self.instructions = instructions
-        else:
-            self.instructions = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(struct.pack("!Q", self.cookie_mask))
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append(util.pack_fm_cmd(self._command))
-        packed.append(struct.pack("!H", self.idle_timeout))
-        packed.append(struct.pack("!H", self.hard_timeout))
-        packed.append(struct.pack("!H", self.priority))
-        packed.append(struct.pack("!L", self.buffer_id))
-        packed.append(util.pack_port_no(self.out_port))
-        packed.append(struct.pack("!L", self.out_group))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 2)
-        packed.append(self.match.pack())
-        packed.append(loxi.generic_util.pack_list(self.instructions))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_add()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 14)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.cookie = reader.read("!Q")[0]
-        obj.cookie_mask = reader.read("!Q")[0]
-        obj.table_id = reader.read("!B")[0]
-        __command = util.unpack_fm_cmd(reader)
-        assert(__command == 0)
-        obj.idle_timeout = reader.read("!H")[0]
-        obj.hard_timeout = reader.read("!H")[0]
-        obj.priority = reader.read("!H")[0]
-        obj.buffer_id = reader.read("!L")[0]
-        obj.out_port = util.unpack_port_no(reader)
-        obj.out_group = reader.read("!L")[0]
-        obj.flags = reader.read("!H")[0]
-        reader.skip(2)
-        obj.match = ofp.match.unpack(reader)
-        obj.instructions = loxi.generic_util.unpack_list(reader, ofp.instruction.instruction.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.cookie != other.cookie: return False
-        if self.cookie_mask != other.cookie_mask: return False
-        if self.table_id != other.table_id: return False
-        if self.idle_timeout != other.idle_timeout: return False
-        if self.hard_timeout != other.hard_timeout: return False
-        if self.priority != other.priority: return False
-        if self.buffer_id != other.buffer_id: return False
-        if self.out_port != other.out_port: return False
-        if self.out_group != other.out_group: return False
-        if self.flags != other.flags: return False
-        if self.match != other.match: return False
-        if self.instructions != other.instructions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_add {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("cookie_mask = ");
-                q.text("%#x" % self.cookie_mask)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("idle_timeout = ");
-                q.text("%#x" % self.idle_timeout)
-                q.text(","); q.breakable()
-                q.text("hard_timeout = ");
-                q.text("%#x" % self.hard_timeout)
-                q.text(","); q.breakable()
-                q.text("priority = ");
-                q.text("%#x" % self.priority)
-                q.text(","); q.breakable()
-                q.text("buffer_id = ");
-                q.text("%#x" % self.buffer_id)
-                q.text(","); q.breakable()
-                q.text("out_port = ");
-                q.text(util.pretty_port(self.out_port))
-                q.text(","); q.breakable()
-                q.text("out_group = ");
-                q.text("%#x" % self.out_group)
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-                q.text(","); q.breakable()
-                q.text("instructions = ");
-                q.pp(self.instructions)
-            q.breakable()
-        q.text('}')
-
-flow_mod.subtypes[0] = flow_add
-
-class flow_delete(flow_mod):
-    version = 4
-    type = 14
-    _command = 3
-
-    def __init__(self, xid=None, cookie=None, cookie_mask=None, table_id=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, out_group=None, flags=None, match=None, instructions=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if cookie_mask != None:
-            self.cookie_mask = cookie_mask
-        else:
-            self.cookie_mask = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if idle_timeout != None:
-            self.idle_timeout = idle_timeout
-        else:
-            self.idle_timeout = 0
-        if hard_timeout != None:
-            self.hard_timeout = hard_timeout
-        else:
-            self.hard_timeout = 0
-        if priority != None:
-            self.priority = priority
-        else:
-            self.priority = 0
-        if buffer_id != None:
-            self.buffer_id = buffer_id
-        else:
-            self.buffer_id = 0
-        if out_port != None:
-            self.out_port = out_port
-        else:
-            self.out_port = 0
-        if out_group != None:
-            self.out_group = out_group
-        else:
-            self.out_group = 0
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        if instructions != None:
-            self.instructions = instructions
-        else:
-            self.instructions = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(struct.pack("!Q", self.cookie_mask))
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append(util.pack_fm_cmd(self._command))
-        packed.append(struct.pack("!H", self.idle_timeout))
-        packed.append(struct.pack("!H", self.hard_timeout))
-        packed.append(struct.pack("!H", self.priority))
-        packed.append(struct.pack("!L", self.buffer_id))
-        packed.append(util.pack_port_no(self.out_port))
-        packed.append(struct.pack("!L", self.out_group))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 2)
-        packed.append(self.match.pack())
-        packed.append(loxi.generic_util.pack_list(self.instructions))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_delete()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 14)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.cookie = reader.read("!Q")[0]
-        obj.cookie_mask = reader.read("!Q")[0]
-        obj.table_id = reader.read("!B")[0]
-        __command = util.unpack_fm_cmd(reader)
-        assert(__command == 3)
-        obj.idle_timeout = reader.read("!H")[0]
-        obj.hard_timeout = reader.read("!H")[0]
-        obj.priority = reader.read("!H")[0]
-        obj.buffer_id = reader.read("!L")[0]
-        obj.out_port = util.unpack_port_no(reader)
-        obj.out_group = reader.read("!L")[0]
-        obj.flags = reader.read("!H")[0]
-        reader.skip(2)
-        obj.match = ofp.match.unpack(reader)
-        obj.instructions = loxi.generic_util.unpack_list(reader, ofp.instruction.instruction.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.cookie != other.cookie: return False
-        if self.cookie_mask != other.cookie_mask: return False
-        if self.table_id != other.table_id: return False
-        if self.idle_timeout != other.idle_timeout: return False
-        if self.hard_timeout != other.hard_timeout: return False
-        if self.priority != other.priority: return False
-        if self.buffer_id != other.buffer_id: return False
-        if self.out_port != other.out_port: return False
-        if self.out_group != other.out_group: return False
-        if self.flags != other.flags: return False
-        if self.match != other.match: return False
-        if self.instructions != other.instructions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_delete {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("cookie_mask = ");
-                q.text("%#x" % self.cookie_mask)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("idle_timeout = ");
-                q.text("%#x" % self.idle_timeout)
-                q.text(","); q.breakable()
-                q.text("hard_timeout = ");
-                q.text("%#x" % self.hard_timeout)
-                q.text(","); q.breakable()
-                q.text("priority = ");
-                q.text("%#x" % self.priority)
-                q.text(","); q.breakable()
-                q.text("buffer_id = ");
-                q.text("%#x" % self.buffer_id)
-                q.text(","); q.breakable()
-                q.text("out_port = ");
-                q.text(util.pretty_port(self.out_port))
-                q.text(","); q.breakable()
-                q.text("out_group = ");
-                q.text("%#x" % self.out_group)
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-                q.text(","); q.breakable()
-                q.text("instructions = ");
-                q.pp(self.instructions)
-            q.breakable()
-        q.text('}')
-
-flow_mod.subtypes[3] = flow_delete
-
-class flow_delete_strict(flow_mod):
-    version = 4
-    type = 14
-    _command = 4
-
-    def __init__(self, xid=None, cookie=None, cookie_mask=None, table_id=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, out_group=None, flags=None, match=None, instructions=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if cookie_mask != None:
-            self.cookie_mask = cookie_mask
-        else:
-            self.cookie_mask = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if idle_timeout != None:
-            self.idle_timeout = idle_timeout
-        else:
-            self.idle_timeout = 0
-        if hard_timeout != None:
-            self.hard_timeout = hard_timeout
-        else:
-            self.hard_timeout = 0
-        if priority != None:
-            self.priority = priority
-        else:
-            self.priority = 0
-        if buffer_id != None:
-            self.buffer_id = buffer_id
-        else:
-            self.buffer_id = 0
-        if out_port != None:
-            self.out_port = out_port
-        else:
-            self.out_port = 0
-        if out_group != None:
-            self.out_group = out_group
-        else:
-            self.out_group = 0
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        if instructions != None:
-            self.instructions = instructions
-        else:
-            self.instructions = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(struct.pack("!Q", self.cookie_mask))
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append(util.pack_fm_cmd(self._command))
-        packed.append(struct.pack("!H", self.idle_timeout))
-        packed.append(struct.pack("!H", self.hard_timeout))
-        packed.append(struct.pack("!H", self.priority))
-        packed.append(struct.pack("!L", self.buffer_id))
-        packed.append(util.pack_port_no(self.out_port))
-        packed.append(struct.pack("!L", self.out_group))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 2)
-        packed.append(self.match.pack())
-        packed.append(loxi.generic_util.pack_list(self.instructions))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_delete_strict()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 14)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.cookie = reader.read("!Q")[0]
-        obj.cookie_mask = reader.read("!Q")[0]
-        obj.table_id = reader.read("!B")[0]
-        __command = util.unpack_fm_cmd(reader)
-        assert(__command == 4)
-        obj.idle_timeout = reader.read("!H")[0]
-        obj.hard_timeout = reader.read("!H")[0]
-        obj.priority = reader.read("!H")[0]
-        obj.buffer_id = reader.read("!L")[0]
-        obj.out_port = util.unpack_port_no(reader)
-        obj.out_group = reader.read("!L")[0]
-        obj.flags = reader.read("!H")[0]
-        reader.skip(2)
-        obj.match = ofp.match.unpack(reader)
-        obj.instructions = loxi.generic_util.unpack_list(reader, ofp.instruction.instruction.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.cookie != other.cookie: return False
-        if self.cookie_mask != other.cookie_mask: return False
-        if self.table_id != other.table_id: return False
-        if self.idle_timeout != other.idle_timeout: return False
-        if self.hard_timeout != other.hard_timeout: return False
-        if self.priority != other.priority: return False
-        if self.buffer_id != other.buffer_id: return False
-        if self.out_port != other.out_port: return False
-        if self.out_group != other.out_group: return False
-        if self.flags != other.flags: return False
-        if self.match != other.match: return False
-        if self.instructions != other.instructions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_delete_strict {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("cookie_mask = ");
-                q.text("%#x" % self.cookie_mask)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("idle_timeout = ");
-                q.text("%#x" % self.idle_timeout)
-                q.text(","); q.breakable()
-                q.text("hard_timeout = ");
-                q.text("%#x" % self.hard_timeout)
-                q.text(","); q.breakable()
-                q.text("priority = ");
-                q.text("%#x" % self.priority)
-                q.text(","); q.breakable()
-                q.text("buffer_id = ");
-                q.text("%#x" % self.buffer_id)
-                q.text(","); q.breakable()
-                q.text("out_port = ");
-                q.text(util.pretty_port(self.out_port))
-                q.text(","); q.breakable()
-                q.text("out_group = ");
-                q.text("%#x" % self.out_group)
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-                q.text(","); q.breakable()
-                q.text("instructions = ");
-                q.pp(self.instructions)
-            q.breakable()
-        q.text('}')
-
-flow_mod.subtypes[4] = flow_delete_strict
-
-class flow_mod_failed_error_msg(error_msg):
-    version = 4
-    type = 1
-    err_type = 5
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_mod_failed_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 5)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_mod_failed_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[5] = flow_mod_failed_error_msg
-
-class flow_modify(flow_mod):
-    version = 4
-    type = 14
-    _command = 1
-
-    def __init__(self, xid=None, cookie=None, cookie_mask=None, table_id=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, out_group=None, flags=None, match=None, instructions=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if cookie_mask != None:
-            self.cookie_mask = cookie_mask
-        else:
-            self.cookie_mask = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if idle_timeout != None:
-            self.idle_timeout = idle_timeout
-        else:
-            self.idle_timeout = 0
-        if hard_timeout != None:
-            self.hard_timeout = hard_timeout
-        else:
-            self.hard_timeout = 0
-        if priority != None:
-            self.priority = priority
-        else:
-            self.priority = 0
-        if buffer_id != None:
-            self.buffer_id = buffer_id
-        else:
-            self.buffer_id = 0
-        if out_port != None:
-            self.out_port = out_port
-        else:
-            self.out_port = 0
-        if out_group != None:
-            self.out_group = out_group
-        else:
-            self.out_group = 0
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        if instructions != None:
-            self.instructions = instructions
-        else:
-            self.instructions = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(struct.pack("!Q", self.cookie_mask))
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append(util.pack_fm_cmd(self._command))
-        packed.append(struct.pack("!H", self.idle_timeout))
-        packed.append(struct.pack("!H", self.hard_timeout))
-        packed.append(struct.pack("!H", self.priority))
-        packed.append(struct.pack("!L", self.buffer_id))
-        packed.append(util.pack_port_no(self.out_port))
-        packed.append(struct.pack("!L", self.out_group))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 2)
-        packed.append(self.match.pack())
-        packed.append(loxi.generic_util.pack_list(self.instructions))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_modify()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 14)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.cookie = reader.read("!Q")[0]
-        obj.cookie_mask = reader.read("!Q")[0]
-        obj.table_id = reader.read("!B")[0]
-        __command = util.unpack_fm_cmd(reader)
-        assert(__command == 1)
-        obj.idle_timeout = reader.read("!H")[0]
-        obj.hard_timeout = reader.read("!H")[0]
-        obj.priority = reader.read("!H")[0]
-        obj.buffer_id = reader.read("!L")[0]
-        obj.out_port = util.unpack_port_no(reader)
-        obj.out_group = reader.read("!L")[0]
-        obj.flags = reader.read("!H")[0]
-        reader.skip(2)
-        obj.match = ofp.match.unpack(reader)
-        obj.instructions = loxi.generic_util.unpack_list(reader, ofp.instruction.instruction.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.cookie != other.cookie: return False
-        if self.cookie_mask != other.cookie_mask: return False
-        if self.table_id != other.table_id: return False
-        if self.idle_timeout != other.idle_timeout: return False
-        if self.hard_timeout != other.hard_timeout: return False
-        if self.priority != other.priority: return False
-        if self.buffer_id != other.buffer_id: return False
-        if self.out_port != other.out_port: return False
-        if self.out_group != other.out_group: return False
-        if self.flags != other.flags: return False
-        if self.match != other.match: return False
-        if self.instructions != other.instructions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_modify {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("cookie_mask = ");
-                q.text("%#x" % self.cookie_mask)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("idle_timeout = ");
-                q.text("%#x" % self.idle_timeout)
-                q.text(","); q.breakable()
-                q.text("hard_timeout = ");
-                q.text("%#x" % self.hard_timeout)
-                q.text(","); q.breakable()
-                q.text("priority = ");
-                q.text("%#x" % self.priority)
-                q.text(","); q.breakable()
-                q.text("buffer_id = ");
-                q.text("%#x" % self.buffer_id)
-                q.text(","); q.breakable()
-                q.text("out_port = ");
-                q.text(util.pretty_port(self.out_port))
-                q.text(","); q.breakable()
-                q.text("out_group = ");
-                q.text("%#x" % self.out_group)
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-                q.text(","); q.breakable()
-                q.text("instructions = ");
-                q.pp(self.instructions)
-            q.breakable()
-        q.text('}')
-
-flow_mod.subtypes[1] = flow_modify
-
-class flow_modify_strict(flow_mod):
-    version = 4
-    type = 14
-    _command = 2
-
-    def __init__(self, xid=None, cookie=None, cookie_mask=None, table_id=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, out_group=None, flags=None, match=None, instructions=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if cookie_mask != None:
-            self.cookie_mask = cookie_mask
-        else:
-            self.cookie_mask = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if idle_timeout != None:
-            self.idle_timeout = idle_timeout
-        else:
-            self.idle_timeout = 0
-        if hard_timeout != None:
-            self.hard_timeout = hard_timeout
-        else:
-            self.hard_timeout = 0
-        if priority != None:
-            self.priority = priority
-        else:
-            self.priority = 0
-        if buffer_id != None:
-            self.buffer_id = buffer_id
-        else:
-            self.buffer_id = 0
-        if out_port != None:
-            self.out_port = out_port
-        else:
-            self.out_port = 0
-        if out_group != None:
-            self.out_group = out_group
-        else:
-            self.out_group = 0
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        if instructions != None:
-            self.instructions = instructions
-        else:
-            self.instructions = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(struct.pack("!Q", self.cookie_mask))
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append(util.pack_fm_cmd(self._command))
-        packed.append(struct.pack("!H", self.idle_timeout))
-        packed.append(struct.pack("!H", self.hard_timeout))
-        packed.append(struct.pack("!H", self.priority))
-        packed.append(struct.pack("!L", self.buffer_id))
-        packed.append(util.pack_port_no(self.out_port))
-        packed.append(struct.pack("!L", self.out_group))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 2)
-        packed.append(self.match.pack())
-        packed.append(loxi.generic_util.pack_list(self.instructions))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_modify_strict()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 14)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.cookie = reader.read("!Q")[0]
-        obj.cookie_mask = reader.read("!Q")[0]
-        obj.table_id = reader.read("!B")[0]
-        __command = util.unpack_fm_cmd(reader)
-        assert(__command == 2)
-        obj.idle_timeout = reader.read("!H")[0]
-        obj.hard_timeout = reader.read("!H")[0]
-        obj.priority = reader.read("!H")[0]
-        obj.buffer_id = reader.read("!L")[0]
-        obj.out_port = util.unpack_port_no(reader)
-        obj.out_group = reader.read("!L")[0]
-        obj.flags = reader.read("!H")[0]
-        reader.skip(2)
-        obj.match = ofp.match.unpack(reader)
-        obj.instructions = loxi.generic_util.unpack_list(reader, ofp.instruction.instruction.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.cookie != other.cookie: return False
-        if self.cookie_mask != other.cookie_mask: return False
-        if self.table_id != other.table_id: return False
-        if self.idle_timeout != other.idle_timeout: return False
-        if self.hard_timeout != other.hard_timeout: return False
-        if self.priority != other.priority: return False
-        if self.buffer_id != other.buffer_id: return False
-        if self.out_port != other.out_port: return False
-        if self.out_group != other.out_group: return False
-        if self.flags != other.flags: return False
-        if self.match != other.match: return False
-        if self.instructions != other.instructions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_modify_strict {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("cookie_mask = ");
-                q.text("%#x" % self.cookie_mask)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("idle_timeout = ");
-                q.text("%#x" % self.idle_timeout)
-                q.text(","); q.breakable()
-                q.text("hard_timeout = ");
-                q.text("%#x" % self.hard_timeout)
-                q.text(","); q.breakable()
-                q.text("priority = ");
-                q.text("%#x" % self.priority)
-                q.text(","); q.breakable()
-                q.text("buffer_id = ");
-                q.text("%#x" % self.buffer_id)
-                q.text(","); q.breakable()
-                q.text("out_port = ");
-                q.text(util.pretty_port(self.out_port))
-                q.text(","); q.breakable()
-                q.text("out_group = ");
-                q.text("%#x" % self.out_group)
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-                q.text(","); q.breakable()
-                q.text("instructions = ");
-                q.pp(self.instructions)
-            q.breakable()
-        q.text('}')
-
-flow_mod.subtypes[2] = flow_modify_strict
-
-class flow_removed(message):
-    version = 4
-    type = 11
-
-    def __init__(self, xid=None, cookie=None, priority=None, reason=None, table_id=None, duration_sec=None, duration_nsec=None, idle_timeout=None, hard_timeout=None, packet_count=None, byte_count=None, match=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if priority != None:
-            self.priority = priority
-        else:
-            self.priority = 0
-        if reason != None:
-            self.reason = reason
-        else:
-            self.reason = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if duration_sec != None:
-            self.duration_sec = duration_sec
-        else:
-            self.duration_sec = 0
-        if duration_nsec != None:
-            self.duration_nsec = duration_nsec
-        else:
-            self.duration_nsec = 0
-        if idle_timeout != None:
-            self.idle_timeout = idle_timeout
-        else:
-            self.idle_timeout = 0
-        if hard_timeout != None:
-            self.hard_timeout = hard_timeout
-        else:
-            self.hard_timeout = 0
-        if packet_count != None:
-            self.packet_count = packet_count
-        else:
-            self.packet_count = 0
-        if byte_count != None:
-            self.byte_count = byte_count
-        else:
-            self.byte_count = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(struct.pack("!H", self.priority))
-        packed.append(struct.pack("!B", self.reason))
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append(struct.pack("!L", self.duration_sec))
-        packed.append(struct.pack("!L", self.duration_nsec))
-        packed.append(struct.pack("!H", self.idle_timeout))
-        packed.append(struct.pack("!H", self.hard_timeout))
-        packed.append(struct.pack("!Q", self.packet_count))
-        packed.append(struct.pack("!Q", self.byte_count))
-        packed.append(self.match.pack())
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_removed()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 11)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.cookie = reader.read("!Q")[0]
-        obj.priority = reader.read("!H")[0]
-        obj.reason = reader.read("!B")[0]
-        obj.table_id = reader.read("!B")[0]
-        obj.duration_sec = reader.read("!L")[0]
-        obj.duration_nsec = reader.read("!L")[0]
-        obj.idle_timeout = reader.read("!H")[0]
-        obj.hard_timeout = reader.read("!H")[0]
-        obj.packet_count = reader.read("!Q")[0]
-        obj.byte_count = reader.read("!Q")[0]
-        obj.match = ofp.match.unpack(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.cookie != other.cookie: return False
-        if self.priority != other.priority: return False
-        if self.reason != other.reason: return False
-        if self.table_id != other.table_id: return False
-        if self.duration_sec != other.duration_sec: return False
-        if self.duration_nsec != other.duration_nsec: return False
-        if self.idle_timeout != other.idle_timeout: return False
-        if self.hard_timeout != other.hard_timeout: return False
-        if self.packet_count != other.packet_count: return False
-        if self.byte_count != other.byte_count: return False
-        if self.match != other.match: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_removed {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("priority = ");
-                q.text("%#x" % self.priority)
-                q.text(","); q.breakable()
-                q.text("reason = ");
-                q.text("%#x" % self.reason)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("duration_sec = ");
-                q.text("%#x" % self.duration_sec)
-                q.text(","); q.breakable()
-                q.text("duration_nsec = ");
-                q.text("%#x" % self.duration_nsec)
-                q.text(","); q.breakable()
-                q.text("idle_timeout = ");
-                q.text("%#x" % self.idle_timeout)
-                q.text(","); q.breakable()
-                q.text("hard_timeout = ");
-                q.text("%#x" % self.hard_timeout)
-                q.text(","); q.breakable()
-                q.text("packet_count = ");
-                q.text("%#x" % self.packet_count)
-                q.text(","); q.breakable()
-                q.text("byte_count = ");
-                q.text("%#x" % self.byte_count)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[11] = flow_removed
-
-class flow_stats_reply(stats_reply):
-    version = 4
-    type = 19
-    stats_type = 1
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 1)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.flow_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[1] = flow_stats_reply
-
-class flow_stats_request(stats_request):
-    version = 4
-    type = 18
-    stats_type = 1
-
-    def __init__(self, xid=None, flags=None, table_id=None, out_port=None, out_group=None, cookie=None, cookie_mask=None, match=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if out_port != None:
-            self.out_port = out_port
-        else:
-            self.out_port = 0
-        if out_group != None:
-            self.out_group = out_group
-        else:
-            self.out_group = 0
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if cookie_mask != None:
-            self.cookie_mask = cookie_mask
-        else:
-            self.cookie_mask = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append('\x00' * 3)
-        packed.append(util.pack_port_no(self.out_port))
-        packed.append(struct.pack("!L", self.out_group))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(struct.pack("!Q", self.cookie_mask))
-        packed.append(self.match.pack())
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 1)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.table_id = reader.read("!B")[0]
-        reader.skip(3)
-        obj.out_port = util.unpack_port_no(reader)
-        obj.out_group = reader.read("!L")[0]
-        reader.skip(4)
-        obj.cookie = reader.read("!Q")[0]
-        obj.cookie_mask = reader.read("!Q")[0]
-        obj.match = ofp.match.unpack(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.table_id != other.table_id: return False
-        if self.out_port != other.out_port: return False
-        if self.out_group != other.out_group: return False
-        if self.cookie != other.cookie: return False
-        if self.cookie_mask != other.cookie_mask: return False
-        if self.match != other.match: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("out_port = ");
-                q.text(util.pretty_port(self.out_port))
-                q.text(","); q.breakable()
-                q.text("out_group = ");
-                q.text("%#x" % self.out_group)
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("cookie_mask = ");
-                q.text("%#x" % self.cookie_mask)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[1] = flow_stats_request
-
-class get_config_reply(message):
-    version = 4
-    type = 8
-
-    def __init__(self, xid=None, flags=None, miss_send_len=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if miss_send_len != None:
-            self.miss_send_len = miss_send_len
-        else:
-            self.miss_send_len = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append(struct.pack("!H", self.miss_send_len))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = get_config_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 8)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.flags = reader.read("!H")[0]
-        obj.miss_send_len = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.miss_send_len != other.miss_send_len: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("get_config_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("miss_send_len = ");
-                q.text("%#x" % self.miss_send_len)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[8] = get_config_reply
-
-class get_config_request(message):
-    version = 4
-    type = 7
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = get_config_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 7)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("get_config_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-message.subtypes[7] = get_config_request
-
-class group_mod(message):
-    subtypes = {}
-
-    version = 4
-    type = 15
-
-    def __init__(self, xid=None, command=None, group_type=None, group_id=None, buckets=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if command != None:
-            self.command = command
-        else:
-            self.command = 0
-        if group_type != None:
-            self.group_type = group_type
-        else:
-            self.group_type = 0
-        if group_id != None:
-            self.group_id = group_id
-        else:
-            self.group_id = 0
-        if buckets != None:
-            self.buckets = buckets
-        else:
-            self.buckets = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.command))
-        packed.append(struct.pack("!B", self.group_type))
-        packed.append('\x00' * 1)
-        packed.append(struct.pack("!L", self.group_id))
-        packed.append(loxi.generic_util.pack_list(self.buckets))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 8)
-        subclass = group_mod.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = group_mod()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 15)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.command = reader.read("!H")[0]
-        obj.group_type = reader.read("!B")[0]
-        reader.skip(1)
-        obj.group_id = reader.read("!L")[0]
-        obj.buckets = loxi.generic_util.unpack_list(reader, ofp.common.bucket.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.command != other.command: return False
-        if self.group_type != other.group_type: return False
-        if self.group_id != other.group_id: return False
-        if self.buckets != other.buckets: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_mod {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("group_type = ");
-                q.text("%#x" % self.group_type)
-                q.text(","); q.breakable()
-                q.text("group_id = ");
-                q.text("%#x" % self.group_id)
-                q.text(","); q.breakable()
-                q.text("buckets = ");
-                q.pp(self.buckets)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[15] = group_mod
-
-class group_add(group_mod):
-    version = 4
-    type = 15
-    command = 0
-
-    def __init__(self, xid=None, group_type=None, group_id=None, buckets=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if group_type != None:
-            self.group_type = group_type
-        else:
-            self.group_type = 0
-        if group_id != None:
-            self.group_id = group_id
-        else:
-            self.group_id = 0
-        if buckets != None:
-            self.buckets = buckets
-        else:
-            self.buckets = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.command))
-        packed.append(struct.pack("!B", self.group_type))
-        packed.append('\x00' * 1)
-        packed.append(struct.pack("!L", self.group_id))
-        packed.append(loxi.generic_util.pack_list(self.buckets))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group_add()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 15)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _command = reader.read("!H")[0]
-        assert(_command == 0)
-        obj.group_type = reader.read("!B")[0]
-        reader.skip(1)
-        obj.group_id = reader.read("!L")[0]
-        obj.buckets = loxi.generic_util.unpack_list(reader, ofp.common.bucket.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.group_type != other.group_type: return False
-        if self.group_id != other.group_id: return False
-        if self.buckets != other.buckets: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_add {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("group_type = ");
-                q.text("%#x" % self.group_type)
-                q.text(","); q.breakable()
-                q.text("group_id = ");
-                q.text("%#x" % self.group_id)
-                q.text(","); q.breakable()
-                q.text("buckets = ");
-                q.pp(self.buckets)
-            q.breakable()
-        q.text('}')
-
-group_mod.subtypes[0] = group_add
-
-class group_delete(group_mod):
-    version = 4
-    type = 15
-    command = 2
-
-    def __init__(self, xid=None, group_type=None, group_id=None, buckets=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if group_type != None:
-            self.group_type = group_type
-        else:
-            self.group_type = 0
-        if group_id != None:
-            self.group_id = group_id
-        else:
-            self.group_id = 0
-        if buckets != None:
-            self.buckets = buckets
-        else:
-            self.buckets = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.command))
-        packed.append(struct.pack("!B", self.group_type))
-        packed.append('\x00' * 1)
-        packed.append(struct.pack("!L", self.group_id))
-        packed.append(loxi.generic_util.pack_list(self.buckets))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group_delete()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 15)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _command = reader.read("!H")[0]
-        assert(_command == 2)
-        obj.group_type = reader.read("!B")[0]
-        reader.skip(1)
-        obj.group_id = reader.read("!L")[0]
-        obj.buckets = loxi.generic_util.unpack_list(reader, ofp.common.bucket.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.group_type != other.group_type: return False
-        if self.group_id != other.group_id: return False
-        if self.buckets != other.buckets: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_delete {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("group_type = ");
-                q.text("%#x" % self.group_type)
-                q.text(","); q.breakable()
-                q.text("group_id = ");
-                q.text("%#x" % self.group_id)
-                q.text(","); q.breakable()
-                q.text("buckets = ");
-                q.pp(self.buckets)
-            q.breakable()
-        q.text('}')
-
-group_mod.subtypes[2] = group_delete
-
-class group_desc_stats_reply(stats_reply):
-    version = 4
-    type = 19
-    stats_type = 7
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group_desc_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 7)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.group_desc_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_desc_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[7] = group_desc_stats_reply
-
-class group_desc_stats_request(stats_request):
-    version = 4
-    type = 18
-    stats_type = 7
-
-    def __init__(self, xid=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group_desc_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 7)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_desc_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[7] = group_desc_stats_request
-
-class group_features_stats_reply(stats_reply):
-    version = 4
-    type = 19
-    stats_type = 8
-
-    def __init__(self, xid=None, flags=None, types=None, capabilities=None, max_groups_all=None, max_groups_select=None, max_groups_indirect=None, max_groups_ff=None, actions_all=None, actions_select=None, actions_indirect=None, actions_ff=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if types != None:
-            self.types = types
-        else:
-            self.types = 0
-        if capabilities != None:
-            self.capabilities = capabilities
-        else:
-            self.capabilities = 0
-        if max_groups_all != None:
-            self.max_groups_all = max_groups_all
-        else:
-            self.max_groups_all = 0
-        if max_groups_select != None:
-            self.max_groups_select = max_groups_select
-        else:
-            self.max_groups_select = 0
-        if max_groups_indirect != None:
-            self.max_groups_indirect = max_groups_indirect
-        else:
-            self.max_groups_indirect = 0
-        if max_groups_ff != None:
-            self.max_groups_ff = max_groups_ff
-        else:
-            self.max_groups_ff = 0
-        if actions_all != None:
-            self.actions_all = actions_all
-        else:
-            self.actions_all = 0
-        if actions_select != None:
-            self.actions_select = actions_select
-        else:
-            self.actions_select = 0
-        if actions_indirect != None:
-            self.actions_indirect = actions_indirect
-        else:
-            self.actions_indirect = 0
-        if actions_ff != None:
-            self.actions_ff = actions_ff
-        else:
-            self.actions_ff = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.types))
-        packed.append(struct.pack("!L", self.capabilities))
-        packed.append(struct.pack("!L", self.max_groups_all))
-        packed.append(struct.pack("!L", self.max_groups_select))
-        packed.append(struct.pack("!L", self.max_groups_indirect))
-        packed.append(struct.pack("!L", self.max_groups_ff))
-        packed.append(struct.pack("!L", self.actions_all))
-        packed.append(struct.pack("!L", self.actions_select))
-        packed.append(struct.pack("!L", self.actions_indirect))
-        packed.append(struct.pack("!L", self.actions_ff))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group_features_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 8)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.types = reader.read("!L")[0]
-        obj.capabilities = reader.read("!L")[0]
-        obj.max_groups_all = reader.read("!L")[0]
-        obj.max_groups_select = reader.read("!L")[0]
-        obj.max_groups_indirect = reader.read("!L")[0]
-        obj.max_groups_ff = reader.read("!L")[0]
-        obj.actions_all = reader.read("!L")[0]
-        obj.actions_select = reader.read("!L")[0]
-        obj.actions_indirect = reader.read("!L")[0]
-        obj.actions_ff = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.types != other.types: return False
-        if self.capabilities != other.capabilities: return False
-        if self.max_groups_all != other.max_groups_all: return False
-        if self.max_groups_select != other.max_groups_select: return False
-        if self.max_groups_indirect != other.max_groups_indirect: return False
-        if self.max_groups_ff != other.max_groups_ff: return False
-        if self.actions_all != other.actions_all: return False
-        if self.actions_select != other.actions_select: return False
-        if self.actions_indirect != other.actions_indirect: return False
-        if self.actions_ff != other.actions_ff: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_features_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("types = ");
-                q.text("%#x" % self.types)
-                q.text(","); q.breakable()
-                q.text("capabilities = ");
-                q.text("%#x" % self.capabilities)
-                q.text(","); q.breakable()
-                q.text("max_groups_all = ");
-                q.text("%#x" % self.max_groups_all)
-                q.text(","); q.breakable()
-                q.text("max_groups_select = ");
-                q.text("%#x" % self.max_groups_select)
-                q.text(","); q.breakable()
-                q.text("max_groups_indirect = ");
-                q.text("%#x" % self.max_groups_indirect)
-                q.text(","); q.breakable()
-                q.text("max_groups_ff = ");
-                q.text("%#x" % self.max_groups_ff)
-                q.text(","); q.breakable()
-                q.text("actions_all = ");
-                q.text("%#x" % self.actions_all)
-                q.text(","); q.breakable()
-                q.text("actions_select = ");
-                q.text("%#x" % self.actions_select)
-                q.text(","); q.breakable()
-                q.text("actions_indirect = ");
-                q.text("%#x" % self.actions_indirect)
-                q.text(","); q.breakable()
-                q.text("actions_ff = ");
-                q.text("%#x" % self.actions_ff)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[8] = group_features_stats_reply
-
-class group_features_stats_request(stats_request):
-    version = 4
-    type = 18
-    stats_type = 8
-
-    def __init__(self, xid=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group_features_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 8)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_features_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[8] = group_features_stats_request
-
-class group_mod_failed_error_msg(error_msg):
-    version = 4
-    type = 1
-    err_type = 6
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group_mod_failed_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 6)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_mod_failed_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[6] = group_mod_failed_error_msg
-
-class group_modify(group_mod):
-    version = 4
-    type = 15
-    command = 1
-
-    def __init__(self, xid=None, group_type=None, group_id=None, buckets=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if group_type != None:
-            self.group_type = group_type
-        else:
-            self.group_type = 0
-        if group_id != None:
-            self.group_id = group_id
-        else:
-            self.group_id = 0
-        if buckets != None:
-            self.buckets = buckets
-        else:
-            self.buckets = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.command))
-        packed.append(struct.pack("!B", self.group_type))
-        packed.append('\x00' * 1)
-        packed.append(struct.pack("!L", self.group_id))
-        packed.append(loxi.generic_util.pack_list(self.buckets))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group_modify()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 15)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _command = reader.read("!H")[0]
-        assert(_command == 1)
-        obj.group_type = reader.read("!B")[0]
-        reader.skip(1)
-        obj.group_id = reader.read("!L")[0]
-        obj.buckets = loxi.generic_util.unpack_list(reader, ofp.common.bucket.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.group_type != other.group_type: return False
-        if self.group_id != other.group_id: return False
-        if self.buckets != other.buckets: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_modify {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("group_type = ");
-                q.text("%#x" % self.group_type)
-                q.text(","); q.breakable()
-                q.text("group_id = ");
-                q.text("%#x" % self.group_id)
-                q.text(","); q.breakable()
-                q.text("buckets = ");
-                q.pp(self.buckets)
-            q.breakable()
-        q.text('}')
-
-group_mod.subtypes[1] = group_modify
-
-class group_stats_reply(stats_reply):
-    version = 4
-    type = 19
-    stats_type = 6
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 6)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.group_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[6] = group_stats_reply
-
-class group_stats_request(stats_request):
-    version = 4
-    type = 18
-    stats_type = 6
-
-    def __init__(self, xid=None, flags=None, group_id=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if group_id != None:
-            self.group_id = group_id
-        else:
-            self.group_id = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.group_id))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 6)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.group_id = reader.read("!L")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.group_id != other.group_id: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("group_id = ");
-                q.text("%#x" % self.group_id)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[6] = group_stats_request
-
-class hello(message):
-    version = 4
-    type = 0
-
-    def __init__(self, xid=None, elements=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if elements != None:
-            self.elements = elements
-        else:
-            self.elements = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(loxi.generic_util.pack_list(self.elements))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = hello()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 0)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.elements = loxi.generic_util.unpack_list(reader, ofp.common.hello_elem.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.elements != other.elements: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("hello {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("elements = ");
-                q.pp(self.elements)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[0] = hello
-
-class hello_failed_error_msg(error_msg):
-    version = 4
-    type = 1
-    err_type = 0
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = hello_failed_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 0)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("hello_failed_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[0] = hello_failed_error_msg
-
-class meter_config_stats_reply(stats_reply):
-    version = 4
-    type = 19
-    stats_type = 10
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = meter_config_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 10)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.meter_config.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("meter_config_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[10] = meter_config_stats_reply
-
-class meter_config_stats_request(stats_request):
-    version = 4
-    type = 18
-    stats_type = 10
-
-    def __init__(self, xid=None, flags=None, meter_id=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if meter_id != None:
-            self.meter_id = meter_id
-        else:
-            self.meter_id = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.meter_id))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = meter_config_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 10)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.meter_id = reader.read("!L")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.meter_id != other.meter_id: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("meter_config_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("meter_id = ");
-                q.text("%#x" % self.meter_id)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[10] = meter_config_stats_request
-
-class meter_features_stats_reply(stats_reply):
-    version = 4
-    type = 19
-    stats_type = 11
-
-    def __init__(self, xid=None, flags=None, features=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if features != None:
-            self.features = features
-        else:
-            self.features = ofp.meter_features()
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(self.features.pack())
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = meter_features_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 11)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.features = ofp.meter_features.unpack(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.features != other.features: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("meter_features_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("features = ");
-                q.pp(self.features)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[11] = meter_features_stats_reply
-
-class meter_features_stats_request(stats_request):
-    version = 4
-    type = 18
-    stats_type = 11
-
-    def __init__(self, xid=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = meter_features_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 11)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("meter_features_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[11] = meter_features_stats_request
-
-class meter_mod(message):
-    version = 4
-    type = 29
-
-    def __init__(self, xid=None, command=None, flags=None, meter_id=None, meters=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if command != None:
-            self.command = command
-        else:
-            self.command = 0
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if meter_id != None:
-            self.meter_id = meter_id
-        else:
-            self.meter_id = 0
-        if meters != None:
-            self.meters = meters
-        else:
-            self.meters = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.command))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append(struct.pack("!L", self.meter_id))
-        packed.append(loxi.generic_util.pack_list(self.meters))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = meter_mod()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 29)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.command = reader.read("!H")[0]
-        obj.flags = reader.read("!H")[0]
-        obj.meter_id = reader.read("!L")[0]
-        obj.meters = loxi.generic_util.unpack_list(reader, ofp.meter_band.meter_band.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.command != other.command: return False
-        if self.flags != other.flags: return False
-        if self.meter_id != other.meter_id: return False
-        if self.meters != other.meters: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("meter_mod {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("command = ");
-                q.text("%#x" % self.command)
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("meter_id = ");
-                q.text("%#x" % self.meter_id)
-                q.text(","); q.breakable()
-                q.text("meters = ");
-                q.pp(self.meters)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[29] = meter_mod
-
-class meter_mod_failed_error_msg(error_msg):
-    version = 4
-    type = 1
-    err_type = 12
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = meter_mod_failed_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 12)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("meter_mod_failed_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[12] = meter_mod_failed_error_msg
-
-class meter_stats_reply(stats_reply):
-    version = 4
-    type = 19
-    stats_type = 9
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = meter_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 9)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.meter_stats.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("meter_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[9] = meter_stats_reply
-
-class meter_stats_request(stats_request):
-    version = 4
-    type = 18
-    stats_type = 9
-
-    def __init__(self, xid=None, flags=None, meter_id=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if meter_id != None:
-            self.meter_id = meter_id
-        else:
-            self.meter_id = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.meter_id))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = meter_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 9)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.meter_id = reader.read("!L")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.meter_id != other.meter_id: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("meter_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("meter_id = ");
-                q.text("%#x" % self.meter_id)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[9] = meter_stats_request
-
-class nicira_header(experimenter):
-    subtypes = {}
-
-    version = 4
-    type = 4
-    experimenter = 8992
-
-    def __init__(self, xid=None, subtype=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 12)
-        subclass = nicira_header.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = nicira_header()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 8992)
-        obj.subtype = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.subtype != other.subtype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("nicira_header {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-experimenter.subtypes[8992] = nicira_header
-
-class packet_in(message):
-    version = 4
-    type = 10
-
-    def __init__(self, xid=None, buffer_id=None, total_len=None, reason=None, table_id=None, cookie=None, match=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if buffer_id != None:
-            self.buffer_id = buffer_id
-        else:
-            self.buffer_id = 0
-        if total_len != None:
-            self.total_len = total_len
-        else:
-            self.total_len = 0
-        if reason != None:
-            self.reason = reason
-        else:
-            self.reason = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.buffer_id))
-        packed.append(struct.pack("!H", self.total_len))
-        packed.append(struct.pack("!B", self.reason))
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(self.match.pack())
-        packed.append('\x00' * 2)
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = packet_in()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 10)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.buffer_id = reader.read("!L")[0]
-        obj.total_len = reader.read("!H")[0]
-        obj.reason = reader.read("!B")[0]
-        obj.table_id = reader.read("!B")[0]
-        obj.cookie = reader.read("!Q")[0]
-        obj.match = ofp.match.unpack(reader)
-        reader.skip(2)
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.buffer_id != other.buffer_id: return False
-        if self.total_len != other.total_len: return False
-        if self.reason != other.reason: return False
-        if self.table_id != other.table_id: return False
-        if self.cookie != other.cookie: return False
-        if self.match != other.match: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("packet_in {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("buffer_id = ");
-                q.text("%#x" % self.buffer_id)
-                q.text(","); q.breakable()
-                q.text("total_len = ");
-                q.text("%#x" % self.total_len)
-                q.text(","); q.breakable()
-                q.text("reason = ");
-                q.text("%#x" % self.reason)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[10] = packet_in
-
-class packet_out(message):
-    version = 4
-    type = 13
-
-    def __init__(self, xid=None, buffer_id=None, in_port=None, actions=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if buffer_id != None:
-            self.buffer_id = buffer_id
-        else:
-            self.buffer_id = 0
-        if in_port != None:
-            self.in_port = in_port
-        else:
-            self.in_port = 0
-        if actions != None:
-            self.actions = actions
-        else:
-            self.actions = []
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.buffer_id))
-        packed.append(util.pack_port_no(self.in_port))
-        packed.append(struct.pack("!H", 0)) # placeholder for actions_len at index 6
-        packed.append('\x00' * 6)
-        packed.append(loxi.generic_util.pack_list(self.actions))
-        packed[6] = struct.pack("!H", len(packed[-1]))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = packet_out()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 13)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.buffer_id = reader.read("!L")[0]
-        obj.in_port = util.unpack_port_no(reader)
-        _actions_len = reader.read("!H")[0]
-        reader.skip(6)
-        obj.actions = loxi.generic_util.unpack_list(reader.slice(_actions_len), ofp.action.action.unpack)
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.buffer_id != other.buffer_id: return False
-        if self.in_port != other.in_port: return False
-        if self.actions != other.actions: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("packet_out {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("buffer_id = ");
-                q.text("%#x" % self.buffer_id)
-                q.text(","); q.breakable()
-                q.text("in_port = ");
-                q.text(util.pretty_port(self.in_port))
-                q.text(","); q.breakable()
-                q.text("actions = ");
-                q.pp(self.actions)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[13] = packet_out
-
-class port_desc_stats_reply(stats_reply):
-    version = 4
-    type = 19
-    stats_type = 13
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = port_desc_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 13)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.port_desc.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port_desc_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[13] = port_desc_stats_reply
-
-class port_desc_stats_request(stats_request):
-    version = 4
-    type = 18
-    stats_type = 13
-
-    def __init__(self, xid=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = port_desc_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 13)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port_desc_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[13] = port_desc_stats_request
-
-class port_mod(message):
-    version = 4
-    type = 16
-
-    def __init__(self, xid=None, port_no=None, hw_addr=None, config=None, mask=None, advertise=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if hw_addr != None:
-            self.hw_addr = hw_addr
-        else:
-            self.hw_addr = [0,0,0,0,0,0]
-        if config != None:
-            self.config = config
-        else:
-            self.config = 0
-        if mask != None:
-            self.mask = mask
-        else:
-            self.mask = 0
-        if advertise != None:
-            self.advertise = advertise
-        else:
-            self.advertise = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!6B", *self.hw_addr))
-        packed.append('\x00' * 2)
-        packed.append(struct.pack("!L", self.config))
-        packed.append(struct.pack("!L", self.mask))
-        packed.append(struct.pack("!L", self.advertise))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = port_mod()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 16)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.port_no = util.unpack_port_no(reader)
-        reader.skip(4)
-        obj.hw_addr = list(reader.read('!6B'))
-        reader.skip(2)
-        obj.config = reader.read("!L")[0]
-        obj.mask = reader.read("!L")[0]
-        obj.advertise = reader.read("!L")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.port_no != other.port_no: return False
-        if self.hw_addr != other.hw_addr: return False
-        if self.config != other.config: return False
-        if self.mask != other.mask: return False
-        if self.advertise != other.advertise: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port_mod {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("hw_addr = ");
-                q.text(util.pretty_mac(self.hw_addr))
-                q.text(","); q.breakable()
-                q.text("config = ");
-                q.text("%#x" % self.config)
-                q.text(","); q.breakable()
-                q.text("mask = ");
-                q.text("%#x" % self.mask)
-                q.text(","); q.breakable()
-                q.text("advertise = ");
-                q.text("%#x" % self.advertise)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[16] = port_mod
-
-class port_mod_failed_error_msg(error_msg):
-    version = 4
-    type = 1
-    err_type = 7
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = port_mod_failed_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 7)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port_mod_failed_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[7] = port_mod_failed_error_msg
-
-class port_stats_reply(stats_reply):
-    version = 4
-    type = 19
-    stats_type = 4
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = port_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 4)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.port_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[4] = port_stats_reply
-
-class port_stats_request(stats_request):
-    version = 4
-    type = 18
-    stats_type = 4
-
-    def __init__(self, xid=None, flags=None, port_no=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = port_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 4)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.port_no = util.unpack_port_no(reader)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.port_no != other.port_no: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[4] = port_stats_request
-
-class port_status(message):
-    version = 4
-    type = 12
-
-    def __init__(self, xid=None, reason=None, desc=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if reason != None:
-            self.reason = reason
-        else:
-            self.reason = 0
-        if desc != None:
-            self.desc = desc
-        else:
-            self.desc = ofp.port_desc()
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!B", self.reason))
-        packed.append('\x00' * 7)
-        packed.append(self.desc.pack())
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = port_status()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 12)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.reason = reader.read("!B")[0]
-        reader.skip(7)
-        obj.desc = ofp.port_desc.unpack(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.reason != other.reason: return False
-        if self.desc != other.desc: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port_status {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("reason = ");
-                q.text("%#x" % self.reason)
-                q.text(","); q.breakable()
-                q.text("desc = ");
-                q.pp(self.desc)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[12] = port_status
-
-class queue_get_config_reply(message):
-    version = 4
-    type = 23
-
-    def __init__(self, xid=None, port=None, queues=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if port != None:
-            self.port = port
-        else:
-            self.port = 0
-        if queues != None:
-            self.queues = queues
-        else:
-            self.queues = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(util.pack_port_no(self.port))
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.queues))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = queue_get_config_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 23)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.port = util.unpack_port_no(reader)
-        reader.skip(4)
-        obj.queues = loxi.generic_util.unpack_list(reader, ofp.common.packet_queue.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.port != other.port: return False
-        if self.queues != other.queues: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_get_config_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("port = ");
-                q.text(util.pretty_port(self.port))
-                q.text(","); q.breakable()
-                q.text("queues = ");
-                q.pp(self.queues)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[23] = queue_get_config_reply
-
-class queue_get_config_request(message):
-    version = 4
-    type = 22
-
-    def __init__(self, xid=None, port=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if port != None:
-            self.port = port
-        else:
-            self.port = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(util.pack_port_no(self.port))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = queue_get_config_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 22)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.port = util.unpack_port_no(reader)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.port != other.port: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_get_config_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("port = ");
-                q.text(util.pretty_port(self.port))
-            q.breakable()
-        q.text('}')
-
-message.subtypes[22] = queue_get_config_request
-
-class queue_op_failed_error_msg(error_msg):
-    version = 4
-    type = 1
-    err_type = 9
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = queue_op_failed_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 9)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_op_failed_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[9] = queue_op_failed_error_msg
-
-class queue_stats_reply(stats_reply):
-    version = 4
-    type = 19
-    stats_type = 5
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = queue_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 5)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.queue_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[5] = queue_stats_reply
-
-class queue_stats_request(stats_request):
-    version = 4
-    type = 18
-    stats_type = 5
-
-    def __init__(self, xid=None, flags=None, port_no=None, queue_id=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if queue_id != None:
-            self.queue_id = queue_id
-        else:
-            self.queue_id = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(struct.pack("!L", self.queue_id))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = queue_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 5)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.port_no = util.unpack_port_no(reader)
-        obj.queue_id = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.port_no != other.port_no: return False
-        if self.queue_id != other.queue_id: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("queue_id = ");
-                q.text("%#x" % self.queue_id)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[5] = queue_stats_request
-
-class role_reply(message):
-    version = 4
-    type = 25
-
-    def __init__(self, xid=None, role=None, generation_id=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if role != None:
-            self.role = role
-        else:
-            self.role = 0
-        if generation_id != None:
-            self.generation_id = generation_id
-        else:
-            self.generation_id = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.role))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!Q", self.generation_id))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = role_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 25)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.role = reader.read("!L")[0]
-        reader.skip(4)
-        obj.generation_id = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.role != other.role: return False
-        if self.generation_id != other.generation_id: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("role_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("role = ");
-                q.text("%#x" % self.role)
-                q.text(","); q.breakable()
-                q.text("generation_id = ");
-                q.text("%#x" % self.generation_id)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[25] = role_reply
-
-class role_request(message):
-    version = 4
-    type = 24
-
-    def __init__(self, xid=None, role=None, generation_id=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if role != None:
-            self.role = role
-        else:
-            self.role = 0
-        if generation_id != None:
-            self.generation_id = generation_id
-        else:
-            self.generation_id = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.role))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!Q", self.generation_id))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = role_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 24)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.role = reader.read("!L")[0]
-        reader.skip(4)
-        obj.generation_id = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.role != other.role: return False
-        if self.generation_id != other.generation_id: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("role_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("role = ");
-                q.text("%#x" % self.role)
-                q.text(","); q.breakable()
-                q.text("generation_id = ");
-                q.text("%#x" % self.generation_id)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[24] = role_request
-
-class role_request_failed_error_msg(error_msg):
-    version = 4
-    type = 1
-    err_type = 11
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = role_request_failed_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 11)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("role_request_failed_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[11] = role_request_failed_error_msg
-
-class set_config(message):
-    version = 4
-    type = 9
-
-    def __init__(self, xid=None, flags=None, miss_send_len=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if miss_send_len != None:
-            self.miss_send_len = miss_send_len
-        else:
-            self.miss_send_len = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append(struct.pack("!H", self.miss_send_len))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_config()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 9)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.flags = reader.read("!H")[0]
-        obj.miss_send_len = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.miss_send_len != other.miss_send_len: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_config {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("miss_send_len = ");
-                q.text("%#x" % self.miss_send_len)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[9] = set_config
-
-class switch_config_failed_error_msg(error_msg):
-    version = 4
-    type = 1
-    err_type = 10
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = switch_config_failed_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 10)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("switch_config_failed_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[10] = switch_config_failed_error_msg
-
-class table_features_failed_error_msg(error_msg):
-    version = 4
-    type = 1
-    err_type = 13
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_features_failed_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 13)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_features_failed_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[13] = table_features_failed_error_msg
-
-class table_features_stats_reply(stats_reply):
-    version = 4
-    type = 19
-    stats_type = 12
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_features_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 12)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.table_features.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_features_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[12] = table_features_stats_reply
-
-class table_features_stats_request(stats_request):
-    version = 4
-    type = 18
-    stats_type = 12
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_features_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 12)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.table_features.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_features_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[12] = table_features_stats_request
-
-class table_mod(message):
-    version = 4
-    type = 17
-
-    def __init__(self, xid=None, table_id=None, config=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if config != None:
-            self.config = config
-        else:
-            self.config = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append('\x00' * 3)
-        packed.append(struct.pack("!L", self.config))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_mod()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 17)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.table_id = reader.read("!B")[0]
-        reader.skip(3)
-        obj.config = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.table_id != other.table_id: return False
-        if self.config != other.config: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_mod {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("config = ");
-                q.text("%#x" % self.config)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[17] = table_mod
-
-class table_mod_failed_error_msg(error_msg):
-    version = 4
-    type = 1
-    err_type = 8
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_mod_failed_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 8)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_mod_failed_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[8] = table_mod_failed_error_msg
-
-class table_stats_reply(stats_reply):
-    version = 4
-    type = 19
-    stats_type = 3
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 3)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.table_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[3] = table_stats_reply
-
-class table_stats_request(stats_request):
-    version = 4
-    type = 18
-    stats_type = 3
-
-    def __init__(self, xid=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 4)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 3)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[3] = table_stats_request
-
-
-def parse_header(buf):
-    if len(buf) < 8:
-        raise loxi.ProtocolError("too short to be an OpenFlow message")
-    return struct.unpack_from("!BBHL", buf)
-
-def parse_message(buf):
-    msg_ver, msg_type, msg_len, msg_xid = parse_header(buf)
-    if msg_ver != ofp.OFP_VERSION and msg_type != ofp.OFPT_HELLO:
-        raise loxi.ProtocolError("wrong OpenFlow version (expected %d, got %d)" % (ofp.OFP_VERSION, msg_ver))
-    if len(buf) != msg_len:
-        raise loxi.ProtocolError("incorrect message size")
-    return message.unpack(loxi.generic_util.OFReader(buf))
diff --git a/python/ofagent/loxi/of13/meter_band.py b/python/ofagent/loxi/of13/meter_band.py
deleted file mode 100644
index 822567e..0000000
--- a/python/ofagent/loxi/of13/meter_band.py
+++ /dev/null
@@ -1,272 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template module.py
-# Do not modify
-
-import struct
-import loxi
-import util
-import loxi.generic_util
-
-import sys
-ofp = sys.modules['loxi.of13']
-
-class meter_band(loxi.OFObject):
-    subtypes = {}
-
-
-    def __init__(self, type=None):
-        if type != None:
-            self.type = type
-        else:
-            self.type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 0)
-        subclass = meter_band.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = meter_band()
-        obj.type = reader.read("!H")[0]
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type != other.type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("meter_band {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-
-class drop(meter_band):
-    type = 1
-
-    def __init__(self, rate=None, burst_size=None):
-        if rate != None:
-            self.rate = rate
-        else:
-            self.rate = 0
-        if burst_size != None:
-            self.burst_size = burst_size
-        else:
-            self.burst_size = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.rate))
-        packed.append(struct.pack("!L", self.burst_size))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = drop()
-        _type = reader.read("!H")[0]
-        assert(_type == 1)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.rate = reader.read("!L")[0]
-        obj.burst_size = reader.read("!L")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.rate != other.rate: return False
-        if self.burst_size != other.burst_size: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("drop {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("rate = ");
-                q.text("%#x" % self.rate)
-                q.text(","); q.breakable()
-                q.text("burst_size = ");
-                q.text("%#x" % self.burst_size)
-            q.breakable()
-        q.text('}')
-
-meter_band.subtypes[1] = drop
-
-class dscp_remark(meter_band):
-    type = 2
-
-    def __init__(self, rate=None, burst_size=None, prec_level=None):
-        if rate != None:
-            self.rate = rate
-        else:
-            self.rate = 0
-        if burst_size != None:
-            self.burst_size = burst_size
-        else:
-            self.burst_size = 0
-        if prec_level != None:
-            self.prec_level = prec_level
-        else:
-            self.prec_level = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.rate))
-        packed.append(struct.pack("!L", self.burst_size))
-        packed.append(struct.pack("!B", self.prec_level))
-        packed.append('\x00' * 3)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = dscp_remark()
-        _type = reader.read("!H")[0]
-        assert(_type == 2)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.rate = reader.read("!L")[0]
-        obj.burst_size = reader.read("!L")[0]
-        obj.prec_level = reader.read("!B")[0]
-        reader.skip(3)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.rate != other.rate: return False
-        if self.burst_size != other.burst_size: return False
-        if self.prec_level != other.prec_level: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("dscp_remark {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("rate = ");
-                q.text("%#x" % self.rate)
-                q.text(","); q.breakable()
-                q.text("burst_size = ");
-                q.text("%#x" % self.burst_size)
-                q.text(","); q.breakable()
-                q.text("prec_level = ");
-                q.text("%#x" % self.prec_level)
-            q.breakable()
-        q.text('}')
-
-meter_band.subtypes[2] = dscp_remark
-
-class experimenter(meter_band):
-    type = 65535
-
-    def __init__(self, rate=None, burst_size=None, experimenter=None):
-        if rate != None:
-            self.rate = rate
-        else:
-            self.rate = 0
-        if burst_size != None:
-            self.burst_size = burst_size
-        else:
-            self.burst_size = 0
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.rate))
-        packed.append(struct.pack("!L", self.burst_size))
-        packed.append(struct.pack("!L", self.experimenter))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = experimenter()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.rate = reader.read("!L")[0]
-        obj.burst_size = reader.read("!L")[0]
-        obj.experimenter = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.rate != other.rate: return False
-        if self.burst_size != other.burst_size: return False
-        if self.experimenter != other.experimenter: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("experimenter {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("rate = ");
-                q.text("%#x" % self.rate)
-                q.text(","); q.breakable()
-                q.text("burst_size = ");
-                q.text("%#x" % self.burst_size)
-                q.text(","); q.breakable()
-                q.text("experimenter = ");
-                q.text("%#x" % self.experimenter)
-            q.breakable()
-        q.text('}')
-
-meter_band.subtypes[65535] = experimenter
-
-
diff --git a/python/ofagent/loxi/of13/oxm.py b/python/ofagent/loxi/of13/oxm.py
deleted file mode 100644
index 0e43b2b..0000000
--- a/python/ofagent/loxi/of13/oxm.py
+++ /dev/null
@@ -1,6235 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template module.py
-# Do not modify
-
-import struct
-import loxi
-import util
-import loxi.generic_util
-
-import sys
-ofp = sys.modules['loxi.of13']
-
-class oxm(loxi.OFObject):
-    subtypes = {}
-
-
-    def __init__(self, type_len=None):
-        if type_len != None:
-            self.type_len = type_len
-        else:
-            self.type_len = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 0)
-        subclass = oxm.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = oxm()
-        obj.type_len = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type_len != other.type_len: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("oxm {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-
-class arp_op(oxm):
-    type_len = 2147494402
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = arp_op()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147494402)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("arp_op {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147494402] = arp_op
-
-class arp_op_masked(oxm):
-    type_len = 2147494660
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        packed.append(struct.pack("!H", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = arp_op_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147494660)
-        obj.value = reader.read("!H")[0]
-        obj.value_mask = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("arp_op_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147494660] = arp_op_masked
-
-class arp_sha(oxm):
-    type_len = 2147495942
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!6B", *self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = arp_sha()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147495942)
-        obj.value = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("arp_sha {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147495942] = arp_sha
-
-class arp_sha_masked(oxm):
-    type_len = 2147496204
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!6B", *self.value))
-        packed.append(struct.pack("!6B", *self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = arp_sha_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147496204)
-        obj.value = list(reader.read('!6B'))
-        obj.value_mask = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("arp_sha_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text(util.pretty_mac(self.value_mask))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147496204] = arp_sha_masked
-
-class arp_spa(oxm):
-    type_len = 2147494916
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = arp_spa()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147494916)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("arp_spa {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147494916] = arp_spa
-
-class arp_spa_masked(oxm):
-    type_len = 2147495176
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = arp_spa_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147495176)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("arp_spa_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147495176] = arp_spa_masked
-
-class arp_tha(oxm):
-    type_len = 2147496454
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!6B", *self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = arp_tha()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147496454)
-        obj.value = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("arp_tha {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147496454] = arp_tha
-
-class arp_tha_masked(oxm):
-    type_len = 2147496716
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!6B", *self.value))
-        packed.append(struct.pack("!6B", *self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = arp_tha_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147496716)
-        obj.value = list(reader.read('!6B'))
-        obj.value_mask = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("arp_tha_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text(util.pretty_mac(self.value_mask))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147496716] = arp_tha_masked
-
-class arp_tpa(oxm):
-    type_len = 2147495428
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = arp_tpa()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147495428)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("arp_tpa {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147495428] = arp_tpa
-
-class arp_tpa_masked(oxm):
-    type_len = 2147495688
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = arp_tpa_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147495688)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("arp_tpa_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147495688] = arp_tpa_masked
-
-class bsn_egr_port_group_id(oxm):
-    type_len = 200196
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_egr_port_group_id()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 200196)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_egr_port_group_id {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[200196] = bsn_egr_port_group_id
-
-class bsn_egr_port_group_id_masked(oxm):
-    type_len = 200456
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_egr_port_group_id_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 200456)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_egr_port_group_id_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[200456] = bsn_egr_port_group_id_masked
-
-class bsn_global_vrf_allowed(oxm):
-    type_len = 198145
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_global_vrf_allowed()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 198145)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_global_vrf_allowed {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[198145] = bsn_global_vrf_allowed
-
-class bsn_global_vrf_allowed_masked(oxm):
-    type_len = 198402
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        packed.append(struct.pack("!B", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_global_vrf_allowed_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 198402)
-        obj.value = reader.read("!B")[0]
-        obj.value_mask = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_global_vrf_allowed_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[198402] = bsn_global_vrf_allowed_masked
-
-class bsn_in_ports_128(oxm):
-    type_len = 196624
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = set()
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(util.pack_bitmap_128(self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_in_ports_128()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 196624)
-        obj.value = util.unpack_bitmap_128(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_in_ports_128 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.pp(self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[196624] = bsn_in_ports_128
-
-class bsn_in_ports_128_masked(oxm):
-    type_len = 196896
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = set()
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = set()
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(util.pack_bitmap_128(self.value))
-        packed.append(util.pack_bitmap_128(self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_in_ports_128_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 196896)
-        obj.value = util.unpack_bitmap_128(reader)
-        obj.value_mask = util.unpack_bitmap_128(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_in_ports_128_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.pp(self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.pp(self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[196896] = bsn_in_ports_128_masked
-
-class bsn_in_ports_512(oxm):
-    type_len = 206400
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = set()
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(util.pack_bitmap_512(self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_in_ports_512()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 206400)
-        obj.value = util.unpack_bitmap_512(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_in_ports_512 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.pp(self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[206400] = bsn_in_ports_512
-
-class bsn_in_ports_512_masked(oxm):
-    type_len = 206720
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = set()
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = set()
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(util.pack_bitmap_512(self.value))
-        packed.append(util.pack_bitmap_512(self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_in_ports_512_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 206720)
-        obj.value = util.unpack_bitmap_512(reader)
-        obj.value_mask = util.unpack_bitmap_512(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_in_ports_512_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.pp(self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.pp(self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[206720] = bsn_in_ports_512_masked
-
-class bsn_ingress_port_group_id(oxm):
-    type_len = 206852
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_ingress_port_group_id()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 206852)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_ingress_port_group_id {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[206852] = bsn_ingress_port_group_id
-
-class bsn_ingress_port_group_id_masked(oxm):
-    type_len = 207112
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_ingress_port_group_id_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 207112)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_ingress_port_group_id_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[207112] = bsn_ingress_port_group_id_masked
-
-class bsn_inner_eth_dst(oxm):
-    type_len = 207878
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!6B", *self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_inner_eth_dst()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 207878)
-        obj.value = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_inner_eth_dst {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[207878] = bsn_inner_eth_dst
-
-class bsn_inner_eth_dst_masked(oxm):
-    type_len = 208140
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!6B", *self.value))
-        packed.append(struct.pack("!6B", *self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_inner_eth_dst_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 208140)
-        obj.value = list(reader.read('!6B'))
-        obj.value_mask = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_inner_eth_dst_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text(util.pretty_mac(self.value_mask))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[208140] = bsn_inner_eth_dst_masked
-
-class bsn_inner_eth_src(oxm):
-    type_len = 208390
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!6B", *self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_inner_eth_src()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 208390)
-        obj.value = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_inner_eth_src {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[208390] = bsn_inner_eth_src
-
-class bsn_inner_eth_src_masked(oxm):
-    type_len = 208652
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!6B", *self.value))
-        packed.append(struct.pack("!6B", *self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_inner_eth_src_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 208652)
-        obj.value = list(reader.read('!6B'))
-        obj.value_mask = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_inner_eth_src_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text(util.pretty_mac(self.value_mask))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[208652] = bsn_inner_eth_src_masked
-
-class bsn_inner_vlan_vid(oxm):
-    type_len = 208898
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_inner_vlan_vid()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 208898)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_inner_vlan_vid {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[208898] = bsn_inner_vlan_vid
-
-class bsn_inner_vlan_vid_masked(oxm):
-    type_len = 209156
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        packed.append(struct.pack("!H", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_inner_vlan_vid_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 209156)
-        obj.value = reader.read("!H")[0]
-        obj.value_mask = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_inner_vlan_vid_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[209156] = bsn_inner_vlan_vid_masked
-
-class bsn_l2_cache_hit(oxm):
-    type_len = 205825
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_l2_cache_hit()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 205825)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_l2_cache_hit {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[205825] = bsn_l2_cache_hit
-
-class bsn_l2_cache_hit_masked(oxm):
-    type_len = 206082
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        packed.append(struct.pack("!B", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_l2_cache_hit_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 206082)
-        obj.value = reader.read("!B")[0]
-        obj.value_mask = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_l2_cache_hit_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[206082] = bsn_l2_cache_hit_masked
-
-class bsn_l3_dst_class_id(oxm):
-    type_len = 199684
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_l3_dst_class_id()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 199684)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_l3_dst_class_id {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[199684] = bsn_l3_dst_class_id
-
-class bsn_l3_dst_class_id_masked(oxm):
-    type_len = 199944
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_l3_dst_class_id_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 199944)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_l3_dst_class_id_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[199944] = bsn_l3_dst_class_id_masked
-
-class bsn_l3_interface_class_id(oxm):
-    type_len = 198660
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_l3_interface_class_id()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 198660)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_l3_interface_class_id {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[198660] = bsn_l3_interface_class_id
-
-class bsn_l3_interface_class_id_masked(oxm):
-    type_len = 198920
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_l3_interface_class_id_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 198920)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_l3_interface_class_id_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[198920] = bsn_l3_interface_class_id_masked
-
-class bsn_l3_src_class_id(oxm):
-    type_len = 199172
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_l3_src_class_id()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 199172)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_l3_src_class_id {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[199172] = bsn_l3_src_class_id
-
-class bsn_l3_src_class_id_masked(oxm):
-    type_len = 199432
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_l3_src_class_id_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 199432)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_l3_src_class_id_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[199432] = bsn_l3_src_class_id_masked
-
-class bsn_lag_id(oxm):
-    type_len = 197124
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_lag_id()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 197124)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_lag_id {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[197124] = bsn_lag_id
-
-class bsn_lag_id_masked(oxm):
-    type_len = 197384
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_lag_id_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 197384)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_lag_id_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[197384] = bsn_lag_id_masked
-
-class bsn_tcp_flags(oxm):
-    type_len = 204802
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_tcp_flags()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 204802)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_tcp_flags {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[204802] = bsn_tcp_flags
-
-class bsn_tcp_flags_masked(oxm):
-    type_len = 205060
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        packed.append(struct.pack("!H", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_tcp_flags_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 205060)
-        obj.value = reader.read("!H")[0]
-        obj.value_mask = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_tcp_flags_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[205060] = bsn_tcp_flags_masked
-
-class bsn_udf0(oxm):
-    type_len = 200708
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf0()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 200708)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf0 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[200708] = bsn_udf0
-
-class bsn_udf0_masked(oxm):
-    type_len = 200968
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf0_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 200968)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf0_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[200968] = bsn_udf0_masked
-
-class bsn_udf1(oxm):
-    type_len = 201220
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf1()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 201220)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf1 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[201220] = bsn_udf1
-
-class bsn_udf1_masked(oxm):
-    type_len = 201480
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf1_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 201480)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf1_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[201480] = bsn_udf1_masked
-
-class bsn_udf2(oxm):
-    type_len = 201732
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf2()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 201732)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf2 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[201732] = bsn_udf2
-
-class bsn_udf2_masked(oxm):
-    type_len = 201992
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf2_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 201992)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf2_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[201992] = bsn_udf2_masked
-
-class bsn_udf3(oxm):
-    type_len = 202244
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf3()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 202244)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf3 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[202244] = bsn_udf3
-
-class bsn_udf3_masked(oxm):
-    type_len = 202504
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf3_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 202504)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf3_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[202504] = bsn_udf3_masked
-
-class bsn_udf4(oxm):
-    type_len = 202756
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf4()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 202756)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf4 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[202756] = bsn_udf4
-
-class bsn_udf4_masked(oxm):
-    type_len = 203016
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf4_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 203016)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf4_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[203016] = bsn_udf4_masked
-
-class bsn_udf5(oxm):
-    type_len = 203268
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf5()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 203268)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf5 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[203268] = bsn_udf5
-
-class bsn_udf5_masked(oxm):
-    type_len = 203528
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf5_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 203528)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf5_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[203528] = bsn_udf5_masked
-
-class bsn_udf6(oxm):
-    type_len = 203780
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf6()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 203780)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf6 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[203780] = bsn_udf6
-
-class bsn_udf6_masked(oxm):
-    type_len = 204040
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf6_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 204040)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf6_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[204040] = bsn_udf6_masked
-
-class bsn_udf7(oxm):
-    type_len = 204292
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf7()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 204292)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf7 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[204292] = bsn_udf7
-
-class bsn_udf7_masked(oxm):
-    type_len = 204552
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf7_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 204552)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf7_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[204552] = bsn_udf7_masked
-
-class bsn_vfi(oxm):
-    type_len = 209410
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_vfi()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 209410)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vfi {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[209410] = bsn_vfi
-
-class bsn_vfi_masked(oxm):
-    type_len = 209668
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        packed.append(struct.pack("!H", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_vfi_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 209668)
-        obj.value = reader.read("!H")[0]
-        obj.value_mask = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vfi_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[209668] = bsn_vfi_masked
-
-class bsn_vlan_xlate_port_group_id(oxm):
-    type_len = 205316
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_vlan_xlate_port_group_id()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 205316)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vlan_xlate_port_group_id {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[205316] = bsn_vlan_xlate_port_group_id
-
-class bsn_vlan_xlate_port_group_id_masked(oxm):
-    type_len = 205576
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_vlan_xlate_port_group_id_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 205576)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vlan_xlate_port_group_id_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[205576] = bsn_vlan_xlate_port_group_id_masked
-
-class bsn_vrf(oxm):
-    type_len = 197636
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_vrf()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 197636)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vrf {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[197636] = bsn_vrf
-
-class bsn_vrf_masked(oxm):
-    type_len = 197896
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_vrf_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 197896)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vrf_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[197896] = bsn_vrf_masked
-
-class bsn_vxlan_network_id(oxm):
-    type_len = 207364
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_vxlan_network_id()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 207364)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vxlan_network_id {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[207364] = bsn_vxlan_network_id
-
-class bsn_vxlan_network_id_masked(oxm):
-    type_len = 207624
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_vxlan_network_id_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 207624)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vxlan_network_id_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[207624] = bsn_vxlan_network_id_masked
-
-class eth_dst(oxm):
-    type_len = 2147485190
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!6B", *self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = eth_dst()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147485190)
-        obj.value = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("eth_dst {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147485190] = eth_dst
-
-class eth_dst_masked(oxm):
-    type_len = 2147485452
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!6B", *self.value))
-        packed.append(struct.pack("!6B", *self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = eth_dst_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147485452)
-        obj.value = list(reader.read('!6B'))
-        obj.value_mask = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("eth_dst_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text(util.pretty_mac(self.value_mask))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147485452] = eth_dst_masked
-
-class eth_src(oxm):
-    type_len = 2147485702
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!6B", *self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = eth_src()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147485702)
-        obj.value = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("eth_src {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147485702] = eth_src
-
-class eth_src_masked(oxm):
-    type_len = 2147485964
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!6B", *self.value))
-        packed.append(struct.pack("!6B", *self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = eth_src_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147485964)
-        obj.value = list(reader.read('!6B'))
-        obj.value_mask = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("eth_src_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text(util.pretty_mac(self.value_mask))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147485964] = eth_src_masked
-
-class eth_type(oxm):
-    type_len = 2147486210
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = eth_type()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147486210)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("eth_type {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147486210] = eth_type
-
-class eth_type_masked(oxm):
-    type_len = 2147486468
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        packed.append(struct.pack("!H", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = eth_type_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147486468)
-        obj.value = reader.read("!H")[0]
-        obj.value_mask = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("eth_type_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147486468] = eth_type_masked
-
-class icmpv4_code(oxm):
-    type_len = 2147493889
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = icmpv4_code()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147493889)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("icmpv4_code {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147493889] = icmpv4_code
-
-class icmpv4_code_masked(oxm):
-    type_len = 2147494146
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        packed.append(struct.pack("!B", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = icmpv4_code_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147494146)
-        obj.value = reader.read("!B")[0]
-        obj.value_mask = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("icmpv4_code_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147494146] = icmpv4_code_masked
-
-class icmpv4_type(oxm):
-    type_len = 2147493377
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = icmpv4_type()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147493377)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("icmpv4_type {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147493377] = icmpv4_type
-
-class icmpv4_type_masked(oxm):
-    type_len = 2147493634
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        packed.append(struct.pack("!B", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = icmpv4_type_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147493634)
-        obj.value = reader.read("!B")[0]
-        obj.value_mask = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("icmpv4_type_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147493634] = icmpv4_type_masked
-
-class icmpv6_code(oxm):
-    type_len = 2147499009
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = icmpv6_code()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147499009)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("icmpv6_code {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147499009] = icmpv6_code
-
-class icmpv6_code_masked(oxm):
-    type_len = 2147499266
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        packed.append(struct.pack("!B", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = icmpv6_code_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147499266)
-        obj.value = reader.read("!B")[0]
-        obj.value_mask = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("icmpv6_code_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147499266] = icmpv6_code_masked
-
-class icmpv6_type(oxm):
-    type_len = 2147498497
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = icmpv6_type()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147498497)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("icmpv6_type {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147498497] = icmpv6_type
-
-class icmpv6_type_masked(oxm):
-    type_len = 2147498754
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        packed.append(struct.pack("!B", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = icmpv6_type_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147498754)
-        obj.value = reader.read("!B")[0]
-        obj.value_mask = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("icmpv6_type_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147498754] = icmpv6_type_masked
-
-class in_phy_port(oxm):
-    type_len = 2147484164
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(util.pack_port_no(self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = in_phy_port()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147484164)
-        obj.value = util.unpack_port_no(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("in_phy_port {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_port(self.value))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147484164] = in_phy_port
-
-class in_phy_port_masked(oxm):
-    type_len = 2147484424
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(util.pack_port_no(self.value))
-        packed.append(util.pack_port_no(self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = in_phy_port_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147484424)
-        obj.value = util.unpack_port_no(reader)
-        obj.value_mask = util.unpack_port_no(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("in_phy_port_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_port(self.value))
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text(util.pretty_port(self.value_mask))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147484424] = in_phy_port_masked
-
-class in_port(oxm):
-    type_len = 2147483652
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(util.pack_port_no(self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = in_port()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147483652)
-        obj.value = util.unpack_port_no(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("in_port {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_port(self.value))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147483652] = in_port
-
-class in_port_masked(oxm):
-    type_len = 2147483912
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(util.pack_port_no(self.value))
-        packed.append(util.pack_port_no(self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = in_port_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147483912)
-        obj.value = util.unpack_port_no(reader)
-        obj.value_mask = util.unpack_port_no(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("in_port_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_port(self.value))
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text(util.pretty_port(self.value_mask))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147483912] = in_port_masked
-
-class ip_dscp(oxm):
-    type_len = 2147487745
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ip_dscp()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147487745)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ip_dscp {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147487745] = ip_dscp
-
-class ip_dscp_masked(oxm):
-    type_len = 2147488002
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        packed.append(struct.pack("!B", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ip_dscp_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147488002)
-        obj.value = reader.read("!B")[0]
-        obj.value_mask = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ip_dscp_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147488002] = ip_dscp_masked
-
-class ip_ecn(oxm):
-    type_len = 2147488257
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ip_ecn()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147488257)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ip_ecn {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147488257] = ip_ecn
-
-class ip_ecn_masked(oxm):
-    type_len = 2147488514
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        packed.append(struct.pack("!B", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ip_ecn_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147488514)
-        obj.value = reader.read("!B")[0]
-        obj.value_mask = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ip_ecn_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147488514] = ip_ecn_masked
-
-class ip_proto(oxm):
-    type_len = 2147488769
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ip_proto()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147488769)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ip_proto {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147488769] = ip_proto
-
-class ip_proto_masked(oxm):
-    type_len = 2147489026
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        packed.append(struct.pack("!B", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ip_proto_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147489026)
-        obj.value = reader.read("!B")[0]
-        obj.value_mask = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ip_proto_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147489026] = ip_proto_masked
-
-class ipv4_dst(oxm):
-    type_len = 2147489796
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv4_dst()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147489796)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv4_dst {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_ipv4(self.value))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147489796] = ipv4_dst
-
-class ipv4_dst_masked(oxm):
-    type_len = 2147490056
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv4_dst_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147490056)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv4_dst_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_ipv4(self.value))
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text(util.pretty_ipv4(self.value_mask))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147490056] = ipv4_dst_masked
-
-class ipv4_src(oxm):
-    type_len = 2147489284
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv4_src()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147489284)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv4_src {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_ipv4(self.value))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147489284] = ipv4_src
-
-class ipv4_src_masked(oxm):
-    type_len = 2147489544
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv4_src_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147489544)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv4_src_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_ipv4(self.value))
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text(util.pretty_ipv4(self.value_mask))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147489544] = ipv4_src_masked
-
-class ipv6_dst(oxm):
-    type_len = 2147497488
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!16s", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv6_dst()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147497488)
-        obj.value = reader.read('!16s')[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv6_dst {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.pp(self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147497488] = ipv6_dst
-
-class ipv6_dst_masked(oxm):
-    type_len = 2147497760
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!16s", self.value))
-        packed.append(struct.pack("!16s", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv6_dst_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147497760)
-        obj.value = reader.read('!16s')[0]
-        obj.value_mask = reader.read('!16s')[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv6_dst_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.pp(self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.pp(self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147497760] = ipv6_dst_masked
-
-class ipv6_exthdr(oxm):
-    type_len = 2147503618
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv6_exthdr()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147503618)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv6_exthdr {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147503618] = ipv6_exthdr
-
-class ipv6_exthdr_masked(oxm):
-    type_len = 2147503876
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        packed.append(struct.pack("!H", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv6_exthdr_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147503876)
-        obj.value = reader.read("!H")[0]
-        obj.value_mask = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv6_exthdr_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147503876] = ipv6_exthdr_masked
-
-class ipv6_flabel(oxm):
-    type_len = 2147497988
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv6_flabel()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147497988)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv6_flabel {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147497988] = ipv6_flabel
-
-class ipv6_flabel_masked(oxm):
-    type_len = 2147498248
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv6_flabel_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147498248)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv6_flabel_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147498248] = ipv6_flabel_masked
-
-class ipv6_nd_sll(oxm):
-    type_len = 2147500038
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!6B", *self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv6_nd_sll()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147500038)
-        obj.value = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv6_nd_sll {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147500038] = ipv6_nd_sll
-
-class ipv6_nd_sll_masked(oxm):
-    type_len = 2147500300
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!6B", *self.value))
-        packed.append(struct.pack("!6B", *self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv6_nd_sll_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147500300)
-        obj.value = list(reader.read('!6B'))
-        obj.value_mask = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv6_nd_sll_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text(util.pretty_mac(self.value_mask))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147500300] = ipv6_nd_sll_masked
-
-class ipv6_nd_target(oxm):
-    type_len = 2147499536
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!16s", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv6_nd_target()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147499536)
-        obj.value = reader.read('!16s')[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv6_nd_target {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.pp(self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147499536] = ipv6_nd_target
-
-class ipv6_nd_target_masked(oxm):
-    type_len = 2147499808
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!16s", self.value))
-        packed.append(struct.pack("!16s", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv6_nd_target_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147499808)
-        obj.value = reader.read('!16s')[0]
-        obj.value_mask = reader.read('!16s')[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv6_nd_target_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.pp(self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.pp(self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147499808] = ipv6_nd_target_masked
-
-class ipv6_nd_tll(oxm):
-    type_len = 2147500550
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!6B", *self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv6_nd_tll()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147500550)
-        obj.value = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv6_nd_tll {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147500550] = ipv6_nd_tll
-
-class ipv6_nd_tll_masked(oxm):
-    type_len = 2147500812
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!6B", *self.value))
-        packed.append(struct.pack("!6B", *self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv6_nd_tll_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147500812)
-        obj.value = list(reader.read('!6B'))
-        obj.value_mask = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv6_nd_tll_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text(util.pretty_mac(self.value_mask))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147500812] = ipv6_nd_tll_masked
-
-class ipv6_src(oxm):
-    type_len = 2147496976
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!16s", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv6_src()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147496976)
-        obj.value = reader.read('!16s')[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv6_src {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.pp(self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147496976] = ipv6_src
-
-class ipv6_src_masked(oxm):
-    type_len = 2147497248
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!16s", self.value))
-        packed.append(struct.pack("!16s", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv6_src_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147497248)
-        obj.value = reader.read('!16s')[0]
-        obj.value_mask = reader.read('!16s')[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv6_src_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.pp(self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.pp(self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147497248] = ipv6_src_masked
-
-class metadata(oxm):
-    type_len = 2147484680
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!Q", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = metadata()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147484680)
-        obj.value = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("metadata {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147484680] = metadata
-
-class metadata_masked(oxm):
-    type_len = 2147484944
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!Q", self.value))
-        packed.append(struct.pack("!Q", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = metadata_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147484944)
-        obj.value = reader.read("!Q")[0]
-        obj.value_mask = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("metadata_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147484944] = metadata_masked
-
-class mpls_bos(oxm):
-    type_len = 2147502081
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = mpls_bos()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147502081)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("mpls_bos {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147502081] = mpls_bos
-
-class mpls_bos_masked(oxm):
-    type_len = 2147502338
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        packed.append(struct.pack("!B", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = mpls_bos_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147502338)
-        obj.value = reader.read("!B")[0]
-        obj.value_mask = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("mpls_bos_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147502338] = mpls_bos_masked
-
-class mpls_label(oxm):
-    type_len = 2147501060
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = mpls_label()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147501060)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("mpls_label {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147501060] = mpls_label
-
-class mpls_label_masked(oxm):
-    type_len = 2147501320
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = mpls_label_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147501320)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("mpls_label_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147501320] = mpls_label_masked
-
-class mpls_tc(oxm):
-    type_len = 2147501569
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = mpls_tc()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147501569)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("mpls_tc {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147501569] = mpls_tc
-
-class mpls_tc_masked(oxm):
-    type_len = 2147501826
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        packed.append(struct.pack("!B", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = mpls_tc_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147501826)
-        obj.value = reader.read("!B")[0]
-        obj.value_mask = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("mpls_tc_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147501826] = mpls_tc_masked
-
-class sctp_dst(oxm):
-    type_len = 2147492866
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = sctp_dst()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147492866)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("sctp_dst {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147492866] = sctp_dst
-
-class sctp_dst_masked(oxm):
-    type_len = 2147493124
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        packed.append(struct.pack("!H", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = sctp_dst_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147493124)
-        obj.value = reader.read("!H")[0]
-        obj.value_mask = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("sctp_dst_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147493124] = sctp_dst_masked
-
-class sctp_src(oxm):
-    type_len = 2147492354
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = sctp_src()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147492354)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("sctp_src {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147492354] = sctp_src
-
-class sctp_src_masked(oxm):
-    type_len = 2147492612
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        packed.append(struct.pack("!H", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = sctp_src_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147492612)
-        obj.value = reader.read("!H")[0]
-        obj.value_mask = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("sctp_src_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147492612] = sctp_src_masked
-
-class tcp_dst(oxm):
-    type_len = 2147490818
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = tcp_dst()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147490818)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("tcp_dst {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147490818] = tcp_dst
-
-class tcp_dst_masked(oxm):
-    type_len = 2147491076
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        packed.append(struct.pack("!H", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = tcp_dst_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147491076)
-        obj.value = reader.read("!H")[0]
-        obj.value_mask = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("tcp_dst_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147491076] = tcp_dst_masked
-
-class tcp_src(oxm):
-    type_len = 2147490306
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = tcp_src()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147490306)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("tcp_src {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147490306] = tcp_src
-
-class tcp_src_masked(oxm):
-    type_len = 2147490564
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        packed.append(struct.pack("!H", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = tcp_src_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147490564)
-        obj.value = reader.read("!H")[0]
-        obj.value_mask = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("tcp_src_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147490564] = tcp_src_masked
-
-class tunnel_id(oxm):
-    type_len = 2147503112
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!Q", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = tunnel_id()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147503112)
-        obj.value = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("tunnel_id {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147503112] = tunnel_id
-
-class tunnel_id_masked(oxm):
-    type_len = 2147503376
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!Q", self.value))
-        packed.append(struct.pack("!Q", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = tunnel_id_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147503376)
-        obj.value = reader.read("!Q")[0]
-        obj.value_mask = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("tunnel_id_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147503376] = tunnel_id_masked
-
-class tunnel_ipv4_dst(oxm):
-    type_len = 81924
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = tunnel_ipv4_dst()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 81924)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("tunnel_ipv4_dst {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_ipv4(self.value))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[81924] = tunnel_ipv4_dst
-
-class tunnel_ipv4_dst_masked(oxm):
-    type_len = 82184
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = tunnel_ipv4_dst_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 82184)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("tunnel_ipv4_dst_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_ipv4(self.value))
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text(util.pretty_ipv4(self.value_mask))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[82184] = tunnel_ipv4_dst_masked
-
-class tunnel_ipv4_src(oxm):
-    type_len = 81412
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = tunnel_ipv4_src()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 81412)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("tunnel_ipv4_src {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_ipv4(self.value))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[81412] = tunnel_ipv4_src
-
-class tunnel_ipv4_src_masked(oxm):
-    type_len = 81672
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = tunnel_ipv4_src_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 81672)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("tunnel_ipv4_src_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_ipv4(self.value))
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text(util.pretty_ipv4(self.value_mask))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[81672] = tunnel_ipv4_src_masked
-
-class udp_dst(oxm):
-    type_len = 2147491842
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = udp_dst()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147491842)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("udp_dst {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147491842] = udp_dst
-
-class udp_dst_masked(oxm):
-    type_len = 2147492100
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        packed.append(struct.pack("!H", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = udp_dst_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147492100)
-        obj.value = reader.read("!H")[0]
-        obj.value_mask = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("udp_dst_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147492100] = udp_dst_masked
-
-class udp_src(oxm):
-    type_len = 2147491330
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = udp_src()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147491330)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("udp_src {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147491330] = udp_src
-
-class udp_src_masked(oxm):
-    type_len = 2147491588
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        packed.append(struct.pack("!H", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = udp_src_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147491588)
-        obj.value = reader.read("!H")[0]
-        obj.value_mask = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("udp_src_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147491588] = udp_src_masked
-
-class vlan_pcp(oxm):
-    type_len = 2147487233
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = vlan_pcp()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147487233)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("vlan_pcp {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147487233] = vlan_pcp
-
-class vlan_pcp_masked(oxm):
-    type_len = 2147487490
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        packed.append(struct.pack("!B", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = vlan_pcp_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147487490)
-        obj.value = reader.read("!B")[0]
-        obj.value_mask = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("vlan_pcp_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147487490] = vlan_pcp_masked
-
-class vlan_vid(oxm):
-    type_len = 2147486722
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = vlan_vid()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147486722)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("vlan_vid {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147486722] = vlan_vid
-
-class vlan_vid_masked(oxm):
-    type_len = 2147486980
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        packed.append(struct.pack("!H", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = vlan_vid_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147486980)
-        obj.value = reader.read("!H")[0]
-        obj.value_mask = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("vlan_vid_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147486980] = vlan_vid_masked
-
-
diff --git a/python/ofagent/loxi/of13/util.py b/python/ofagent/loxi/of13/util.py
deleted file mode 100644
index e88d022..0000000
--- a/python/ofagent/loxi/of13/util.py
+++ /dev/null
@@ -1,146 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-# Automatically generated by LOXI from template util.py
-# Do not modify
-
-import struct
-import loxi
-import const
-import common
-import action
-import instruction
-import oxm
-import action_id
-import instruction_id
-import meter_band
-
-def pretty_mac(mac):
-    return ':'.join(["%02x" % x for x in mac])
-
-def pretty_ipv4(v):
-    return "%d.%d.%d.%d" % ((v >> 24) & 0xFF, (v >> 16) & 0xFF, (v >> 8) & 0xFF, v & 0xFF)
-
-def pretty_flags(v, flag_names):
-    set_flags = []
-    for flag_name in flag_names:
-        flag_value = getattr(const, flag_name)
-        if v & flag_value == flag_value:
-            set_flags.append(flag_name)
-        elif v & flag_value:
-            set_flags.append('%s&%#x' % (flag_name, v & flag_value))
-        v &= ~flag_value
-    if v:
-        set_flags.append("%#x" % v)
-    return '|'.join(set_flags) or '0'
-
-
-def pretty_port(v):
-    named_ports = [(k,v2) for (k,v2) in const.__dict__.iteritems() if k.startswith('OFPP_')]
-    for (k, v2) in named_ports:
-        if v == v2:
-            return k
-    return v
-
-def pack_port_no(value):
-    return struct.pack("!L", value)
-
-def unpack_port_no(reader):
-    return reader.read("!L")[0]
-
-def pack_fm_cmd(value):
-    return struct.pack("!B", value)
-
-def unpack_fm_cmd(reader):
-    return reader.read("!B")[0]
-
-def init_wc_bmap():
-    return 0
-
-def pack_wc_bmap(value):
-    return struct.pack("!Q", value)
-
-def unpack_wc_bmap(reader):
-    return reader.read("!Q")[0]
-
-def init_match_bmap():
-    return 0
-
-def pack_match_bmap(value):
-    return struct.pack("!Q", value)
-
-def unpack_match_bmap(reader):
-    return reader.read("!Q")[0]
-
-MASK64 = (1 << 64) - 1
-
-def pack_bitmap_128(value):
-    x = 0l
-    for y in value:
-        x |= 1 << y
-    return struct.pack("!QQ", (x >> 64) & MASK64, x & MASK64)
-
-def unpack_bitmap_128(reader):
-    hi, lo = reader.read("!QQ")
-    x = (hi << 64) | lo
-    i = 0
-    value = set()
-    while x != 0:
-        if x & 1 == 1:
-            value.add(i)
-        i += 1
-        x >>= 1
-    return value
-
-def pack_bitmap_512(value):
-    words = [0] * 8
-    for v in value:
-        assert v < 512
-        words[7-v/64] |= 1 << (v % 64)
-    return struct.pack("!8Q", *words)
-
-def unpack_bitmap_512(reader):
-    words = reader.read("!8Q")
-    x = 0l
-    for word in words:
-        x <<= 64
-        x |= word
-    i = 0
-    value = set()
-    while x != 0:
-        if x & 1 == 1:
-            value.add(i)
-        i += 1
-        x >>= 1
-    return value
-
-def pack_checksum_128(value):
-    return struct.pack("!QQ", (value >> 64) & MASK64, value & MASK64)
-
-def unpack_checksum_128(reader):
-    hi, lo = reader.read("!QQ")
-    return (hi << 64) | lo
-
-def bitmap_to_version(bitmaps):
-    versions = [i * 32 + shift
-                for i, bitmap in enumerate(bitmaps)
-                for shift in range(31) if bitmap & (1 << shift)]
-    return versions
-
-def verify_version_support(msg,version_list):
-    version_list_sup = bitmap_to_version([msg.elements[0].bitmaps[0].value])
-    return any(i in version_list_sup for i in version_list)
diff --git a/python/ofagent/loxi/of14/__init__.py b/python/ofagent/loxi/of14/__init__.py
deleted file mode 100644
index e256fbb..0000000
--- a/python/ofagent/loxi/of14/__init__.py
+++ /dev/null
@@ -1,43 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template init.py
-# Do not modify
-
-import const
-import port_desc_prop
-import bsn_tlv
-import meter_band
-import table_mod_prop
-import instruction
-import queue_desc_prop
-import oxm
-import bundle_prop
-import common
-import instruction_id
-import action
-import role_prop
-import message
-import queue_stats_prop
-import port_stats_prop
-import port_mod_prop
-import async_config_prop
-import action_id
-from const import *
-from common import *
-from loxi import ProtocolError
diff --git a/python/ofagent/loxi/of14/action.py b/python/ofagent/loxi/of14/action.py
deleted file mode 100644
index d03b05d..0000000
--- a/python/ofagent/loxi/of14/action.py
+++ /dev/null
@@ -1,1298 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template module.py
-# Do not modify
-
-import struct
-import loxi
-import util
-import loxi.generic_util
-
-import sys
-ofp = sys.modules['loxi.of14']
-
-class action(loxi.OFObject):
-    subtypes = {}
-
-
-    def __init__(self, type=None):
-        if type != None:
-            self.type = type
-        else:
-            self.type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 0)
-        subclass = action.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = action()
-        obj.type = reader.read("!H")[0]
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type != other.type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("action {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-
-class experimenter(action):
-    subtypes = {}
-
-    type = 65535
-
-    def __init__(self, experimenter=None, data=None):
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed.append(loxi.generic_util.pad_to(8, length))
-        length += len(packed[-1])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 4)
-        subclass = experimenter.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = experimenter()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.experimenter = reader.read("!L")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.experimenter != other.experimenter: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("experimenter {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[65535] = experimenter
-
-class bsn(experimenter):
-    subtypes = {}
-
-    type = 65535
-    experimenter = 6035143
-
-    def __init__(self, subtype=None):
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 8)
-        subclass = bsn.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = bsn()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        obj.subtype = reader.read("!L")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.subtype != other.subtype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-experimenter.subtypes[6035143] = bsn
-
-class bsn_checksum(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 4
-
-    def __init__(self, checksum=None):
-        if checksum != None:
-            self.checksum = checksum
-        else:
-            self.checksum = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(util.pack_checksum_128(self.checksum))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_checksum()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 4)
-        obj.checksum = util.unpack_checksum_128(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.checksum != other.checksum: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_checksum {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("checksum = ");
-                q.pp(self.checksum)
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[4] = bsn_checksum
-
-class bsn_gentable(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 5
-
-    def __init__(self, table_id=None, key=None):
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if key != None:
-            self.key = key
-        else:
-            self.key = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.table_id))
-        packed.append(loxi.generic_util.pack_list(self.key))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_gentable()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 5)
-        obj.table_id = reader.read("!L")[0]
-        obj.key = loxi.generic_util.unpack_list(reader, ofp.bsn_tlv.bsn_tlv.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.table_id != other.table_id: return False
-        if self.key != other.key: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_gentable {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("key = ");
-                q.pp(self.key)
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[5] = bsn_gentable
-
-class bsn_mirror(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 1
-
-    def __init__(self, dest_port=None, vlan_tag=None, copy_stage=None):
-        if dest_port != None:
-            self.dest_port = dest_port
-        else:
-            self.dest_port = 0
-        if vlan_tag != None:
-            self.vlan_tag = vlan_tag
-        else:
-            self.vlan_tag = 0
-        if copy_stage != None:
-            self.copy_stage = copy_stage
-        else:
-            self.copy_stage = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.dest_port))
-        packed.append(struct.pack("!L", self.vlan_tag))
-        packed.append(struct.pack("!B", self.copy_stage))
-        packed.append('\x00' * 3)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_mirror()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 1)
-        obj.dest_port = reader.read("!L")[0]
-        obj.vlan_tag = reader.read("!L")[0]
-        obj.copy_stage = reader.read("!B")[0]
-        reader.skip(3)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.dest_port != other.dest_port: return False
-        if self.vlan_tag != other.vlan_tag: return False
-        if self.copy_stage != other.copy_stage: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_mirror {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("dest_port = ");
-                q.text("%#x" % self.dest_port)
-                q.text(","); q.breakable()
-                q.text("vlan_tag = ");
-                q.text("%#x" % self.vlan_tag)
-                q.text(","); q.breakable()
-                q.text("copy_stage = ");
-                q.text("%#x" % self.copy_stage)
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[1] = bsn_mirror
-
-class bsn_set_tunnel_dst(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 2
-
-    def __init__(self, dst=None):
-        if dst != None:
-            self.dst = dst
-        else:
-            self.dst = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.dst))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_set_tunnel_dst()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 2)
-        obj.dst = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.dst != other.dst: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_set_tunnel_dst {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("dst = ");
-                q.text("%#x" % self.dst)
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[2] = bsn_set_tunnel_dst
-
-class copy_ttl_in(action):
-    type = 12
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = copy_ttl_in()
-        _type = reader.read("!H")[0]
-        assert(_type == 12)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("copy_ttl_in {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action.subtypes[12] = copy_ttl_in
-
-class copy_ttl_out(action):
-    type = 11
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = copy_ttl_out()
-        _type = reader.read("!H")[0]
-        assert(_type == 11)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("copy_ttl_out {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action.subtypes[11] = copy_ttl_out
-
-class dec_mpls_ttl(action):
-    type = 16
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = dec_mpls_ttl()
-        _type = reader.read("!H")[0]
-        assert(_type == 16)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("dec_mpls_ttl {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action.subtypes[16] = dec_mpls_ttl
-
-class dec_nw_ttl(action):
-    type = 24
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = dec_nw_ttl()
-        _type = reader.read("!H")[0]
-        assert(_type == 24)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("dec_nw_ttl {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action.subtypes[24] = dec_nw_ttl
-
-class group(action):
-    type = 22
-
-    def __init__(self, group_id=None):
-        if group_id != None:
-            self.group_id = group_id
-        else:
-            self.group_id = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.group_id))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group()
-        _type = reader.read("!H")[0]
-        assert(_type == 22)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.group_id = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.group_id != other.group_id: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("group_id = ");
-                q.text("%#x" % self.group_id)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[22] = group
-
-class nicira(experimenter):
-    subtypes = {}
-
-    type = 65535
-    experimenter = 8992
-
-    def __init__(self, subtype=None):
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!H", self.subtype))
-        packed.append('\x00' * 2)
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 8)
-        subclass = nicira.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = nicira()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 8992)
-        obj.subtype = reader.read("!H")[0]
-        reader.skip(2)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.subtype != other.subtype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("nicira {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-experimenter.subtypes[8992] = nicira
-
-class nicira_dec_ttl(nicira):
-    type = 65535
-    experimenter = 8992
-    subtype = 18
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!H", self.subtype))
-        packed.append('\x00' * 2)
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = nicira_dec_ttl()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 8992)
-        _subtype = reader.read("!H")[0]
-        assert(_subtype == 18)
-        reader.skip(2)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("nicira_dec_ttl {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-nicira.subtypes[18] = nicira_dec_ttl
-
-class output(action):
-    type = 0
-
-    def __init__(self, port=None, max_len=None):
-        if port != None:
-            self.port = port
-        else:
-            self.port = 0
-        if max_len != None:
-            self.max_len = max_len
-        else:
-            self.max_len = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(util.pack_port_no(self.port))
-        packed.append(struct.pack("!H", self.max_len))
-        packed.append('\x00' * 6)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = output()
-        _type = reader.read("!H")[0]
-        assert(_type == 0)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.port = util.unpack_port_no(reader)
-        obj.max_len = reader.read("!H")[0]
-        reader.skip(6)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.port != other.port: return False
-        if self.max_len != other.max_len: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("output {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("port = ");
-                q.text(util.pretty_port(self.port))
-                q.text(","); q.breakable()
-                q.text("max_len = ");
-                q.text("%#x" % self.max_len)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[0] = output
-
-class pop_mpls(action):
-    type = 20
-
-    def __init__(self, ethertype=None):
-        if ethertype != None:
-            self.ethertype = ethertype
-        else:
-            self.ethertype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!H", self.ethertype))
-        packed.append('\x00' * 2)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = pop_mpls()
-        _type = reader.read("!H")[0]
-        assert(_type == 20)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.ethertype = reader.read("!H")[0]
-        reader.skip(2)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.ethertype != other.ethertype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("pop_mpls {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("ethertype = ");
-                q.text("%#x" % self.ethertype)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[20] = pop_mpls
-
-class pop_pbb(action):
-    type = 27
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = pop_pbb()
-        _type = reader.read("!H")[0]
-        assert(_type == 27)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("pop_pbb {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action.subtypes[27] = pop_pbb
-
-class pop_vlan(action):
-    type = 18
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = pop_vlan()
-        _type = reader.read("!H")[0]
-        assert(_type == 18)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("pop_vlan {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action.subtypes[18] = pop_vlan
-
-class push_mpls(action):
-    type = 19
-
-    def __init__(self, ethertype=None):
-        if ethertype != None:
-            self.ethertype = ethertype
-        else:
-            self.ethertype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!H", self.ethertype))
-        packed.append('\x00' * 2)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = push_mpls()
-        _type = reader.read("!H")[0]
-        assert(_type == 19)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.ethertype = reader.read("!H")[0]
-        reader.skip(2)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.ethertype != other.ethertype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("push_mpls {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("ethertype = ");
-                q.text("%#x" % self.ethertype)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[19] = push_mpls
-
-class push_pbb(action):
-    type = 26
-
-    def __init__(self, ethertype=None):
-        if ethertype != None:
-            self.ethertype = ethertype
-        else:
-            self.ethertype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!H", self.ethertype))
-        packed.append('\x00' * 2)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = push_pbb()
-        _type = reader.read("!H")[0]
-        assert(_type == 26)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.ethertype = reader.read("!H")[0]
-        reader.skip(2)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.ethertype != other.ethertype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("push_pbb {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("ethertype = ");
-                q.text("%#x" % self.ethertype)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[26] = push_pbb
-
-class push_vlan(action):
-    type = 17
-
-    def __init__(self, ethertype=None):
-        if ethertype != None:
-            self.ethertype = ethertype
-        else:
-            self.ethertype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!H", self.ethertype))
-        packed.append('\x00' * 2)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = push_vlan()
-        _type = reader.read("!H")[0]
-        assert(_type == 17)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.ethertype = reader.read("!H")[0]
-        reader.skip(2)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.ethertype != other.ethertype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("push_vlan {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("ethertype = ");
-                q.text("%#x" % self.ethertype)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[17] = push_vlan
-
-class set_field(action):
-    type = 25
-
-    def __init__(self, field=None):
-        if field != None:
-            self.field = field
-        else:
-            self.field = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(self.field.pack())
-        length = sum([len(x) for x in packed])
-        packed.append(loxi.generic_util.pad_to(8, length))
-        length += len(packed[-1])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_field()
-        _type = reader.read("!H")[0]
-        assert(_type == 25)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.field = ofp.oxm.oxm.unpack(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.field != other.field: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_field {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("field = ");
-                q.pp(self.field)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[25] = set_field
-
-class set_mpls_ttl(action):
-    type = 15
-
-    def __init__(self, mpls_ttl=None):
-        if mpls_ttl != None:
-            self.mpls_ttl = mpls_ttl
-        else:
-            self.mpls_ttl = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!B", self.mpls_ttl))
-        packed.append('\x00' * 3)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_mpls_ttl()
-        _type = reader.read("!H")[0]
-        assert(_type == 15)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.mpls_ttl = reader.read("!B")[0]
-        reader.skip(3)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.mpls_ttl != other.mpls_ttl: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_mpls_ttl {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("mpls_ttl = ");
-                q.text("%#x" % self.mpls_ttl)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[15] = set_mpls_ttl
-
-class set_nw_ttl(action):
-    type = 23
-
-    def __init__(self, nw_ttl=None):
-        if nw_ttl != None:
-            self.nw_ttl = nw_ttl
-        else:
-            self.nw_ttl = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!B", self.nw_ttl))
-        packed.append('\x00' * 3)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_nw_ttl()
-        _type = reader.read("!H")[0]
-        assert(_type == 23)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.nw_ttl = reader.read("!B")[0]
-        reader.skip(3)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.nw_ttl != other.nw_ttl: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_nw_ttl {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("nw_ttl = ");
-                q.text("%#x" % self.nw_ttl)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[23] = set_nw_ttl
-
-class set_queue(action):
-    type = 21
-
-    def __init__(self, queue_id=None):
-        if queue_id != None:
-            self.queue_id = queue_id
-        else:
-            self.queue_id = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.queue_id))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_queue()
-        _type = reader.read("!H")[0]
-        assert(_type == 21)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.queue_id = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.queue_id != other.queue_id: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_queue {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("queue_id = ");
-                q.text("%#x" % self.queue_id)
-            q.breakable()
-        q.text('}')
-
-action.subtypes[21] = set_queue
-
-
diff --git a/python/ofagent/loxi/of14/action_id.py b/python/ofagent/loxi/of14/action_id.py
deleted file mode 100644
index 1ff80ff..0000000
--- a/python/ofagent/loxi/of14/action_id.py
+++ /dev/null
@@ -1,1079 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template module.py
-# Do not modify
-
-import struct
-import loxi
-import util
-import loxi.generic_util
-
-import sys
-ofp = sys.modules['loxi.of14']
-
-class action_id(loxi.OFObject):
-    subtypes = {}
-
-
-    def __init__(self, type=None):
-        if type != None:
-            self.type = type
-        else:
-            self.type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 0)
-        subclass = action_id.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = action_id()
-        obj.type = reader.read("!H")[0]
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type != other.type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("action_id {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-
-class experimenter(action_id):
-    subtypes = {}
-
-    type = 65535
-
-    def __init__(self, experimenter=None):
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 4)
-        subclass = experimenter.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = experimenter()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.experimenter = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.experimenter != other.experimenter: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("experimenter {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action_id.subtypes[65535] = experimenter
-
-class bsn(experimenter):
-    subtypes = {}
-
-    type = 65535
-    experimenter = 6035143
-
-    def __init__(self, subtype=None):
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 8)
-        subclass = bsn.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = bsn()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        obj.subtype = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.subtype != other.subtype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-experimenter.subtypes[6035143] = bsn
-
-class bsn_checksum(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 4
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_checksum()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_checksum {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[4] = bsn_checksum
-
-class bsn_gentable(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 5
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_gentable()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 5)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_gentable {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[5] = bsn_gentable
-
-class bsn_mirror(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 1
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_mirror()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 1)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_mirror {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[1] = bsn_mirror
-
-class bsn_set_tunnel_dst(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 2
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_set_tunnel_dst()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 2)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_set_tunnel_dst {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[2] = bsn_set_tunnel_dst
-
-class copy_ttl_in(action_id):
-    type = 12
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = copy_ttl_in()
-        _type = reader.read("!H")[0]
-        assert(_type == 12)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("copy_ttl_in {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action_id.subtypes[12] = copy_ttl_in
-
-class copy_ttl_out(action_id):
-    type = 11
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = copy_ttl_out()
-        _type = reader.read("!H")[0]
-        assert(_type == 11)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("copy_ttl_out {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action_id.subtypes[11] = copy_ttl_out
-
-class dec_mpls_ttl(action_id):
-    type = 16
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = dec_mpls_ttl()
-        _type = reader.read("!H")[0]
-        assert(_type == 16)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("dec_mpls_ttl {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action_id.subtypes[16] = dec_mpls_ttl
-
-class dec_nw_ttl(action_id):
-    type = 24
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = dec_nw_ttl()
-        _type = reader.read("!H")[0]
-        assert(_type == 24)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("dec_nw_ttl {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action_id.subtypes[24] = dec_nw_ttl
-
-class group(action_id):
-    type = 22
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group()
-        _type = reader.read("!H")[0]
-        assert(_type == 22)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action_id.subtypes[22] = group
-
-class nicira(experimenter):
-    subtypes = {}
-
-    type = 65535
-    experimenter = 8992
-
-    def __init__(self, subtype=None):
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!H", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 8)
-        subclass = nicira.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = nicira()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 8992)
-        obj.subtype = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.subtype != other.subtype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("nicira {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-experimenter.subtypes[8992] = nicira
-
-class nicira_dec_ttl(nicira):
-    type = 65535
-    experimenter = 8992
-    subtype = 18
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!H", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = nicira_dec_ttl()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 8992)
-        _subtype = reader.read("!H")[0]
-        assert(_subtype == 18)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("nicira_dec_ttl {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-nicira.subtypes[18] = nicira_dec_ttl
-
-class output(action_id):
-    type = 0
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = output()
-        _type = reader.read("!H")[0]
-        assert(_type == 0)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("output {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action_id.subtypes[0] = output
-
-class pop_mpls(action_id):
-    type = 20
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = pop_mpls()
-        _type = reader.read("!H")[0]
-        assert(_type == 20)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("pop_mpls {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action_id.subtypes[20] = pop_mpls
-
-class pop_pbb(action_id):
-    type = 27
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = pop_pbb()
-        _type = reader.read("!H")[0]
-        assert(_type == 27)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("pop_pbb {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action_id.subtypes[27] = pop_pbb
-
-class pop_vlan(action_id):
-    type = 18
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = pop_vlan()
-        _type = reader.read("!H")[0]
-        assert(_type == 18)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("pop_vlan {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action_id.subtypes[18] = pop_vlan
-
-class push_mpls(action_id):
-    type = 19
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = push_mpls()
-        _type = reader.read("!H")[0]
-        assert(_type == 19)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("push_mpls {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action_id.subtypes[19] = push_mpls
-
-class push_pbb(action_id):
-    type = 26
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = push_pbb()
-        _type = reader.read("!H")[0]
-        assert(_type == 26)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("push_pbb {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action_id.subtypes[26] = push_pbb
-
-class push_vlan(action_id):
-    type = 17
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = push_vlan()
-        _type = reader.read("!H")[0]
-        assert(_type == 17)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("push_vlan {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action_id.subtypes[17] = push_vlan
-
-class set_field(action_id):
-    type = 25
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_field()
-        _type = reader.read("!H")[0]
-        assert(_type == 25)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_field {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action_id.subtypes[25] = set_field
-
-class set_mpls_ttl(action_id):
-    type = 15
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_mpls_ttl()
-        _type = reader.read("!H")[0]
-        assert(_type == 15)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_mpls_ttl {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action_id.subtypes[15] = set_mpls_ttl
-
-class set_nw_ttl(action_id):
-    type = 23
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_nw_ttl()
-        _type = reader.read("!H")[0]
-        assert(_type == 23)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_nw_ttl {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action_id.subtypes[23] = set_nw_ttl
-
-class set_queue(action_id):
-    type = 21
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_queue()
-        _type = reader.read("!H")[0]
-        assert(_type == 21)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_queue {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-action_id.subtypes[21] = set_queue
-
-
diff --git a/python/ofagent/loxi/of14/async_config_prop.py b/python/ofagent/loxi/of14/async_config_prop.py
deleted file mode 100644
index 6188c87..0000000
--- a/python/ofagent/loxi/of14/async_config_prop.py
+++ /dev/null
@@ -1,717 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template module.py
-# Do not modify
-
-import struct
-import loxi
-import util
-import loxi.generic_util
-
-import sys
-ofp = sys.modules['loxi.of14']
-
-class async_config_prop(loxi.OFObject):
-    subtypes = {}
-
-
-    def __init__(self, type=None):
-        if type != None:
-            self.type = type
-        else:
-            self.type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 0)
-        subclass = async_config_prop.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = async_config_prop()
-        obj.type = reader.read("!H")[0]
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type != other.type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("async_config_prop {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-
-class experimenter_master(async_config_prop):
-    type = 65535
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = experimenter_master()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("experimenter_master {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-async_config_prop.subtypes[65535] = experimenter_master
-
-class experimenter_slave(async_config_prop):
-    type = 65534
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = experimenter_slave()
-        _type = reader.read("!H")[0]
-        assert(_type == 65534)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("experimenter_slave {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-async_config_prop.subtypes[65534] = experimenter_slave
-
-class flow_removed_master(async_config_prop):
-    type = 5
-
-    def __init__(self, mask=None):
-        if mask != None:
-            self.mask = mask
-        else:
-            self.mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.mask))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_removed_master()
-        _type = reader.read("!H")[0]
-        assert(_type == 5)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.mask != other.mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_removed_master {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("mask = ");
-                q.text("%#x" % self.mask)
-            q.breakable()
-        q.text('}')
-
-async_config_prop.subtypes[5] = flow_removed_master
-
-class flow_removed_slave(async_config_prop):
-    type = 4
-
-    def __init__(self, mask=None):
-        if mask != None:
-            self.mask = mask
-        else:
-            self.mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.mask))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_removed_slave()
-        _type = reader.read("!H")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.mask != other.mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_removed_slave {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("mask = ");
-                q.text("%#x" % self.mask)
-            q.breakable()
-        q.text('}')
-
-async_config_prop.subtypes[4] = flow_removed_slave
-
-class packet_in_master(async_config_prop):
-    type = 1
-
-    def __init__(self, mask=None):
-        if mask != None:
-            self.mask = mask
-        else:
-            self.mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.mask))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = packet_in_master()
-        _type = reader.read("!H")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.mask != other.mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("packet_in_master {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("mask = ");
-                q.text("%#x" % self.mask)
-            q.breakable()
-        q.text('}')
-
-async_config_prop.subtypes[1] = packet_in_master
-
-class packet_in_slave(async_config_prop):
-    type = 0
-
-    def __init__(self, mask=None):
-        if mask != None:
-            self.mask = mask
-        else:
-            self.mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.mask))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = packet_in_slave()
-        _type = reader.read("!H")[0]
-        assert(_type == 0)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.mask != other.mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("packet_in_slave {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("mask = ");
-                q.text("%#x" % self.mask)
-            q.breakable()
-        q.text('}')
-
-async_config_prop.subtypes[0] = packet_in_slave
-
-class port_status_master(async_config_prop):
-    type = 3
-
-    def __init__(self, mask=None):
-        if mask != None:
-            self.mask = mask
-        else:
-            self.mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.mask))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = port_status_master()
-        _type = reader.read("!H")[0]
-        assert(_type == 3)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.mask != other.mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port_status_master {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("mask = ");
-                q.text("%#x" % self.mask)
-            q.breakable()
-        q.text('}')
-
-async_config_prop.subtypes[3] = port_status_master
-
-class port_status_slave(async_config_prop):
-    type = 2
-
-    def __init__(self, mask=None):
-        if mask != None:
-            self.mask = mask
-        else:
-            self.mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.mask))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = port_status_slave()
-        _type = reader.read("!H")[0]
-        assert(_type == 2)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.mask != other.mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port_status_slave {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("mask = ");
-                q.text("%#x" % self.mask)
-            q.breakable()
-        q.text('}')
-
-async_config_prop.subtypes[2] = port_status_slave
-
-class requestforward_master(async_config_prop):
-    type = 11
-
-    def __init__(self, mask=None):
-        if mask != None:
-            self.mask = mask
-        else:
-            self.mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.mask))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = requestforward_master()
-        _type = reader.read("!H")[0]
-        assert(_type == 11)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.mask != other.mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("requestforward_master {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("mask = ");
-                q.text("%#x" % self.mask)
-            q.breakable()
-        q.text('}')
-
-async_config_prop.subtypes[11] = requestforward_master
-
-class requestforward_slave(async_config_prop):
-    type = 10
-
-    def __init__(self, mask=None):
-        if mask != None:
-            self.mask = mask
-        else:
-            self.mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.mask))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = requestforward_slave()
-        _type = reader.read("!H")[0]
-        assert(_type == 10)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.mask != other.mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("requestforward_slave {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("mask = ");
-                q.text("%#x" % self.mask)
-            q.breakable()
-        q.text('}')
-
-async_config_prop.subtypes[10] = requestforward_slave
-
-class role_status_master(async_config_prop):
-    type = 7
-
-    def __init__(self, mask=None):
-        if mask != None:
-            self.mask = mask
-        else:
-            self.mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.mask))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = role_status_master()
-        _type = reader.read("!H")[0]
-        assert(_type == 7)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.mask != other.mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("role_status_master {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("mask = ");
-                q.text("%#x" % self.mask)
-            q.breakable()
-        q.text('}')
-
-async_config_prop.subtypes[7] = role_status_master
-
-class role_status_slave(async_config_prop):
-    type = 6
-
-    def __init__(self, mask=None):
-        if mask != None:
-            self.mask = mask
-        else:
-            self.mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.mask))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = role_status_slave()
-        _type = reader.read("!H")[0]
-        assert(_type == 6)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.mask != other.mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("role_status_slave {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("mask = ");
-                q.text("%#x" % self.mask)
-            q.breakable()
-        q.text('}')
-
-async_config_prop.subtypes[6] = role_status_slave
-
-class table_status_master(async_config_prop):
-    type = 9
-
-    def __init__(self, mask=None):
-        if mask != None:
-            self.mask = mask
-        else:
-            self.mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.mask))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_status_master()
-        _type = reader.read("!H")[0]
-        assert(_type == 9)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.mask != other.mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_status_master {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("mask = ");
-                q.text("%#x" % self.mask)
-            q.breakable()
-        q.text('}')
-
-async_config_prop.subtypes[9] = table_status_master
-
-class table_status_slave(async_config_prop):
-    type = 8
-
-    def __init__(self, mask=None):
-        if mask != None:
-            self.mask = mask
-        else:
-            self.mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.mask))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_status_slave()
-        _type = reader.read("!H")[0]
-        assert(_type == 8)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.mask != other.mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_status_slave {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("mask = ");
-                q.text("%#x" % self.mask)
-            q.breakable()
-        q.text('}')
-
-async_config_prop.subtypes[8] = table_status_slave
-
-
diff --git a/python/ofagent/loxi/of14/bsn_tlv.py b/python/ofagent/loxi/of14/bsn_tlv.py
deleted file mode 100644
index 125f534..0000000
--- a/python/ofagent/loxi/of14/bsn_tlv.py
+++ /dev/null
@@ -1,4801 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template module.py
-# Do not modify
-
-import struct
-import loxi
-import util
-import loxi.generic_util
-
-import sys
-ofp = sys.modules['loxi.of14']
-
-class bsn_tlv(loxi.OFObject):
-    subtypes = {}
-
-
-    def __init__(self, type=None):
-        if type != None:
-            self.type = type
-        else:
-            self.type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 0)
-        subclass = bsn_tlv.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = bsn_tlv()
-        obj.type = reader.read("!H")[0]
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type != other.type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_tlv {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-
-class actor_key(bsn_tlv):
-    type = 44
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = actor_key()
-        _type = reader.read("!H")[0]
-        assert(_type == 44)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("actor_key {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[44] = actor_key
-
-class actor_port_num(bsn_tlv):
-    type = 43
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = actor_port_num()
-        _type = reader.read("!H")[0]
-        assert(_type == 43)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("actor_port_num {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[43] = actor_port_num
-
-class actor_port_priority(bsn_tlv):
-    type = 42
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = actor_port_priority()
-        _type = reader.read("!H")[0]
-        assert(_type == 42)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("actor_port_priority {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[42] = actor_port_priority
-
-class actor_state(bsn_tlv):
-    type = 53
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!B", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = actor_state()
-        _type = reader.read("!H")[0]
-        assert(_type == 53)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("actor_state {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[53] = actor_state
-
-class actor_system_mac(bsn_tlv):
-    type = 41
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!6B", *self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = actor_system_mac()
-        _type = reader.read("!H")[0]
-        assert(_type == 41)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("actor_system_mac {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[41] = actor_system_mac
-
-class actor_system_priority(bsn_tlv):
-    type = 40
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = actor_system_priority()
-        _type = reader.read("!H")[0]
-        assert(_type == 40)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("actor_system_priority {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[40] = actor_system_priority
-
-class anchor(bsn_tlv):
-    type = 81
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = anchor()
-        _type = reader.read("!H")[0]
-        assert(_type == 81)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("anchor {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[81] = anchor
-
-class broadcast_query_timeout(bsn_tlv):
-    type = 10
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = broadcast_query_timeout()
-        _type = reader.read("!H")[0]
-        assert(_type == 10)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("broadcast_query_timeout {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[10] = broadcast_query_timeout
-
-class broadcast_rate(bsn_tlv):
-    type = 90
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = broadcast_rate()
-        _type = reader.read("!H")[0]
-        assert(_type == 90)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("broadcast_rate {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[90] = broadcast_rate
-
-class bucket(bsn_tlv):
-    type = 64
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(loxi.generic_util.pack_list(self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bucket()
-        _type = reader.read("!H")[0]
-        assert(_type == 64)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = loxi.generic_util.unpack_list(reader, ofp.bsn_tlv.bsn_tlv.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bucket {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.pp(self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[64] = bucket
-
-class circuit_id(bsn_tlv):
-    type = 14
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(self.value)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = circuit_id()
-        _type = reader.read("!H")[0]
-        assert(_type == 14)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("circuit_id {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.pp(self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[14] = circuit_id
-
-class convergence_status(bsn_tlv):
-    type = 45
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!B", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = convergence_status()
-        _type = reader.read("!H")[0]
-        assert(_type == 45)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("convergence_status {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[45] = convergence_status
-
-class crc_enabled(bsn_tlv):
-    type = 22
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!B", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = crc_enabled()
-        _type = reader.read("!H")[0]
-        assert(_type == 22)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("crc_enabled {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[22] = crc_enabled
-
-class data(bsn_tlv):
-    type = 55
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(self.value)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = data()
-        _type = reader.read("!H")[0]
-        assert(_type == 55)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("data {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.pp(self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[55] = data
-
-class decap(bsn_tlv):
-    type = 85
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = decap()
-        _type = reader.read("!H")[0]
-        assert(_type == 85)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("decap {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[85] = decap
-
-class eth_dst(bsn_tlv):
-    type = 33
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!6B", *self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = eth_dst()
-        _type = reader.read("!H")[0]
-        assert(_type == 33)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("eth_dst {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[33] = eth_dst
-
-class eth_src(bsn_tlv):
-    type = 32
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!6B", *self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = eth_src()
-        _type = reader.read("!H")[0]
-        assert(_type == 32)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("eth_src {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[32] = eth_src
-
-class external_gateway_ip(bsn_tlv):
-    type = 26
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = external_gateway_ip()
-        _type = reader.read("!H")[0]
-        assert(_type == 26)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("external_gateway_ip {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_ipv4(self.value))
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[26] = external_gateway_ip
-
-class external_gateway_mac(bsn_tlv):
-    type = 29
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!6B", *self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = external_gateway_mac()
-        _type = reader.read("!H")[0]
-        assert(_type == 29)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("external_gateway_mac {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[29] = external_gateway_mac
-
-class external_ip(bsn_tlv):
-    type = 23
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = external_ip()
-        _type = reader.read("!H")[0]
-        assert(_type == 23)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("external_ip {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_ipv4(self.value))
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[23] = external_ip
-
-class external_mac(bsn_tlv):
-    type = 24
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!6B", *self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = external_mac()
-        _type = reader.read("!H")[0]
-        assert(_type == 24)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("external_mac {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[24] = external_mac
-
-class external_netmask(bsn_tlv):
-    type = 25
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = external_netmask()
-        _type = reader.read("!H")[0]
-        assert(_type == 25)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("external_netmask {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_ipv4(self.value))
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[25] = external_netmask
-
-class generation_id(bsn_tlv):
-    type = 80
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!Q", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = generation_id()
-        _type = reader.read("!H")[0]
-        assert(_type == 80)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("generation_id {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[80] = generation_id
-
-class hash_packet_field(bsn_tlv):
-    type = 103
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!Q", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = hash_packet_field()
-        _type = reader.read("!H")[0]
-        assert(_type == 103)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("hash_packet_field {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[103] = hash_packet_field
-
-class hash_packet_type(bsn_tlv):
-    type = 102
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!B", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = hash_packet_type()
-        _type = reader.read("!H")[0]
-        assert(_type == 102)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("hash_packet_type {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[102] = hash_packet_type
-
-class hash_seed(bsn_tlv):
-    type = 100
-
-    def __init__(self, seed1=None, seed2=None):
-        if seed1 != None:
-            self.seed1 = seed1
-        else:
-            self.seed1 = 0
-        if seed2 != None:
-            self.seed2 = seed2
-        else:
-            self.seed2 = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.seed1))
-        packed.append(struct.pack("!L", self.seed2))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = hash_seed()
-        _type = reader.read("!H")[0]
-        assert(_type == 100)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.seed1 = reader.read("!L")[0]
-        obj.seed2 = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.seed1 != other.seed1: return False
-        if self.seed2 != other.seed2: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("hash_seed {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("seed1 = ");
-                q.text("%#x" % self.seed1)
-                q.text(","); q.breakable()
-                q.text("seed2 = ");
-                q.text("%#x" % self.seed2)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[100] = hash_seed
-
-class hash_type(bsn_tlv):
-    type = 101
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!B", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = hash_type()
-        _type = reader.read("!H")[0]
-        assert(_type == 101)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("hash_type {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[101] = hash_type
-
-class header_size(bsn_tlv):
-    type = 31
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = header_size()
-        _type = reader.read("!H")[0]
-        assert(_type == 31)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("header_size {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[31] = header_size
-
-class icmp_code(bsn_tlv):
-    type = 69
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!B", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = icmp_code()
-        _type = reader.read("!H")[0]
-        assert(_type == 69)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("icmp_code {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[69] = icmp_code
-
-class icmp_id(bsn_tlv):
-    type = 70
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = icmp_id()
-        _type = reader.read("!H")[0]
-        assert(_type == 70)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("icmp_id {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[70] = icmp_id
-
-class icmp_type(bsn_tlv):
-    type = 68
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!B", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = icmp_type()
-        _type = reader.read("!H")[0]
-        assert(_type == 68)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("icmp_type {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[68] = icmp_type
-
-class idle_notification(bsn_tlv):
-    type = 7
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = idle_notification()
-        _type = reader.read("!H")[0]
-        assert(_type == 7)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("idle_notification {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[7] = idle_notification
-
-class idle_time(bsn_tlv):
-    type = 5
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!Q", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = idle_time()
-        _type = reader.read("!H")[0]
-        assert(_type == 5)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("idle_time {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[5] = idle_time
-
-class idle_timeout(bsn_tlv):
-    type = 8
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = idle_timeout()
-        _type = reader.read("!H")[0]
-        assert(_type == 8)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("idle_timeout {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[8] = idle_timeout
-
-class igmp_snooping(bsn_tlv):
-    type = 78
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = igmp_snooping()
-        _type = reader.read("!H")[0]
-        assert(_type == 78)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("igmp_snooping {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[78] = igmp_snooping
-
-class internal_gateway_mac(bsn_tlv):
-    type = 28
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!6B", *self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = internal_gateway_mac()
-        _type = reader.read("!H")[0]
-        assert(_type == 28)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("internal_gateway_mac {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[28] = internal_gateway_mac
-
-class internal_mac(bsn_tlv):
-    type = 27
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!6B", *self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = internal_mac()
-        _type = reader.read("!H")[0]
-        assert(_type == 27)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("internal_mac {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[27] = internal_mac
-
-class interval(bsn_tlv):
-    type = 58
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = interval()
-        _type = reader.read("!H")[0]
-        assert(_type == 58)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("interval {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[58] = interval
-
-class ip_proto(bsn_tlv):
-    type = 67
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!B", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ip_proto()
-        _type = reader.read("!H")[0]
-        assert(_type == 67)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ip_proto {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[67] = ip_proto
-
-class ipv4(bsn_tlv):
-    type = 4
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv4()
-        _type = reader.read("!H")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv4 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_ipv4(self.value))
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[4] = ipv4
-
-class ipv4_dst(bsn_tlv):
-    type = 35
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv4_dst()
-        _type = reader.read("!H")[0]
-        assert(_type == 35)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv4_dst {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_ipv4(self.value))
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[35] = ipv4_dst
-
-class ipv4_netmask(bsn_tlv):
-    type = 60
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv4_netmask()
-        _type = reader.read("!H")[0]
-        assert(_type == 60)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv4_netmask {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_ipv4(self.value))
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[60] = ipv4_netmask
-
-class ipv4_src(bsn_tlv):
-    type = 34
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv4_src()
-        _type = reader.read("!H")[0]
-        assert(_type == 34)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv4_src {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_ipv4(self.value))
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[34] = ipv4_src
-
-class ipv6(bsn_tlv):
-    type = 84
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!16s", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv6()
-        _type = reader.read("!H")[0]
-        assert(_type == 84)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read('!16s')[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv6 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.pp(self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[84] = ipv6
-
-class known_multicast_rate(bsn_tlv):
-    type = 91
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = known_multicast_rate()
-        _type = reader.read("!H")[0]
-        assert(_type == 91)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("known_multicast_rate {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[91] = known_multicast_rate
-
-class l2_multicast_lookup(bsn_tlv):
-    type = 79
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = l2_multicast_lookup()
-        _type = reader.read("!H")[0]
-        assert(_type == 79)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("l2_multicast_lookup {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[79] = l2_multicast_lookup
-
-class mac(bsn_tlv):
-    type = 1
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!6B", *self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = mac()
-        _type = reader.read("!H")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("mac {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[1] = mac
-
-class mac_mask(bsn_tlv):
-    type = 56
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!6B", *self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = mac_mask()
-        _type = reader.read("!H")[0]
-        assert(_type == 56)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("mac_mask {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[56] = mac_mask
-
-class mcg_type_vxlan(bsn_tlv):
-    type = 87
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = mcg_type_vxlan()
-        _type = reader.read("!H")[0]
-        assert(_type == 87)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("mcg_type_vxlan {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[87] = mcg_type_vxlan
-
-class miss_packets(bsn_tlv):
-    type = 13
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!Q", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = miss_packets()
-        _type = reader.read("!H")[0]
-        assert(_type == 13)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("miss_packets {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[13] = miss_packets
-
-class mpls_control_word(bsn_tlv):
-    type = 62
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!B", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = mpls_control_word()
-        _type = reader.read("!H")[0]
-        assert(_type == 62)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("mpls_control_word {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[62] = mpls_control_word
-
-class mpls_label(bsn_tlv):
-    type = 61
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = mpls_label()
-        _type = reader.read("!H")[0]
-        assert(_type == 61)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("mpls_label {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[61] = mpls_label
-
-class mpls_sequenced(bsn_tlv):
-    type = 63
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!B", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = mpls_sequenced()
-        _type = reader.read("!H")[0]
-        assert(_type == 63)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("mpls_sequenced {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[63] = mpls_sequenced
-
-class multicast_interface_id(bsn_tlv):
-    type = 95
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = multicast_interface_id()
-        _type = reader.read("!H")[0]
-        assert(_type == 95)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("multicast_interface_id {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[95] = multicast_interface_id
-
-class name(bsn_tlv):
-    type = 52
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(self.value)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = name()
-        _type = reader.read("!H")[0]
-        assert(_type == 52)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("name {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.pp(self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[52] = name
-
-class negate(bsn_tlv):
-    type = 83
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = negate()
-        _type = reader.read("!H")[0]
-        assert(_type == 83)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("negate {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[83] = negate
-
-class nexthop_type_vxlan(bsn_tlv):
-    type = 94
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = nexthop_type_vxlan()
-        _type = reader.read("!H")[0]
-        assert(_type == 94)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("nexthop_type_vxlan {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[94] = nexthop_type_vxlan
-
-class offset(bsn_tlv):
-    type = 82
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = offset()
-        _type = reader.read("!H")[0]
-        assert(_type == 82)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("offset {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[82] = offset
-
-class partner_key(bsn_tlv):
-    type = 51
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = partner_key()
-        _type = reader.read("!H")[0]
-        assert(_type == 51)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("partner_key {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[51] = partner_key
-
-class partner_port_num(bsn_tlv):
-    type = 50
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = partner_port_num()
-        _type = reader.read("!H")[0]
-        assert(_type == 50)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("partner_port_num {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[50] = partner_port_num
-
-class partner_port_priority(bsn_tlv):
-    type = 49
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = partner_port_priority()
-        _type = reader.read("!H")[0]
-        assert(_type == 49)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("partner_port_priority {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[49] = partner_port_priority
-
-class partner_state(bsn_tlv):
-    type = 54
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!B", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = partner_state()
-        _type = reader.read("!H")[0]
-        assert(_type == 54)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("partner_state {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[54] = partner_state
-
-class partner_system_mac(bsn_tlv):
-    type = 48
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!6B", *self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = partner_system_mac()
-        _type = reader.read("!H")[0]
-        assert(_type == 48)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("partner_system_mac {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[48] = partner_system_mac
-
-class partner_system_priority(bsn_tlv):
-    type = 47
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = partner_system_priority()
-        _type = reader.read("!H")[0]
-        assert(_type == 47)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("partner_system_priority {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[47] = partner_system_priority
-
-class port(bsn_tlv):
-    type = 0
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(util.pack_port_no(self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = port()
-        _type = reader.read("!H")[0]
-        assert(_type == 0)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = util.unpack_port_no(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_port(self.value))
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[0] = port
-
-class port_vxlan_mode(bsn_tlv):
-    type = 88
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!B", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = port_vxlan_mode()
-        _type = reader.read("!H")[0]
-        assert(_type == 88)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port_vxlan_mode {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[88] = port_vxlan_mode
-
-class priority(bsn_tlv):
-    type = 57
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = priority()
-        _type = reader.read("!H")[0]
-        assert(_type == 57)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("priority {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[57] = priority
-
-class queue_id(bsn_tlv):
-    type = 20
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = queue_id()
-        _type = reader.read("!H")[0]
-        assert(_type == 20)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_id {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[20] = queue_id
-
-class queue_weight(bsn_tlv):
-    type = 21
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = queue_weight()
-        _type = reader.read("!H")[0]
-        assert(_type == 21)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_weight {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[21] = queue_weight
-
-class rate_unit(bsn_tlv):
-    type = 89
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!B", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = rate_unit()
-        _type = reader.read("!H")[0]
-        assert(_type == 89)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("rate_unit {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[89] = rate_unit
-
-class reference(bsn_tlv):
-    type = 59
-
-    def __init__(self, table_id=None, key=None):
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if key != None:
-            self.key = key
-        else:
-            self.key = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.table_id))
-        packed.append(loxi.generic_util.pack_list(self.key))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = reference()
-        _type = reader.read("!H")[0]
-        assert(_type == 59)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.table_id = reader.read("!H")[0]
-        obj.key = loxi.generic_util.unpack_list(reader, ofp.bsn_tlv.bsn_tlv.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.table_id != other.table_id: return False
-        if self.key != other.key: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("reference {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("key = ");
-                q.pp(self.key)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[59] = reference
-
-class reply_packets(bsn_tlv):
-    type = 12
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!Q", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = reply_packets()
-        _type = reader.read("!H")[0]
-        assert(_type == 12)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("reply_packets {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[12] = reply_packets
-
-class request_packets(bsn_tlv):
-    type = 11
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!Q", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = request_packets()
-        _type = reader.read("!H")[0]
-        assert(_type == 11)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("request_packets {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[11] = request_packets
-
-class rx_bytes(bsn_tlv):
-    type = 71
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!Q", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = rx_bytes()
-        _type = reader.read("!H")[0]
-        assert(_type == 71)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("rx_bytes {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[71] = rx_bytes
-
-class rx_packets(bsn_tlv):
-    type = 2
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!Q", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = rx_packets()
-        _type = reader.read("!H")[0]
-        assert(_type == 2)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("rx_packets {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[2] = rx_packets
-
-class sampling_rate(bsn_tlv):
-    type = 30
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = sampling_rate()
-        _type = reader.read("!H")[0]
-        assert(_type == 30)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("sampling_rate {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[30] = sampling_rate
-
-class set_loopback_mode(bsn_tlv):
-    type = 74
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_loopback_mode()
-        _type = reader.read("!H")[0]
-        assert(_type == 74)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_loopback_mode {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[74] = set_loopback_mode
-
-class status(bsn_tlv):
-    type = 97
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!B", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = status()
-        _type = reader.read("!H")[0]
-        assert(_type == 97)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("status {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[97] = status
-
-class strip_mpls_l2_on_ingress(bsn_tlv):
-    type = 75
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = strip_mpls_l2_on_ingress()
-        _type = reader.read("!H")[0]
-        assert(_type == 75)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("strip_mpls_l2_on_ingress {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[75] = strip_mpls_l2_on_ingress
-
-class strip_mpls_l3_on_ingress(bsn_tlv):
-    type = 76
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = strip_mpls_l3_on_ingress()
-        _type = reader.read("!H")[0]
-        assert(_type == 76)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("strip_mpls_l3_on_ingress {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[76] = strip_mpls_l3_on_ingress
-
-class strip_vlan_on_egress(bsn_tlv):
-    type = 73
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = strip_vlan_on_egress()
-        _type = reader.read("!H")[0]
-        assert(_type == 73)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("strip_vlan_on_egress {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[73] = strip_vlan_on_egress
-
-class sub_agent_id(bsn_tlv):
-    type = 38
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = sub_agent_id()
-        _type = reader.read("!H")[0]
-        assert(_type == 38)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("sub_agent_id {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[38] = sub_agent_id
-
-class tcp_dst(bsn_tlv):
-    type = 66
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = tcp_dst()
-        _type = reader.read("!H")[0]
-        assert(_type == 66)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("tcp_dst {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[66] = tcp_dst
-
-class tcp_src(bsn_tlv):
-    type = 65
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = tcp_src()
-        _type = reader.read("!H")[0]
-        assert(_type == 65)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("tcp_src {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[65] = tcp_src
-
-class tx_bytes(bsn_tlv):
-    type = 39
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!Q", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = tx_bytes()
-        _type = reader.read("!H")[0]
-        assert(_type == 39)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("tx_bytes {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[39] = tx_bytes
-
-class tx_packets(bsn_tlv):
-    type = 3
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!Q", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = tx_packets()
-        _type = reader.read("!H")[0]
-        assert(_type == 3)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("tx_packets {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[3] = tx_packets
-
-class udf_anchor(bsn_tlv):
-    type = 16
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = udf_anchor()
-        _type = reader.read("!H")[0]
-        assert(_type == 16)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("udf_anchor {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[16] = udf_anchor
-
-class udf_id(bsn_tlv):
-    type = 15
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = udf_id()
-        _type = reader.read("!H")[0]
-        assert(_type == 15)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("udf_id {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[15] = udf_id
-
-class udf_length(bsn_tlv):
-    type = 18
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = udf_length()
-        _type = reader.read("!H")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("udf_length {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[18] = udf_length
-
-class udf_offset(bsn_tlv):
-    type = 17
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = udf_offset()
-        _type = reader.read("!H")[0]
-        assert(_type == 17)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("udf_offset {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[17] = udf_offset
-
-class udp_dst(bsn_tlv):
-    type = 37
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = udp_dst()
-        _type = reader.read("!H")[0]
-        assert(_type == 37)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("udp_dst {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[37] = udp_dst
-
-class udp_src(bsn_tlv):
-    type = 36
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = udp_src()
-        _type = reader.read("!H")[0]
-        assert(_type == 36)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("udp_src {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[36] = udp_src
-
-class unicast_query_timeout(bsn_tlv):
-    type = 9
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = unicast_query_timeout()
-        _type = reader.read("!H")[0]
-        assert(_type == 9)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("unicast_query_timeout {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[9] = unicast_query_timeout
-
-class unicast_rate(bsn_tlv):
-    type = 93
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = unicast_rate()
-        _type = reader.read("!H")[0]
-        assert(_type == 93)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("unicast_rate {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[93] = unicast_rate
-
-class unknown_multicast_rate(bsn_tlv):
-    type = 92
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = unknown_multicast_rate()
-        _type = reader.read("!H")[0]
-        assert(_type == 92)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("unknown_multicast_rate {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[92] = unknown_multicast_rate
-
-class use_packet_state(bsn_tlv):
-    type = 96
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!B", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = use_packet_state()
-        _type = reader.read("!H")[0]
-        assert(_type == 96)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("use_packet_state {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[96] = use_packet_state
-
-class vfi(bsn_tlv):
-    type = 99
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = vfi()
-        _type = reader.read("!H")[0]
-        assert(_type == 99)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("vfi {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[99] = vfi
-
-class vlan_pcp(bsn_tlv):
-    type = 72
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!B", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = vlan_pcp()
-        _type = reader.read("!H")[0]
-        assert(_type == 72)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("vlan_pcp {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[72] = vlan_pcp
-
-class vlan_vid(bsn_tlv):
-    type = 6
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = vlan_vid()
-        _type = reader.read("!H")[0]
-        assert(_type == 6)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("vlan_vid {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[6] = vlan_vid
-
-class vlan_vid_mask(bsn_tlv):
-    type = 77
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = vlan_vid_mask()
-        _type = reader.read("!H")[0]
-        assert(_type == 77)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("vlan_vid_mask {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[77] = vlan_vid_mask
-
-class vni(bsn_tlv):
-    type = 86
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = vni()
-        _type = reader.read("!H")[0]
-        assert(_type == 86)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("vni {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[86] = vni
-
-class vrf(bsn_tlv):
-    type = 19
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = vrf()
-        _type = reader.read("!H")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("vrf {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_tlv.subtypes[19] = vrf
-
-
diff --git a/python/ofagent/loxi/of14/bundle_prop.py b/python/ofagent/loxi/of14/bundle_prop.py
deleted file mode 100644
index 6a36f28..0000000
--- a/python/ofagent/loxi/of14/bundle_prop.py
+++ /dev/null
@@ -1,138 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template module.py
-# Do not modify
-
-import struct
-import loxi
-import util
-import loxi.generic_util
-
-import sys
-ofp = sys.modules['loxi.of14']
-
-class bundle_prop(loxi.OFObject):
-    subtypes = {}
-
-
-    def __init__(self, type=None):
-        if type != None:
-            self.type = type
-        else:
-            self.type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 0)
-        subclass = bundle_prop.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = bundle_prop()
-        obj.type = reader.read("!H")[0]
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type != other.type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bundle_prop {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-
-class experimenter(bundle_prop):
-    subtypes = {}
-
-    type = 65535
-
-    def __init__(self, experimenter=None, exp_type=None):
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        if exp_type != None:
-            self.exp_type = exp_type
-        else:
-            self.exp_type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.exp_type))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 4)
-        subclass = experimenter.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = experimenter()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.experimenter = reader.read("!L")[0]
-        obj.exp_type = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.experimenter != other.experimenter: return False
-        if self.exp_type != other.exp_type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("experimenter {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("exp_type = ");
-                q.text("%#x" % self.exp_type)
-            q.breakable()
-        q.text('}')
-
-bundle_prop.subtypes[65535] = experimenter
-
-
diff --git a/python/ofagent/loxi/of14/common.py b/python/ofagent/loxi/of14/common.py
deleted file mode 100644
index 124b26a..0000000
--- a/python/ofagent/loxi/of14/common.py
+++ /dev/null
@@ -1,4456 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template module.py
-# Do not modify
-
-import struct
-import loxi
-import util
-import loxi.generic_util
-
-import sys
-ofp = sys.modules['loxi.of14']
-
-class bsn_controller_connection(loxi.OFObject):
-
-    def __init__(self, state=None, auxiliary_id=None, role=None, uri=None):
-        if state != None:
-            self.state = state
-        else:
-            self.state = 0
-        if auxiliary_id != None:
-            self.auxiliary_id = auxiliary_id
-        else:
-            self.auxiliary_id = 0
-        if role != None:
-            self.role = role
-        else:
-            self.role = 0
-        if uri != None:
-            self.uri = uri
-        else:
-            self.uri = ""
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.state))
-        packed.append(struct.pack("!B", self.auxiliary_id))
-        packed.append('\x00' * 2)
-        packed.append(struct.pack("!L", self.role))
-        packed.append(struct.pack("!256s", self.uri))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_controller_connection()
-        obj.state = reader.read("!B")[0]
-        obj.auxiliary_id = reader.read("!B")[0]
-        reader.skip(2)
-        obj.role = reader.read("!L")[0]
-        obj.uri = reader.read("!256s")[0].rstrip("\x00")
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.state != other.state: return False
-        if self.auxiliary_id != other.auxiliary_id: return False
-        if self.role != other.role: return False
-        if self.uri != other.uri: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_controller_connection {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("state = ");
-                q.text("%#x" % self.state)
-                q.text(","); q.breakable()
-                q.text("auxiliary_id = ");
-                q.text("%#x" % self.auxiliary_id)
-                q.text(","); q.breakable()
-                q.text("role = ");
-                q.text("%#x" % self.role)
-                q.text(","); q.breakable()
-                q.text("uri = ");
-                q.pp(self.uri)
-            q.breakable()
-        q.text('}')
-
-
-class bsn_debug_counter_desc_stats_entry(loxi.OFObject):
-
-    def __init__(self, counter_id=None, name=None, description=None):
-        if counter_id != None:
-            self.counter_id = counter_id
-        else:
-            self.counter_id = 0
-        if name != None:
-            self.name = name
-        else:
-            self.name = ""
-        if description != None:
-            self.description = description
-        else:
-            self.description = ""
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!Q", self.counter_id))
-        packed.append(struct.pack("!64s", self.name))
-        packed.append(struct.pack("!256s", self.description))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_debug_counter_desc_stats_entry()
-        obj.counter_id = reader.read("!Q")[0]
-        obj.name = reader.read("!64s")[0].rstrip("\x00")
-        obj.description = reader.read("!256s")[0].rstrip("\x00")
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.counter_id != other.counter_id: return False
-        if self.name != other.name: return False
-        if self.description != other.description: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_debug_counter_desc_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("counter_id = ");
-                q.text("%#x" % self.counter_id)
-                q.text(","); q.breakable()
-                q.text("name = ");
-                q.pp(self.name)
-                q.text(","); q.breakable()
-                q.text("description = ");
-                q.pp(self.description)
-            q.breakable()
-        q.text('}')
-
-
-class bsn_debug_counter_stats_entry(loxi.OFObject):
-
-    def __init__(self, counter_id=None, value=None):
-        if counter_id != None:
-            self.counter_id = counter_id
-        else:
-            self.counter_id = 0
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!Q", self.counter_id))
-        packed.append(struct.pack("!Q", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_debug_counter_stats_entry()
-        obj.counter_id = reader.read("!Q")[0]
-        obj.value = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.counter_id != other.counter_id: return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_debug_counter_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("counter_id = ");
-                q.text("%#x" % self.counter_id)
-                q.text(","); q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-
-class bsn_flow_checksum_bucket_stats_entry(loxi.OFObject):
-
-    def __init__(self, checksum=None):
-        if checksum != None:
-            self.checksum = checksum
-        else:
-            self.checksum = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!Q", self.checksum))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_flow_checksum_bucket_stats_entry()
-        obj.checksum = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.checksum != other.checksum: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_flow_checksum_bucket_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("checksum = ");
-                q.text("%#x" % self.checksum)
-            q.breakable()
-        q.text('}')
-
-
-class bsn_generic_stats_entry(loxi.OFObject):
-
-    def __init__(self, tlvs=None):
-        if tlvs != None:
-            self.tlvs = tlvs
-        else:
-            self.tlvs = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 0
-        packed.append(loxi.generic_util.pack_list(self.tlvs))
-        length = sum([len(x) for x in packed])
-        packed[0] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_generic_stats_entry()
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 2)
-        obj.tlvs = loxi.generic_util.unpack_list(reader, ofp.bsn_tlv.bsn_tlv.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.tlvs != other.tlvs: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_generic_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("tlvs = ");
-                q.pp(self.tlvs)
-            q.breakable()
-        q.text('}')
-
-
-class bsn_gentable_bucket_stats_entry(loxi.OFObject):
-
-    def __init__(self, checksum=None):
-        if checksum != None:
-            self.checksum = checksum
-        else:
-            self.checksum = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(util.pack_checksum_128(self.checksum))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_gentable_bucket_stats_entry()
-        obj.checksum = util.unpack_checksum_128(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.checksum != other.checksum: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_gentable_bucket_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("checksum = ");
-                q.pp(self.checksum)
-            q.breakable()
-        q.text('}')
-
-
-class bsn_gentable_desc_stats_entry(loxi.OFObject):
-
-    def __init__(self, table_id=None, name=None, buckets_size=None, max_entries=None):
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if name != None:
-            self.name = name
-        else:
-            self.name = ""
-        if buckets_size != None:
-            self.buckets_size = buckets_size
-        else:
-            self.buckets_size = 0
-        if max_entries != None:
-            self.max_entries = max_entries
-        else:
-            self.max_entries = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 0
-        packed.append(struct.pack("!H", self.table_id))
-        packed.append(struct.pack("!32s", self.name))
-        packed.append(struct.pack("!L", self.buckets_size))
-        packed.append(struct.pack("!L", self.max_entries))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[0] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_gentable_desc_stats_entry()
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 2)
-        obj.table_id = reader.read("!H")[0]
-        obj.name = reader.read("!32s")[0].rstrip("\x00")
-        obj.buckets_size = reader.read("!L")[0]
-        obj.max_entries = reader.read("!L")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.table_id != other.table_id: return False
-        if self.name != other.name: return False
-        if self.buckets_size != other.buckets_size: return False
-        if self.max_entries != other.max_entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_gentable_desc_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("name = ");
-                q.pp(self.name)
-                q.text(","); q.breakable()
-                q.text("buckets_size = ");
-                q.text("%#x" % self.buckets_size)
-                q.text(","); q.breakable()
-                q.text("max_entries = ");
-                q.text("%#x" % self.max_entries)
-            q.breakable()
-        q.text('}')
-
-
-class bsn_gentable_entry_desc_stats_entry(loxi.OFObject):
-
-    def __init__(self, checksum=None, key=None, value=None):
-        if checksum != None:
-            self.checksum = checksum
-        else:
-            self.checksum = 0
-        if key != None:
-            self.key = key
-        else:
-            self.key = []
-        if value != None:
-            self.value = value
-        else:
-            self.value = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 0
-        packed.append(struct.pack("!H", 0)) # placeholder for key_length at index 1
-        packed.append(util.pack_checksum_128(self.checksum))
-        packed.append(loxi.generic_util.pack_list(self.key))
-        packed[1] = struct.pack("!H", len(packed[-1]))
-        packed.append(loxi.generic_util.pack_list(self.value))
-        length = sum([len(x) for x in packed])
-        packed[0] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_gentable_entry_desc_stats_entry()
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 2)
-        _key_length = reader.read("!H")[0]
-        obj.checksum = util.unpack_checksum_128(reader)
-        obj.key = loxi.generic_util.unpack_list(reader.slice(_key_length), ofp.bsn_tlv.bsn_tlv.unpack)
-        obj.value = loxi.generic_util.unpack_list(reader, ofp.bsn_tlv.bsn_tlv.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.checksum != other.checksum: return False
-        if self.key != other.key: return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_gentable_entry_desc_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("checksum = ");
-                q.pp(self.checksum)
-                q.text(","); q.breakable()
-                q.text("key = ");
-                q.pp(self.key)
-                q.text(","); q.breakable()
-                q.text("value = ");
-                q.pp(self.value)
-            q.breakable()
-        q.text('}')
-
-
-class bsn_gentable_entry_stats_entry(loxi.OFObject):
-
-    def __init__(self, key=None, stats=None):
-        if key != None:
-            self.key = key
-        else:
-            self.key = []
-        if stats != None:
-            self.stats = stats
-        else:
-            self.stats = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 0
-        packed.append(struct.pack("!H", 0)) # placeholder for key_length at index 1
-        packed.append(loxi.generic_util.pack_list(self.key))
-        packed[1] = struct.pack("!H", len(packed[-1]))
-        packed.append(loxi.generic_util.pack_list(self.stats))
-        length = sum([len(x) for x in packed])
-        packed[0] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_gentable_entry_stats_entry()
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 2)
-        _key_length = reader.read("!H")[0]
-        obj.key = loxi.generic_util.unpack_list(reader.slice(_key_length), ofp.bsn_tlv.bsn_tlv.unpack)
-        obj.stats = loxi.generic_util.unpack_list(reader, ofp.bsn_tlv.bsn_tlv.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.key != other.key: return False
-        if self.stats != other.stats: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_gentable_entry_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("key = ");
-                q.pp(self.key)
-                q.text(","); q.breakable()
-                q.text("stats = ");
-                q.pp(self.stats)
-            q.breakable()
-        q.text('}')
-
-
-class bsn_gentable_stats_entry(loxi.OFObject):
-
-    def __init__(self, table_id=None, entry_count=None, checksum=None):
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if entry_count != None:
-            self.entry_count = entry_count
-        else:
-            self.entry_count = 0
-        if checksum != None:
-            self.checksum = checksum
-        else:
-            self.checksum = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.table_id))
-        packed.append('\x00' * 2)
-        packed.append(struct.pack("!L", self.entry_count))
-        packed.append(util.pack_checksum_128(self.checksum))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_gentable_stats_entry()
-        obj.table_id = reader.read("!H")[0]
-        reader.skip(2)
-        obj.entry_count = reader.read("!L")[0]
-        obj.checksum = util.unpack_checksum_128(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.table_id != other.table_id: return False
-        if self.entry_count != other.entry_count: return False
-        if self.checksum != other.checksum: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_gentable_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("entry_count = ");
-                q.text("%#x" % self.entry_count)
-                q.text(","); q.breakable()
-                q.text("checksum = ");
-                q.pp(self.checksum)
-            q.breakable()
-        q.text('}')
-
-
-class bsn_interface(loxi.OFObject):
-
-    def __init__(self, hw_addr=None, name=None, ipv4_addr=None, ipv4_netmask=None):
-        if hw_addr != None:
-            self.hw_addr = hw_addr
-        else:
-            self.hw_addr = [0,0,0,0,0,0]
-        if name != None:
-            self.name = name
-        else:
-            self.name = ""
-        if ipv4_addr != None:
-            self.ipv4_addr = ipv4_addr
-        else:
-            self.ipv4_addr = 0
-        if ipv4_netmask != None:
-            self.ipv4_netmask = ipv4_netmask
-        else:
-            self.ipv4_netmask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!6B", *self.hw_addr))
-        packed.append('\x00' * 2)
-        packed.append(struct.pack("!16s", self.name))
-        packed.append(struct.pack("!L", self.ipv4_addr))
-        packed.append(struct.pack("!L", self.ipv4_netmask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_interface()
-        obj.hw_addr = list(reader.read('!6B'))
-        reader.skip(2)
-        obj.name = reader.read("!16s")[0].rstrip("\x00")
-        obj.ipv4_addr = reader.read("!L")[0]
-        obj.ipv4_netmask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.hw_addr != other.hw_addr: return False
-        if self.name != other.name: return False
-        if self.ipv4_addr != other.ipv4_addr: return False
-        if self.ipv4_netmask != other.ipv4_netmask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_interface {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("hw_addr = ");
-                q.text(util.pretty_mac(self.hw_addr))
-                q.text(","); q.breakable()
-                q.text("name = ");
-                q.pp(self.name)
-                q.text(","); q.breakable()
-                q.text("ipv4_addr = ");
-                q.text(util.pretty_ipv4(self.ipv4_addr))
-                q.text(","); q.breakable()
-                q.text("ipv4_netmask = ");
-                q.text(util.pretty_ipv4(self.ipv4_netmask))
-            q.breakable()
-        q.text('}')
-
-
-class bsn_lacp_stats_entry(loxi.OFObject):
-
-    def __init__(self, port_no=None, actor_sys_priority=None, actor_sys_mac=None, actor_port_priority=None, actor_port_num=None, actor_key=None, convergence_status=None, partner_sys_priority=None, partner_sys_mac=None, partner_port_priority=None, partner_port_num=None, partner_key=None):
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if actor_sys_priority != None:
-            self.actor_sys_priority = actor_sys_priority
-        else:
-            self.actor_sys_priority = 0
-        if actor_sys_mac != None:
-            self.actor_sys_mac = actor_sys_mac
-        else:
-            self.actor_sys_mac = [0,0,0,0,0,0]
-        if actor_port_priority != None:
-            self.actor_port_priority = actor_port_priority
-        else:
-            self.actor_port_priority = 0
-        if actor_port_num != None:
-            self.actor_port_num = actor_port_num
-        else:
-            self.actor_port_num = 0
-        if actor_key != None:
-            self.actor_key = actor_key
-        else:
-            self.actor_key = 0
-        if convergence_status != None:
-            self.convergence_status = convergence_status
-        else:
-            self.convergence_status = 0
-        if partner_sys_priority != None:
-            self.partner_sys_priority = partner_sys_priority
-        else:
-            self.partner_sys_priority = 0
-        if partner_sys_mac != None:
-            self.partner_sys_mac = partner_sys_mac
-        else:
-            self.partner_sys_mac = [0,0,0,0,0,0]
-        if partner_port_priority != None:
-            self.partner_port_priority = partner_port_priority
-        else:
-            self.partner_port_priority = 0
-        if partner_port_num != None:
-            self.partner_port_num = partner_port_num
-        else:
-            self.partner_port_num = 0
-        if partner_key != None:
-            self.partner_key = partner_key
-        else:
-            self.partner_key = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(struct.pack("!H", self.actor_sys_priority))
-        packed.append(struct.pack("!6B", *self.actor_sys_mac))
-        packed.append(struct.pack("!H", self.actor_port_priority))
-        packed.append(struct.pack("!H", self.actor_port_num))
-        packed.append(struct.pack("!H", self.actor_key))
-        packed.append(struct.pack("!B", self.convergence_status))
-        packed.append('\x00' * 1)
-        packed.append(struct.pack("!H", self.partner_sys_priority))
-        packed.append(struct.pack("!6B", *self.partner_sys_mac))
-        packed.append(struct.pack("!H", self.partner_port_priority))
-        packed.append(struct.pack("!H", self.partner_port_num))
-        packed.append(struct.pack("!H", self.partner_key))
-        packed.append('\x00' * 2)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_lacp_stats_entry()
-        obj.port_no = util.unpack_port_no(reader)
-        obj.actor_sys_priority = reader.read("!H")[0]
-        obj.actor_sys_mac = list(reader.read('!6B'))
-        obj.actor_port_priority = reader.read("!H")[0]
-        obj.actor_port_num = reader.read("!H")[0]
-        obj.actor_key = reader.read("!H")[0]
-        obj.convergence_status = reader.read("!B")[0]
-        reader.skip(1)
-        obj.partner_sys_priority = reader.read("!H")[0]
-        obj.partner_sys_mac = list(reader.read('!6B'))
-        obj.partner_port_priority = reader.read("!H")[0]
-        obj.partner_port_num = reader.read("!H")[0]
-        obj.partner_key = reader.read("!H")[0]
-        reader.skip(2)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.port_no != other.port_no: return False
-        if self.actor_sys_priority != other.actor_sys_priority: return False
-        if self.actor_sys_mac != other.actor_sys_mac: return False
-        if self.actor_port_priority != other.actor_port_priority: return False
-        if self.actor_port_num != other.actor_port_num: return False
-        if self.actor_key != other.actor_key: return False
-        if self.convergence_status != other.convergence_status: return False
-        if self.partner_sys_priority != other.partner_sys_priority: return False
-        if self.partner_sys_mac != other.partner_sys_mac: return False
-        if self.partner_port_priority != other.partner_port_priority: return False
-        if self.partner_port_num != other.partner_port_num: return False
-        if self.partner_key != other.partner_key: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_lacp_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("actor_sys_priority = ");
-                q.text("%#x" % self.actor_sys_priority)
-                q.text(","); q.breakable()
-                q.text("actor_sys_mac = ");
-                q.text(util.pretty_mac(self.actor_sys_mac))
-                q.text(","); q.breakable()
-                q.text("actor_port_priority = ");
-                q.text("%#x" % self.actor_port_priority)
-                q.text(","); q.breakable()
-                q.text("actor_port_num = ");
-                q.text("%#x" % self.actor_port_num)
-                q.text(","); q.breakable()
-                q.text("actor_key = ");
-                q.text("%#x" % self.actor_key)
-                q.text(","); q.breakable()
-                q.text("convergence_status = ");
-                q.text("%#x" % self.convergence_status)
-                q.text(","); q.breakable()
-                q.text("partner_sys_priority = ");
-                q.text("%#x" % self.partner_sys_priority)
-                q.text(","); q.breakable()
-                q.text("partner_sys_mac = ");
-                q.text(util.pretty_mac(self.partner_sys_mac))
-                q.text(","); q.breakable()
-                q.text("partner_port_priority = ");
-                q.text("%#x" % self.partner_port_priority)
-                q.text(","); q.breakable()
-                q.text("partner_port_num = ");
-                q.text("%#x" % self.partner_port_num)
-                q.text(","); q.breakable()
-                q.text("partner_key = ");
-                q.text("%#x" % self.partner_key)
-            q.breakable()
-        q.text('}')
-
-
-class bsn_port_counter_stats_entry(loxi.OFObject):
-
-    def __init__(self, port_no=None, values=None):
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if values != None:
-            self.values = values
-        else:
-            self.values = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 0
-        packed.append('\x00' * 2)
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(loxi.generic_util.pack_list(self.values))
-        length = sum([len(x) for x in packed])
-        packed[0] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_port_counter_stats_entry()
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 2)
-        reader.skip(2)
-        obj.port_no = util.unpack_port_no(reader)
-        obj.values = loxi.generic_util.unpack_list(reader, ofp.common.uint64.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.port_no != other.port_no: return False
-        if self.values != other.values: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_port_counter_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("values = ");
-                q.pp(self.values)
-            q.breakable()
-        q.text('}')
-
-
-class bsn_switch_pipeline_stats_entry(loxi.OFObject):
-
-    def __init__(self, pipeline=None):
-        if pipeline != None:
-            self.pipeline = pipeline
-        else:
-            self.pipeline = ""
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!256s", self.pipeline))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_switch_pipeline_stats_entry()
-        obj.pipeline = reader.read("!256s")[0].rstrip("\x00")
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.pipeline != other.pipeline: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_switch_pipeline_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("pipeline = ");
-                q.pp(self.pipeline)
-            q.breakable()
-        q.text('}')
-
-
-class bsn_table_checksum_stats_entry(loxi.OFObject):
-
-    def __init__(self, table_id=None, checksum=None):
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if checksum != None:
-            self.checksum = checksum
-        else:
-            self.checksum = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append(struct.pack("!Q", self.checksum))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_table_checksum_stats_entry()
-        obj.table_id = reader.read("!B")[0]
-        obj.checksum = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.table_id != other.table_id: return False
-        if self.checksum != other.checksum: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_table_checksum_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("checksum = ");
-                q.text("%#x" % self.checksum)
-            q.breakable()
-        q.text('}')
-
-
-class bsn_tlv_vlan_mac_list(loxi.OFObject):
-    type = 98
-
-    def __init__(self, key=None):
-        if key != None:
-            self.key = key
-        else:
-            self.key = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(loxi.generic_util.pack_list(self.key))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_tlv_vlan_mac_list()
-        _type = reader.read("!H")[0]
-        assert(_type == 98)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.key = loxi.generic_util.unpack_list(reader, ofp.common.bsn_vlan_mac.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.key != other.key: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_tlv_vlan_mac_list {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("key = ");
-                q.pp(self.key)
-            q.breakable()
-        q.text('}')
-
-
-class bsn_vport(loxi.OFObject):
-    subtypes = {}
-
-
-    def __init__(self, type=None):
-        if type != None:
-            self.type = type
-        else:
-            self.type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 0)
-        subclass = bsn_vport.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = bsn_vport()
-        obj.type = reader.read("!H")[0]
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type != other.type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vport {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-
-class bsn_vlan_counter_stats_entry(loxi.OFObject):
-
-    def __init__(self, vlan_vid=None, values=None):
-        if vlan_vid != None:
-            self.vlan_vid = vlan_vid
-        else:
-            self.vlan_vid = 0
-        if values != None:
-            self.values = values
-        else:
-            self.values = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 0
-        packed.append(struct.pack("!H", self.vlan_vid))
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.values))
-        length = sum([len(x) for x in packed])
-        packed[0] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_vlan_counter_stats_entry()
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 2)
-        obj.vlan_vid = reader.read("!H")[0]
-        reader.skip(4)
-        obj.values = loxi.generic_util.unpack_list(reader, ofp.common.uint64.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.vlan_vid != other.vlan_vid: return False
-        if self.values != other.values: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vlan_counter_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("vlan_vid = ");
-                q.text("%#x" % self.vlan_vid)
-                q.text(","); q.breakable()
-                q.text("values = ");
-                q.pp(self.values)
-            q.breakable()
-        q.text('}')
-
-
-class bsn_vlan_mac(loxi.OFObject):
-
-    def __init__(self, vlan_vid=None, mac=None):
-        if vlan_vid != None:
-            self.vlan_vid = vlan_vid
-        else:
-            self.vlan_vid = 0
-        if mac != None:
-            self.mac = mac
-        else:
-            self.mac = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.vlan_vid))
-        packed.append(struct.pack("!6B", *self.mac))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_vlan_mac()
-        obj.vlan_vid = reader.read("!H")[0]
-        obj.mac = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.vlan_vid != other.vlan_vid: return False
-        if self.mac != other.mac: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vlan_mac {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("vlan_vid = ");
-                q.text("%#x" % self.vlan_vid)
-                q.text(","); q.breakable()
-                q.text("mac = ");
-                q.text(util.pretty_mac(self.mac))
-            q.breakable()
-        q.text('}')
-
-
-class bsn_vport_l2gre(bsn_vport):
-    type = 1
-
-    def __init__(self, flags=None, port_no=None, loopback_port_no=None, local_mac=None, nh_mac=None, src_ip=None, dst_ip=None, dscp=None, ttl=None, vpn=None, rate_limit=None, if_name=None):
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if loopback_port_no != None:
-            self.loopback_port_no = loopback_port_no
-        else:
-            self.loopback_port_no = 0
-        if local_mac != None:
-            self.local_mac = local_mac
-        else:
-            self.local_mac = [0,0,0,0,0,0]
-        if nh_mac != None:
-            self.nh_mac = nh_mac
-        else:
-            self.nh_mac = [0,0,0,0,0,0]
-        if src_ip != None:
-            self.src_ip = src_ip
-        else:
-            self.src_ip = 0
-        if dst_ip != None:
-            self.dst_ip = dst_ip
-        else:
-            self.dst_ip = 0
-        if dscp != None:
-            self.dscp = dscp
-        else:
-            self.dscp = 0
-        if ttl != None:
-            self.ttl = ttl
-        else:
-            self.ttl = 0
-        if vpn != None:
-            self.vpn = vpn
-        else:
-            self.vpn = 0
-        if rate_limit != None:
-            self.rate_limit = rate_limit
-        else:
-            self.rate_limit = 0
-        if if_name != None:
-            self.if_name = if_name
-        else:
-            self.if_name = ""
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.flags))
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(util.pack_port_no(self.loopback_port_no))
-        packed.append(struct.pack("!6B", *self.local_mac))
-        packed.append(struct.pack("!6B", *self.nh_mac))
-        packed.append(struct.pack("!L", self.src_ip))
-        packed.append(struct.pack("!L", self.dst_ip))
-        packed.append(struct.pack("!B", self.dscp))
-        packed.append(struct.pack("!B", self.ttl))
-        packed.append('\x00' * 2)
-        packed.append(struct.pack("!L", self.vpn))
-        packed.append(struct.pack("!L", self.rate_limit))
-        packed.append(struct.pack("!16s", self.if_name))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_vport_l2gre()
-        _type = reader.read("!H")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.flags = reader.read("!L")[0]
-        obj.port_no = util.unpack_port_no(reader)
-        obj.loopback_port_no = util.unpack_port_no(reader)
-        obj.local_mac = list(reader.read('!6B'))
-        obj.nh_mac = list(reader.read('!6B'))
-        obj.src_ip = reader.read("!L")[0]
-        obj.dst_ip = reader.read("!L")[0]
-        obj.dscp = reader.read("!B")[0]
-        obj.ttl = reader.read("!B")[0]
-        reader.skip(2)
-        obj.vpn = reader.read("!L")[0]
-        obj.rate_limit = reader.read("!L")[0]
-        obj.if_name = reader.read("!16s")[0].rstrip("\x00")
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.flags != other.flags: return False
-        if self.port_no != other.port_no: return False
-        if self.loopback_port_no != other.loopback_port_no: return False
-        if self.local_mac != other.local_mac: return False
-        if self.nh_mac != other.nh_mac: return False
-        if self.src_ip != other.src_ip: return False
-        if self.dst_ip != other.dst_ip: return False
-        if self.dscp != other.dscp: return False
-        if self.ttl != other.ttl: return False
-        if self.vpn != other.vpn: return False
-        if self.rate_limit != other.rate_limit: return False
-        if self.if_name != other.if_name: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vport_l2gre {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("loopback_port_no = ");
-                q.text(util.pretty_port(self.loopback_port_no))
-                q.text(","); q.breakable()
-                q.text("local_mac = ");
-                q.text(util.pretty_mac(self.local_mac))
-                q.text(","); q.breakable()
-                q.text("nh_mac = ");
-                q.text(util.pretty_mac(self.nh_mac))
-                q.text(","); q.breakable()
-                q.text("src_ip = ");
-                q.text(util.pretty_ipv4(self.src_ip))
-                q.text(","); q.breakable()
-                q.text("dst_ip = ");
-                q.text(util.pretty_ipv4(self.dst_ip))
-                q.text(","); q.breakable()
-                q.text("dscp = ");
-                q.text("%#x" % self.dscp)
-                q.text(","); q.breakable()
-                q.text("ttl = ");
-                q.text("%#x" % self.ttl)
-                q.text(","); q.breakable()
-                q.text("vpn = ");
-                q.text("%#x" % self.vpn)
-                q.text(","); q.breakable()
-                q.text("rate_limit = ");
-                q.text("%#x" % self.rate_limit)
-                q.text(","); q.breakable()
-                q.text("if_name = ");
-                q.pp(self.if_name)
-            q.breakable()
-        q.text('}')
-
-bsn_vport.subtypes[1] = bsn_vport_l2gre
-
-class bsn_vport_q_in_q(bsn_vport):
-    type = 0
-
-    def __init__(self, port_no=None, ingress_tpid=None, ingress_vlan_id=None, egress_tpid=None, egress_vlan_id=None, if_name=None):
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if ingress_tpid != None:
-            self.ingress_tpid = ingress_tpid
-        else:
-            self.ingress_tpid = 0
-        if ingress_vlan_id != None:
-            self.ingress_vlan_id = ingress_vlan_id
-        else:
-            self.ingress_vlan_id = 0
-        if egress_tpid != None:
-            self.egress_tpid = egress_tpid
-        else:
-            self.egress_tpid = 0
-        if egress_vlan_id != None:
-            self.egress_vlan_id = egress_vlan_id
-        else:
-            self.egress_vlan_id = 0
-        if if_name != None:
-            self.if_name = if_name
-        else:
-            self.if_name = ""
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.port_no))
-        packed.append(struct.pack("!H", self.ingress_tpid))
-        packed.append(struct.pack("!H", self.ingress_vlan_id))
-        packed.append(struct.pack("!H", self.egress_tpid))
-        packed.append(struct.pack("!H", self.egress_vlan_id))
-        packed.append(struct.pack("!16s", self.if_name))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_vport_q_in_q()
-        _type = reader.read("!H")[0]
-        assert(_type == 0)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.port_no = reader.read("!L")[0]
-        obj.ingress_tpid = reader.read("!H")[0]
-        obj.ingress_vlan_id = reader.read("!H")[0]
-        obj.egress_tpid = reader.read("!H")[0]
-        obj.egress_vlan_id = reader.read("!H")[0]
-        obj.if_name = reader.read("!16s")[0].rstrip("\x00")
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.port_no != other.port_no: return False
-        if self.ingress_tpid != other.ingress_tpid: return False
-        if self.ingress_vlan_id != other.ingress_vlan_id: return False
-        if self.egress_tpid != other.egress_tpid: return False
-        if self.egress_vlan_id != other.egress_vlan_id: return False
-        if self.if_name != other.if_name: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vport_q_in_q {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("port_no = ");
-                q.text("%#x" % self.port_no)
-                q.text(","); q.breakable()
-                q.text("ingress_tpid = ");
-                q.text("%#x" % self.ingress_tpid)
-                q.text(","); q.breakable()
-                q.text("ingress_vlan_id = ");
-                q.text("%#x" % self.ingress_vlan_id)
-                q.text(","); q.breakable()
-                q.text("egress_tpid = ");
-                q.text("%#x" % self.egress_tpid)
-                q.text(","); q.breakable()
-                q.text("egress_vlan_id = ");
-                q.text("%#x" % self.egress_vlan_id)
-                q.text(","); q.breakable()
-                q.text("if_name = ");
-                q.pp(self.if_name)
-            q.breakable()
-        q.text('}')
-
-bsn_vport.subtypes[0] = bsn_vport_q_in_q
-
-class bsn_vrf_counter_stats_entry(loxi.OFObject):
-
-    def __init__(self, vrf=None, values=None):
-        if vrf != None:
-            self.vrf = vrf
-        else:
-            self.vrf = 0
-        if values != None:
-            self.values = values
-        else:
-            self.values = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 0
-        packed.append('\x00' * 2)
-        packed.append(struct.pack("!L", self.vrf))
-        packed.append(loxi.generic_util.pack_list(self.values))
-        length = sum([len(x) for x in packed])
-        packed[0] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_vrf_counter_stats_entry()
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 2)
-        reader.skip(2)
-        obj.vrf = reader.read("!L")[0]
-        obj.values = loxi.generic_util.unpack_list(reader, ofp.common.uint64.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.vrf != other.vrf: return False
-        if self.values != other.values: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vrf_counter_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("vrf = ");
-                q.text("%#x" % self.vrf)
-                q.text(","); q.breakable()
-                q.text("values = ");
-                q.pp(self.values)
-            q.breakable()
-        q.text('}')
-
-
-class bucket(loxi.OFObject):
-
-    def __init__(self, weight=None, watch_port=None, watch_group=None, actions=None):
-        if weight != None:
-            self.weight = weight
-        else:
-            self.weight = 0
-        if watch_port != None:
-            self.watch_port = watch_port
-        else:
-            self.watch_port = 0
-        if watch_group != None:
-            self.watch_group = watch_group
-        else:
-            self.watch_group = 0
-        if actions != None:
-            self.actions = actions
-        else:
-            self.actions = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 0
-        packed.append(struct.pack("!H", self.weight))
-        packed.append(util.pack_port_no(self.watch_port))
-        packed.append(struct.pack("!L", self.watch_group))
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.actions))
-        length = sum([len(x) for x in packed])
-        packed[0] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bucket()
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 2)
-        obj.weight = reader.read("!H")[0]
-        obj.watch_port = util.unpack_port_no(reader)
-        obj.watch_group = reader.read("!L")[0]
-        reader.skip(4)
-        obj.actions = loxi.generic_util.unpack_list(reader, ofp.action.action.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.weight != other.weight: return False
-        if self.watch_port != other.watch_port: return False
-        if self.watch_group != other.watch_group: return False
-        if self.actions != other.actions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bucket {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("weight = ");
-                q.text("%#x" % self.weight)
-                q.text(","); q.breakable()
-                q.text("watch_port = ");
-                q.text(util.pretty_port(self.watch_port))
-                q.text(","); q.breakable()
-                q.text("watch_group = ");
-                q.text("%#x" % self.watch_group)
-                q.text(","); q.breakable()
-                q.text("actions = ");
-                q.pp(self.actions)
-            q.breakable()
-        q.text('}')
-
-
-class bucket_counter(loxi.OFObject):
-
-    def __init__(self, packet_count=None, byte_count=None):
-        if packet_count != None:
-            self.packet_count = packet_count
-        else:
-            self.packet_count = 0
-        if byte_count != None:
-            self.byte_count = byte_count
-        else:
-            self.byte_count = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!Q", self.packet_count))
-        packed.append(struct.pack("!Q", self.byte_count))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bucket_counter()
-        obj.packet_count = reader.read("!Q")[0]
-        obj.byte_count = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.packet_count != other.packet_count: return False
-        if self.byte_count != other.byte_count: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bucket_counter {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("packet_count = ");
-                q.text("%#x" % self.packet_count)
-                q.text(","); q.breakable()
-                q.text("byte_count = ");
-                q.text("%#x" % self.byte_count)
-            q.breakable()
-        q.text('}')
-
-
-class flow_stats_entry(loxi.OFObject):
-
-    def __init__(self, table_id=None, duration_sec=None, duration_nsec=None, priority=None, idle_timeout=None, hard_timeout=None, flags=None, importance=None, cookie=None, packet_count=None, byte_count=None, match=None, instructions=None):
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if duration_sec != None:
-            self.duration_sec = duration_sec
-        else:
-            self.duration_sec = 0
-        if duration_nsec != None:
-            self.duration_nsec = duration_nsec
-        else:
-            self.duration_nsec = 0
-        if priority != None:
-            self.priority = priority
-        else:
-            self.priority = 0
-        if idle_timeout != None:
-            self.idle_timeout = idle_timeout
-        else:
-            self.idle_timeout = 0
-        if hard_timeout != None:
-            self.hard_timeout = hard_timeout
-        else:
-            self.hard_timeout = 0
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if importance != None:
-            self.importance = importance
-        else:
-            self.importance = 0
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if packet_count != None:
-            self.packet_count = packet_count
-        else:
-            self.packet_count = 0
-        if byte_count != None:
-            self.byte_count = byte_count
-        else:
-            self.byte_count = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        if instructions != None:
-            self.instructions = instructions
-        else:
-            self.instructions = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 0
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append('\x00' * 1)
-        packed.append(struct.pack("!L", self.duration_sec))
-        packed.append(struct.pack("!L", self.duration_nsec))
-        packed.append(struct.pack("!H", self.priority))
-        packed.append(struct.pack("!H", self.idle_timeout))
-        packed.append(struct.pack("!H", self.hard_timeout))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append(struct.pack("!H", self.importance))
-        packed.append('\x00' * 2)
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(struct.pack("!Q", self.packet_count))
-        packed.append(struct.pack("!Q", self.byte_count))
-        packed.append(self.match.pack())
-        packed.append(loxi.generic_util.pack_list(self.instructions))
-        length = sum([len(x) for x in packed])
-        packed[0] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_stats_entry()
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 2)
-        obj.table_id = reader.read("!B")[0]
-        reader.skip(1)
-        obj.duration_sec = reader.read("!L")[0]
-        obj.duration_nsec = reader.read("!L")[0]
-        obj.priority = reader.read("!H")[0]
-        obj.idle_timeout = reader.read("!H")[0]
-        obj.hard_timeout = reader.read("!H")[0]
-        obj.flags = reader.read("!H")[0]
-        obj.importance = reader.read("!H")[0]
-        reader.skip(2)
-        obj.cookie = reader.read("!Q")[0]
-        obj.packet_count = reader.read("!Q")[0]
-        obj.byte_count = reader.read("!Q")[0]
-        obj.match = ofp.match.unpack(reader)
-        obj.instructions = loxi.generic_util.unpack_list(reader, ofp.instruction.instruction.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.table_id != other.table_id: return False
-        if self.duration_sec != other.duration_sec: return False
-        if self.duration_nsec != other.duration_nsec: return False
-        if self.priority != other.priority: return False
-        if self.idle_timeout != other.idle_timeout: return False
-        if self.hard_timeout != other.hard_timeout: return False
-        if self.flags != other.flags: return False
-        if self.importance != other.importance: return False
-        if self.cookie != other.cookie: return False
-        if self.packet_count != other.packet_count: return False
-        if self.byte_count != other.byte_count: return False
-        if self.match != other.match: return False
-        if self.instructions != other.instructions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("duration_sec = ");
-                q.text("%#x" % self.duration_sec)
-                q.text(","); q.breakable()
-                q.text("duration_nsec = ");
-                q.text("%#x" % self.duration_nsec)
-                q.text(","); q.breakable()
-                q.text("priority = ");
-                q.text("%#x" % self.priority)
-                q.text(","); q.breakable()
-                q.text("idle_timeout = ");
-                q.text("%#x" % self.idle_timeout)
-                q.text(","); q.breakable()
-                q.text("hard_timeout = ");
-                q.text("%#x" % self.hard_timeout)
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("importance = ");
-                q.text("%#x" % self.importance)
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("packet_count = ");
-                q.text("%#x" % self.packet_count)
-                q.text(","); q.breakable()
-                q.text("byte_count = ");
-                q.text("%#x" % self.byte_count)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-                q.text(","); q.breakable()
-                q.text("instructions = ");
-                q.pp(self.instructions)
-            q.breakable()
-        q.text('}')
-
-
-class group_desc_stats_entry(loxi.OFObject):
-
-    def __init__(self, group_type=None, group_id=None, buckets=None):
-        if group_type != None:
-            self.group_type = group_type
-        else:
-            self.group_type = 0
-        if group_id != None:
-            self.group_id = group_id
-        else:
-            self.group_id = 0
-        if buckets != None:
-            self.buckets = buckets
-        else:
-            self.buckets = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 0
-        packed.append(struct.pack("!B", self.group_type))
-        packed.append('\x00' * 1)
-        packed.append(struct.pack("!L", self.group_id))
-        packed.append(loxi.generic_util.pack_list(self.buckets))
-        length = sum([len(x) for x in packed])
-        packed[0] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group_desc_stats_entry()
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 2)
-        obj.group_type = reader.read("!B")[0]
-        reader.skip(1)
-        obj.group_id = reader.read("!L")[0]
-        obj.buckets = loxi.generic_util.unpack_list(reader, ofp.common.bucket.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.group_type != other.group_type: return False
-        if self.group_id != other.group_id: return False
-        if self.buckets != other.buckets: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_desc_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("group_type = ");
-                q.text("%#x" % self.group_type)
-                q.text(","); q.breakable()
-                q.text("group_id = ");
-                q.text("%#x" % self.group_id)
-                q.text(","); q.breakable()
-                q.text("buckets = ");
-                q.pp(self.buckets)
-            q.breakable()
-        q.text('}')
-
-
-class group_stats_entry(loxi.OFObject):
-
-    def __init__(self, group_id=None, ref_count=None, packet_count=None, byte_count=None, duration_sec=None, duration_nsec=None, bucket_stats=None):
-        if group_id != None:
-            self.group_id = group_id
-        else:
-            self.group_id = 0
-        if ref_count != None:
-            self.ref_count = ref_count
-        else:
-            self.ref_count = 0
-        if packet_count != None:
-            self.packet_count = packet_count
-        else:
-            self.packet_count = 0
-        if byte_count != None:
-            self.byte_count = byte_count
-        else:
-            self.byte_count = 0
-        if duration_sec != None:
-            self.duration_sec = duration_sec
-        else:
-            self.duration_sec = 0
-        if duration_nsec != None:
-            self.duration_nsec = duration_nsec
-        else:
-            self.duration_nsec = 0
-        if bucket_stats != None:
-            self.bucket_stats = bucket_stats
-        else:
-            self.bucket_stats = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 0
-        packed.append('\x00' * 2)
-        packed.append(struct.pack("!L", self.group_id))
-        packed.append(struct.pack("!L", self.ref_count))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!Q", self.packet_count))
-        packed.append(struct.pack("!Q", self.byte_count))
-        packed.append(struct.pack("!L", self.duration_sec))
-        packed.append(struct.pack("!L", self.duration_nsec))
-        packed.append(loxi.generic_util.pack_list(self.bucket_stats))
-        length = sum([len(x) for x in packed])
-        packed[0] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group_stats_entry()
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 2)
-        reader.skip(2)
-        obj.group_id = reader.read("!L")[0]
-        obj.ref_count = reader.read("!L")[0]
-        reader.skip(4)
-        obj.packet_count = reader.read("!Q")[0]
-        obj.byte_count = reader.read("!Q")[0]
-        obj.duration_sec = reader.read("!L")[0]
-        obj.duration_nsec = reader.read("!L")[0]
-        obj.bucket_stats = loxi.generic_util.unpack_list(reader, ofp.common.bucket_counter.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.group_id != other.group_id: return False
-        if self.ref_count != other.ref_count: return False
-        if self.packet_count != other.packet_count: return False
-        if self.byte_count != other.byte_count: return False
-        if self.duration_sec != other.duration_sec: return False
-        if self.duration_nsec != other.duration_nsec: return False
-        if self.bucket_stats != other.bucket_stats: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("group_id = ");
-                q.text("%#x" % self.group_id)
-                q.text(","); q.breakable()
-                q.text("ref_count = ");
-                q.text("%#x" % self.ref_count)
-                q.text(","); q.breakable()
-                q.text("packet_count = ");
-                q.text("%#x" % self.packet_count)
-                q.text(","); q.breakable()
-                q.text("byte_count = ");
-                q.text("%#x" % self.byte_count)
-                q.text(","); q.breakable()
-                q.text("duration_sec = ");
-                q.text("%#x" % self.duration_sec)
-                q.text(","); q.breakable()
-                q.text("duration_nsec = ");
-                q.text("%#x" % self.duration_nsec)
-                q.text(","); q.breakable()
-                q.text("bucket_stats = ");
-                q.pp(self.bucket_stats)
-            q.breakable()
-        q.text('}')
-
-
-class hello_elem(loxi.OFObject):
-    subtypes = {}
-
-
-    def __init__(self, type=None):
-        if type != None:
-            self.type = type
-        else:
-            self.type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 0)
-        subclass = hello_elem.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = hello_elem()
-        obj.type = reader.read("!H")[0]
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type != other.type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("hello_elem {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-
-class hello_elem_versionbitmap(hello_elem):
-    type = 1
-
-    def __init__(self, bitmaps=None):
-        if bitmaps != None:
-            self.bitmaps = bitmaps
-        else:
-            self.bitmaps = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(loxi.generic_util.pack_list(self.bitmaps))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = hello_elem_versionbitmap()
-        _type = reader.read("!H")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.bitmaps = loxi.generic_util.unpack_list(reader, ofp.common.uint32.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.bitmaps != other.bitmaps: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("hello_elem_versionbitmap {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("bitmaps = ");
-                q.pp(self.bitmaps)
-            q.breakable()
-        q.text('}')
-
-hello_elem.subtypes[1] = hello_elem_versionbitmap
-
-class match_v3(loxi.OFObject):
-    type = 1
-
-    def __init__(self, oxm_list=None):
-        if oxm_list != None:
-            self.oxm_list = oxm_list
-        else:
-            self.oxm_list = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(loxi.generic_util.pack_list(self.oxm_list))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        packed.append(loxi.generic_util.pad_to(8, length))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = match_v3()
-        _type = reader.read("!H")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.oxm_list = loxi.generic_util.unpack_list(reader, ofp.oxm.oxm.unpack)
-        orig_reader.skip_align()
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.oxm_list != other.oxm_list: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("match_v3 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("oxm_list = ");
-                q.pp(self.oxm_list)
-            q.breakable()
-        q.text('}')
-
-
-class meter_band_stats(loxi.OFObject):
-
-    def __init__(self, packet_band_count=None, byte_band_count=None):
-        if packet_band_count != None:
-            self.packet_band_count = packet_band_count
-        else:
-            self.packet_band_count = 0
-        if byte_band_count != None:
-            self.byte_band_count = byte_band_count
-        else:
-            self.byte_band_count = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!Q", self.packet_band_count))
-        packed.append(struct.pack("!Q", self.byte_band_count))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = meter_band_stats()
-        obj.packet_band_count = reader.read("!Q")[0]
-        obj.byte_band_count = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.packet_band_count != other.packet_band_count: return False
-        if self.byte_band_count != other.byte_band_count: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("meter_band_stats {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("packet_band_count = ");
-                q.text("%#x" % self.packet_band_count)
-                q.text(","); q.breakable()
-                q.text("byte_band_count = ");
-                q.text("%#x" % self.byte_band_count)
-            q.breakable()
-        q.text('}')
-
-
-class meter_config(loxi.OFObject):
-
-    def __init__(self, flags=None, meter_id=None, entries=None):
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if meter_id != None:
-            self.meter_id = meter_id
-        else:
-            self.meter_id = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 0
-        packed.append(struct.pack("!H", self.flags))
-        packed.append(struct.pack("!L", self.meter_id))
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[0] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = meter_config()
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 2)
-        obj.flags = reader.read("!H")[0]
-        obj.meter_id = reader.read("!L")[0]
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.meter_band.meter_band.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.flags != other.flags: return False
-        if self.meter_id != other.meter_id: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("meter_config {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("meter_id = ");
-                q.text("%#x" % self.meter_id)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-
-class meter_features(loxi.OFObject):
-
-    def __init__(self, max_meter=None, band_types=None, capabilities=None, max_bands=None, max_color=None):
-        if max_meter != None:
-            self.max_meter = max_meter
-        else:
-            self.max_meter = 0
-        if band_types != None:
-            self.band_types = band_types
-        else:
-            self.band_types = 0
-        if capabilities != None:
-            self.capabilities = capabilities
-        else:
-            self.capabilities = 0
-        if max_bands != None:
-            self.max_bands = max_bands
-        else:
-            self.max_bands = 0
-        if max_color != None:
-            self.max_color = max_color
-        else:
-            self.max_color = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.max_meter))
-        packed.append(struct.pack("!L", self.band_types))
-        packed.append(struct.pack("!L", self.capabilities))
-        packed.append(struct.pack("!B", self.max_bands))
-        packed.append(struct.pack("!B", self.max_color))
-        packed.append('\x00' * 2)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = meter_features()
-        obj.max_meter = reader.read("!L")[0]
-        obj.band_types = reader.read("!L")[0]
-        obj.capabilities = reader.read("!L")[0]
-        obj.max_bands = reader.read("!B")[0]
-        obj.max_color = reader.read("!B")[0]
-        reader.skip(2)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.max_meter != other.max_meter: return False
-        if self.band_types != other.band_types: return False
-        if self.capabilities != other.capabilities: return False
-        if self.max_bands != other.max_bands: return False
-        if self.max_color != other.max_color: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("meter_features {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("max_meter = ");
-                q.text("%#x" % self.max_meter)
-                q.text(","); q.breakable()
-                q.text("band_types = ");
-                q.text("%#x" % self.band_types)
-                q.text(","); q.breakable()
-                q.text("capabilities = ");
-                q.text("%#x" % self.capabilities)
-                q.text(","); q.breakable()
-                q.text("max_bands = ");
-                q.text("%#x" % self.max_bands)
-                q.text(","); q.breakable()
-                q.text("max_color = ");
-                q.text("%#x" % self.max_color)
-            q.breakable()
-        q.text('}')
-
-
-class meter_stats(loxi.OFObject):
-
-    def __init__(self, meter_id=None, flow_count=None, packet_in_count=None, byte_in_count=None, duration_sec=None, duration_nsec=None, band_stats=None):
-        if meter_id != None:
-            self.meter_id = meter_id
-        else:
-            self.meter_id = 0
-        if flow_count != None:
-            self.flow_count = flow_count
-        else:
-            self.flow_count = 0
-        if packet_in_count != None:
-            self.packet_in_count = packet_in_count
-        else:
-            self.packet_in_count = 0
-        if byte_in_count != None:
-            self.byte_in_count = byte_in_count
-        else:
-            self.byte_in_count = 0
-        if duration_sec != None:
-            self.duration_sec = duration_sec
-        else:
-            self.duration_sec = 0
-        if duration_nsec != None:
-            self.duration_nsec = duration_nsec
-        else:
-            self.duration_nsec = 0
-        if band_stats != None:
-            self.band_stats = band_stats
-        else:
-            self.band_stats = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.meter_id))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 6)
-        packed.append(struct.pack("!L", self.flow_count))
-        packed.append(struct.pack("!Q", self.packet_in_count))
-        packed.append(struct.pack("!Q", self.byte_in_count))
-        packed.append(struct.pack("!L", self.duration_sec))
-        packed.append(struct.pack("!L", self.duration_nsec))
-        packed.append(loxi.generic_util.pack_list(self.band_stats))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = meter_stats()
-        obj.meter_id = reader.read("!L")[0]
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 6)
-        reader.skip(6)
-        obj.flow_count = reader.read("!L")[0]
-        obj.packet_in_count = reader.read("!Q")[0]
-        obj.byte_in_count = reader.read("!Q")[0]
-        obj.duration_sec = reader.read("!L")[0]
-        obj.duration_nsec = reader.read("!L")[0]
-        obj.band_stats = loxi.generic_util.unpack_list(reader, ofp.common.meter_band_stats.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.meter_id != other.meter_id: return False
-        if self.flow_count != other.flow_count: return False
-        if self.packet_in_count != other.packet_in_count: return False
-        if self.byte_in_count != other.byte_in_count: return False
-        if self.duration_sec != other.duration_sec: return False
-        if self.duration_nsec != other.duration_nsec: return False
-        if self.band_stats != other.band_stats: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("meter_stats {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("meter_id = ");
-                q.text("%#x" % self.meter_id)
-                q.text(","); q.breakable()
-                q.text("flow_count = ");
-                q.text("%#x" % self.flow_count)
-                q.text(","); q.breakable()
-                q.text("packet_in_count = ");
-                q.text("%#x" % self.packet_in_count)
-                q.text(","); q.breakable()
-                q.text("byte_in_count = ");
-                q.text("%#x" % self.byte_in_count)
-                q.text(","); q.breakable()
-                q.text("duration_sec = ");
-                q.text("%#x" % self.duration_sec)
-                q.text(","); q.breakable()
-                q.text("duration_nsec = ");
-                q.text("%#x" % self.duration_nsec)
-                q.text(","); q.breakable()
-                q.text("band_stats = ");
-                q.pp(self.band_stats)
-            q.breakable()
-        q.text('}')
-
-
-class packet_queue(loxi.OFObject):
-
-    def __init__(self, queue_id=None, port=None, properties=None):
-        if queue_id != None:
-            self.queue_id = queue_id
-        else:
-            self.queue_id = 0
-        if port != None:
-            self.port = port
-        else:
-            self.port = 0
-        if properties != None:
-            self.properties = properties
-        else:
-            self.properties = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.queue_id))
-        packed.append(util.pack_port_no(self.port))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 2
-        packed.append('\x00' * 6)
-        packed.append(loxi.generic_util.pack_list(self.properties))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = packet_queue()
-        obj.queue_id = reader.read("!L")[0]
-        obj.port = util.unpack_port_no(reader)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 10)
-        reader.skip(6)
-        obj.properties = loxi.generic_util.unpack_list(reader, ofp.common.queue_prop.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.queue_id != other.queue_id: return False
-        if self.port != other.port: return False
-        if self.properties != other.properties: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("packet_queue {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("queue_id = ");
-                q.text("%#x" % self.queue_id)
-                q.text(","); q.breakable()
-                q.text("port = ");
-                q.text(util.pretty_port(self.port))
-                q.text(","); q.breakable()
-                q.text("properties = ");
-                q.pp(self.properties)
-            q.breakable()
-        q.text('}')
-
-
-class port_desc(loxi.OFObject):
-
-    def __init__(self, port_no=None, hw_addr=None, name=None, config=None, state=None, properties=None):
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if hw_addr != None:
-            self.hw_addr = hw_addr
-        else:
-            self.hw_addr = [0,0,0,0,0,0]
-        if name != None:
-            self.name = name
-        else:
-            self.name = ""
-        if config != None:
-            self.config = config
-        else:
-            self.config = 0
-        if state != None:
-            self.state = state
-        else:
-            self.state = 0
-        if properties != None:
-            self.properties = properties
-        else:
-            self.properties = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append('\x00' * 2)
-        packed.append(struct.pack("!6B", *self.hw_addr))
-        packed.append('\x00' * 2)
-        packed.append(struct.pack("!16s", self.name))
-        packed.append(struct.pack("!L", self.config))
-        packed.append(struct.pack("!L", self.state))
-        packed.append(loxi.generic_util.pack_list(self.properties))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = port_desc()
-        obj.port_no = util.unpack_port_no(reader)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 6)
-        reader.skip(2)
-        obj.hw_addr = list(reader.read('!6B'))
-        reader.skip(2)
-        obj.name = reader.read("!16s")[0].rstrip("\x00")
-        obj.config = reader.read("!L")[0]
-        obj.state = reader.read("!L")[0]
-        obj.properties = loxi.generic_util.unpack_list(reader, ofp.port_desc_prop.port_desc_prop.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.port_no != other.port_no: return False
-        if self.hw_addr != other.hw_addr: return False
-        if self.name != other.name: return False
-        if self.config != other.config: return False
-        if self.state != other.state: return False
-        if self.properties != other.properties: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port_desc {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("hw_addr = ");
-                q.text(util.pretty_mac(self.hw_addr))
-                q.text(","); q.breakable()
-                q.text("name = ");
-                q.pp(self.name)
-                q.text(","); q.breakable()
-                q.text("config = ");
-                q.text("%#x" % self.config)
-                q.text(","); q.breakable()
-                q.text("state = ");
-                q.text("%#x" % self.state)
-                q.text(","); q.breakable()
-                q.text("properties = ");
-                q.pp(self.properties)
-            q.breakable()
-        q.text('}')
-
-
-class port_stats_entry(loxi.OFObject):
-
-    def __init__(self, port_no=None, duration_sec=None, duration_nsec=None, rx_packets=None, tx_packets=None, rx_bytes=None, tx_bytes=None, rx_dropped=None, tx_dropped=None, rx_errors=None, tx_errors=None, properties=None):
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if duration_sec != None:
-            self.duration_sec = duration_sec
-        else:
-            self.duration_sec = 0
-        if duration_nsec != None:
-            self.duration_nsec = duration_nsec
-        else:
-            self.duration_nsec = 0
-        if rx_packets != None:
-            self.rx_packets = rx_packets
-        else:
-            self.rx_packets = 0
-        if tx_packets != None:
-            self.tx_packets = tx_packets
-        else:
-            self.tx_packets = 0
-        if rx_bytes != None:
-            self.rx_bytes = rx_bytes
-        else:
-            self.rx_bytes = 0
-        if tx_bytes != None:
-            self.tx_bytes = tx_bytes
-        else:
-            self.tx_bytes = 0
-        if rx_dropped != None:
-            self.rx_dropped = rx_dropped
-        else:
-            self.rx_dropped = 0
-        if tx_dropped != None:
-            self.tx_dropped = tx_dropped
-        else:
-            self.tx_dropped = 0
-        if rx_errors != None:
-            self.rx_errors = rx_errors
-        else:
-            self.rx_errors = 0
-        if tx_errors != None:
-            self.tx_errors = tx_errors
-        else:
-            self.tx_errors = 0
-        if properties != None:
-            self.properties = properties
-        else:
-            self.properties = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 0
-        packed.append('\x00' * 2)
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(struct.pack("!L", self.duration_sec))
-        packed.append(struct.pack("!L", self.duration_nsec))
-        packed.append(struct.pack("!Q", self.rx_packets))
-        packed.append(struct.pack("!Q", self.tx_packets))
-        packed.append(struct.pack("!Q", self.rx_bytes))
-        packed.append(struct.pack("!Q", self.tx_bytes))
-        packed.append(struct.pack("!Q", self.rx_dropped))
-        packed.append(struct.pack("!Q", self.tx_dropped))
-        packed.append(struct.pack("!Q", self.rx_errors))
-        packed.append(struct.pack("!Q", self.tx_errors))
-        packed.append(loxi.generic_util.pack_list(self.properties))
-        length = sum([len(x) for x in packed])
-        packed[0] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = port_stats_entry()
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 2)
-        reader.skip(2)
-        obj.port_no = util.unpack_port_no(reader)
-        obj.duration_sec = reader.read("!L")[0]
-        obj.duration_nsec = reader.read("!L")[0]
-        obj.rx_packets = reader.read("!Q")[0]
-        obj.tx_packets = reader.read("!Q")[0]
-        obj.rx_bytes = reader.read("!Q")[0]
-        obj.tx_bytes = reader.read("!Q")[0]
-        obj.rx_dropped = reader.read("!Q")[0]
-        obj.tx_dropped = reader.read("!Q")[0]
-        obj.rx_errors = reader.read("!Q")[0]
-        obj.tx_errors = reader.read("!Q")[0]
-        obj.properties = loxi.generic_util.unpack_list(reader, ofp.port_stats_prop.port_stats_prop.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.port_no != other.port_no: return False
-        if self.duration_sec != other.duration_sec: return False
-        if self.duration_nsec != other.duration_nsec: return False
-        if self.rx_packets != other.rx_packets: return False
-        if self.tx_packets != other.tx_packets: return False
-        if self.rx_bytes != other.rx_bytes: return False
-        if self.tx_bytes != other.tx_bytes: return False
-        if self.rx_dropped != other.rx_dropped: return False
-        if self.tx_dropped != other.tx_dropped: return False
-        if self.rx_errors != other.rx_errors: return False
-        if self.tx_errors != other.tx_errors: return False
-        if self.properties != other.properties: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("duration_sec = ");
-                q.text("%#x" % self.duration_sec)
-                q.text(","); q.breakable()
-                q.text("duration_nsec = ");
-                q.text("%#x" % self.duration_nsec)
-                q.text(","); q.breakable()
-                q.text("rx_packets = ");
-                q.text("%#x" % self.rx_packets)
-                q.text(","); q.breakable()
-                q.text("tx_packets = ");
-                q.text("%#x" % self.tx_packets)
-                q.text(","); q.breakable()
-                q.text("rx_bytes = ");
-                q.text("%#x" % self.rx_bytes)
-                q.text(","); q.breakable()
-                q.text("tx_bytes = ");
-                q.text("%#x" % self.tx_bytes)
-                q.text(","); q.breakable()
-                q.text("rx_dropped = ");
-                q.text("%#x" % self.rx_dropped)
-                q.text(","); q.breakable()
-                q.text("tx_dropped = ");
-                q.text("%#x" % self.tx_dropped)
-                q.text(","); q.breakable()
-                q.text("rx_errors = ");
-                q.text("%#x" % self.rx_errors)
-                q.text(","); q.breakable()
-                q.text("tx_errors = ");
-                q.text("%#x" % self.tx_errors)
-                q.text(","); q.breakable()
-                q.text("properties = ");
-                q.pp(self.properties)
-            q.breakable()
-        q.text('}')
-
-
-class queue_desc(loxi.OFObject):
-
-    def __init__(self, port_no=None, queue_id=None, properties=None):
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if queue_id != None:
-            self.queue_id = queue_id
-        else:
-            self.queue_id = 0
-        if properties != None:
-            self.properties = properties
-        else:
-            self.properties = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.port_no))
-        packed.append(struct.pack("!L", self.queue_id))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append('\x00' * 6)
-        packed.append(loxi.generic_util.pack_list(self.properties))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = queue_desc()
-        obj.port_no = reader.read("!L")[0]
-        obj.queue_id = reader.read("!L")[0]
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 10)
-        reader.skip(6)
-        obj.properties = loxi.generic_util.unpack_list(reader, ofp.queue_desc_prop.queue_desc_prop.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.port_no != other.port_no: return False
-        if self.queue_id != other.queue_id: return False
-        if self.properties != other.properties: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_desc {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("port_no = ");
-                q.text("%#x" % self.port_no)
-                q.text(","); q.breakable()
-                q.text("queue_id = ");
-                q.text("%#x" % self.queue_id)
-                q.text(","); q.breakable()
-                q.text("properties = ");
-                q.pp(self.properties)
-            q.breakable()
-        q.text('}')
-
-
-class queue_prop(loxi.OFObject):
-    subtypes = {}
-
-
-    def __init__(self, type=None):
-        if type != None:
-            self.type = type
-        else:
-            self.type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 0)
-        subclass = queue_prop.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = queue_prop()
-        obj.type = reader.read("!H")[0]
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type != other.type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_prop {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-
-class queue_prop_experimenter(queue_prop):
-    subtypes = {}
-
-    type = 65535
-
-    def __init__(self, experimenter=None, data=None):
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append('\x00' * 4)
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 8)
-        subclass = queue_prop_experimenter.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = queue_prop_experimenter()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        obj.experimenter = reader.read("!L")[0]
-        reader.skip(4)
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.experimenter != other.experimenter: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_prop_experimenter {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-queue_prop.subtypes[65535] = queue_prop_experimenter
-
-class queue_prop_max_rate(queue_prop):
-    type = 2
-
-    def __init__(self, rate=None):
-        if rate != None:
-            self.rate = rate
-        else:
-            self.rate = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!H", self.rate))
-        packed.append('\x00' * 6)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = queue_prop_max_rate()
-        _type = reader.read("!H")[0]
-        assert(_type == 2)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        obj.rate = reader.read("!H")[0]
-        reader.skip(6)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.rate != other.rate: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_prop_max_rate {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("rate = ");
-                q.text("%#x" % self.rate)
-            q.breakable()
-        q.text('}')
-
-queue_prop.subtypes[2] = queue_prop_max_rate
-
-class queue_prop_min_rate(queue_prop):
-    type = 1
-
-    def __init__(self, rate=None):
-        if rate != None:
-            self.rate = rate
-        else:
-            self.rate = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!H", self.rate))
-        packed.append('\x00' * 6)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = queue_prop_min_rate()
-        _type = reader.read("!H")[0]
-        assert(_type == 1)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        obj.rate = reader.read("!H")[0]
-        reader.skip(6)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.rate != other.rate: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_prop_min_rate {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("rate = ");
-                q.text("%#x" % self.rate)
-            q.breakable()
-        q.text('}')
-
-queue_prop.subtypes[1] = queue_prop_min_rate
-
-class queue_stats_entry(loxi.OFObject):
-
-    def __init__(self, port_no=None, queue_id=None, tx_bytes=None, tx_packets=None, tx_errors=None, duration_sec=None, duration_nsec=None, properties=None):
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if queue_id != None:
-            self.queue_id = queue_id
-        else:
-            self.queue_id = 0
-        if tx_bytes != None:
-            self.tx_bytes = tx_bytes
-        else:
-            self.tx_bytes = 0
-        if tx_packets != None:
-            self.tx_packets = tx_packets
-        else:
-            self.tx_packets = 0
-        if tx_errors != None:
-            self.tx_errors = tx_errors
-        else:
-            self.tx_errors = 0
-        if duration_sec != None:
-            self.duration_sec = duration_sec
-        else:
-            self.duration_sec = 0
-        if duration_nsec != None:
-            self.duration_nsec = duration_nsec
-        else:
-            self.duration_nsec = 0
-        if properties != None:
-            self.properties = properties
-        else:
-            self.properties = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 0
-        packed.append('\x00' * 6)
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(struct.pack("!L", self.queue_id))
-        packed.append(struct.pack("!Q", self.tx_bytes))
-        packed.append(struct.pack("!Q", self.tx_packets))
-        packed.append(struct.pack("!Q", self.tx_errors))
-        packed.append(struct.pack("!L", self.duration_sec))
-        packed.append(struct.pack("!L", self.duration_nsec))
-        packed.append(loxi.generic_util.pack_list(self.properties))
-        length = sum([len(x) for x in packed])
-        packed[0] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = queue_stats_entry()
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 2)
-        reader.skip(6)
-        obj.port_no = util.unpack_port_no(reader)
-        obj.queue_id = reader.read("!L")[0]
-        obj.tx_bytes = reader.read("!Q")[0]
-        obj.tx_packets = reader.read("!Q")[0]
-        obj.tx_errors = reader.read("!Q")[0]
-        obj.duration_sec = reader.read("!L")[0]
-        obj.duration_nsec = reader.read("!L")[0]
-        obj.properties = loxi.generic_util.unpack_list(reader, ofp.queue_stats_prop.queue_stats_prop.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.port_no != other.port_no: return False
-        if self.queue_id != other.queue_id: return False
-        if self.tx_bytes != other.tx_bytes: return False
-        if self.tx_packets != other.tx_packets: return False
-        if self.tx_errors != other.tx_errors: return False
-        if self.duration_sec != other.duration_sec: return False
-        if self.duration_nsec != other.duration_nsec: return False
-        if self.properties != other.properties: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("queue_id = ");
-                q.text("%#x" % self.queue_id)
-                q.text(","); q.breakable()
-                q.text("tx_bytes = ");
-                q.text("%#x" % self.tx_bytes)
-                q.text(","); q.breakable()
-                q.text("tx_packets = ");
-                q.text("%#x" % self.tx_packets)
-                q.text(","); q.breakable()
-                q.text("tx_errors = ");
-                q.text("%#x" % self.tx_errors)
-                q.text(","); q.breakable()
-                q.text("duration_sec = ");
-                q.text("%#x" % self.duration_sec)
-                q.text(","); q.breakable()
-                q.text("duration_nsec = ");
-                q.text("%#x" % self.duration_nsec)
-                q.text(","); q.breakable()
-                q.text("properties = ");
-                q.pp(self.properties)
-            q.breakable()
-        q.text('}')
-
-
-class table_desc(loxi.OFObject):
-
-    def __init__(self, table_id=None, config=None):
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if config != None:
-            self.config = config
-        else:
-            self.config = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 0
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append('\x00' * 1)
-        packed.append(struct.pack("!L", self.config))
-        length = sum([len(x) for x in packed])
-        packed[0] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_desc()
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 2)
-        obj.table_id = reader.read("!B")[0]
-        reader.skip(1)
-        obj.config = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.table_id != other.table_id: return False
-        if self.config != other.config: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_desc {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("config = ");
-                q.text("%#x" % self.config)
-            q.breakable()
-        q.text('}')
-
-
-class table_feature_prop(loxi.OFObject):
-    subtypes = {}
-
-
-    def __init__(self, type=None):
-        if type != None:
-            self.type = type
-        else:
-            self.type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 0)
-        subclass = table_feature_prop.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = table_feature_prop()
-        obj.type = reader.read("!H")[0]
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type != other.type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_feature_prop {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-
-class table_feature_prop_apply_actions(table_feature_prop):
-    type = 6
-
-    def __init__(self, action_ids=None):
-        if action_ids != None:
-            self.action_ids = action_ids
-        else:
-            self.action_ids = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(loxi.generic_util.pack_list(self.action_ids))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        packed.append(loxi.generic_util.pad_to(8, length))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_feature_prop_apply_actions()
-        _type = reader.read("!H")[0]
-        assert(_type == 6)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.action_ids = loxi.generic_util.unpack_list(reader, ofp.action_id.action_id.unpack)
-        orig_reader.skip_align()
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.action_ids != other.action_ids: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_feature_prop_apply_actions {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("action_ids = ");
-                q.pp(self.action_ids)
-            q.breakable()
-        q.text('}')
-
-table_feature_prop.subtypes[6] = table_feature_prop_apply_actions
-
-class table_feature_prop_apply_actions_miss(table_feature_prop):
-    type = 7
-
-    def __init__(self, action_ids=None):
-        if action_ids != None:
-            self.action_ids = action_ids
-        else:
-            self.action_ids = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(loxi.generic_util.pack_list(self.action_ids))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        packed.append(loxi.generic_util.pad_to(8, length))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_feature_prop_apply_actions_miss()
-        _type = reader.read("!H")[0]
-        assert(_type == 7)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.action_ids = loxi.generic_util.unpack_list(reader, ofp.action_id.action_id.unpack)
-        orig_reader.skip_align()
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.action_ids != other.action_ids: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_feature_prop_apply_actions_miss {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("action_ids = ");
-                q.pp(self.action_ids)
-            q.breakable()
-        q.text('}')
-
-table_feature_prop.subtypes[7] = table_feature_prop_apply_actions_miss
-
-class table_feature_prop_apply_setfield(table_feature_prop):
-    type = 14
-
-    def __init__(self, oxm_ids=None):
-        if oxm_ids != None:
-            self.oxm_ids = oxm_ids
-        else:
-            self.oxm_ids = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(loxi.generic_util.pack_list(self.oxm_ids))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        packed.append(loxi.generic_util.pad_to(8, length))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_feature_prop_apply_setfield()
-        _type = reader.read("!H")[0]
-        assert(_type == 14)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.oxm_ids = loxi.generic_util.unpack_list(reader, ofp.common.uint32.unpack)
-        orig_reader.skip_align()
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.oxm_ids != other.oxm_ids: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_feature_prop_apply_setfield {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("oxm_ids = ");
-                q.pp(self.oxm_ids)
-            q.breakable()
-        q.text('}')
-
-table_feature_prop.subtypes[14] = table_feature_prop_apply_setfield
-
-class table_feature_prop_apply_setfield_miss(table_feature_prop):
-    type = 15
-
-    def __init__(self, oxm_ids=None):
-        if oxm_ids != None:
-            self.oxm_ids = oxm_ids
-        else:
-            self.oxm_ids = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(loxi.generic_util.pack_list(self.oxm_ids))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        packed.append(loxi.generic_util.pad_to(8, length))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_feature_prop_apply_setfield_miss()
-        _type = reader.read("!H")[0]
-        assert(_type == 15)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.oxm_ids = loxi.generic_util.unpack_list(reader, ofp.common.uint32.unpack)
-        orig_reader.skip_align()
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.oxm_ids != other.oxm_ids: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_feature_prop_apply_setfield_miss {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("oxm_ids = ");
-                q.pp(self.oxm_ids)
-            q.breakable()
-        q.text('}')
-
-table_feature_prop.subtypes[15] = table_feature_prop_apply_setfield_miss
-
-class table_feature_prop_experimenter(table_feature_prop):
-    subtypes = {}
-
-    type = 65534
-
-    def __init__(self, experimenter=None, subtype=None, experimenter_data=None):
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        if experimenter_data != None:
-            self.experimenter_data = experimenter_data
-        else:
-            self.experimenter_data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(self.experimenter_data)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        packed.append(loxi.generic_util.pad_to(8, length))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 4)
-        subclass = table_feature_prop_experimenter.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = table_feature_prop_experimenter()
-        _type = reader.read("!H")[0]
-        assert(_type == 65534)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.experimenter = reader.read("!L")[0]
-        obj.subtype = reader.read("!L")[0]
-        obj.experimenter_data = str(reader.read_all())
-        orig_reader.skip_align()
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.experimenter != other.experimenter: return False
-        if self.subtype != other.subtype: return False
-        if self.experimenter_data != other.experimenter_data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_feature_prop_experimenter {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("subtype = ");
-                q.text("%#x" % self.subtype)
-                q.text(","); q.breakable()
-                q.text("experimenter_data = ");
-                q.pp(self.experimenter_data)
-            q.breakable()
-        q.text('}')
-
-table_feature_prop.subtypes[65534] = table_feature_prop_experimenter
-
-class table_feature_prop_experimenter_miss(table_feature_prop):
-    subtypes = {}
-
-    type = 65535
-
-    def __init__(self, experimenter=None, subtype=None, experimenter_data=None):
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        if experimenter_data != None:
-            self.experimenter_data = experimenter_data
-        else:
-            self.experimenter_data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(self.experimenter_data)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        packed.append(loxi.generic_util.pad_to(8, length))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 4)
-        subclass = table_feature_prop_experimenter_miss.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = table_feature_prop_experimenter_miss()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.experimenter = reader.read("!L")[0]
-        obj.subtype = reader.read("!L")[0]
-        obj.experimenter_data = str(reader.read_all())
-        orig_reader.skip_align()
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.experimenter != other.experimenter: return False
-        if self.subtype != other.subtype: return False
-        if self.experimenter_data != other.experimenter_data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_feature_prop_experimenter_miss {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("subtype = ");
-                q.text("%#x" % self.subtype)
-                q.text(","); q.breakable()
-                q.text("experimenter_data = ");
-                q.pp(self.experimenter_data)
-            q.breakable()
-        q.text('}')
-
-table_feature_prop.subtypes[65535] = table_feature_prop_experimenter_miss
-
-class table_feature_prop_instructions(table_feature_prop):
-    type = 0
-
-    def __init__(self, instruction_ids=None):
-        if instruction_ids != None:
-            self.instruction_ids = instruction_ids
-        else:
-            self.instruction_ids = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(loxi.generic_util.pack_list(self.instruction_ids))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        packed.append(loxi.generic_util.pad_to(8, length))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_feature_prop_instructions()
-        _type = reader.read("!H")[0]
-        assert(_type == 0)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.instruction_ids = loxi.generic_util.unpack_list(reader, ofp.instruction_id.instruction_id.unpack)
-        orig_reader.skip_align()
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.instruction_ids != other.instruction_ids: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_feature_prop_instructions {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("instruction_ids = ");
-                q.pp(self.instruction_ids)
-            q.breakable()
-        q.text('}')
-
-table_feature_prop.subtypes[0] = table_feature_prop_instructions
-
-class table_feature_prop_instructions_miss(table_feature_prop):
-    type = 1
-
-    def __init__(self, instruction_ids=None):
-        if instruction_ids != None:
-            self.instruction_ids = instruction_ids
-        else:
-            self.instruction_ids = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(loxi.generic_util.pack_list(self.instruction_ids))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        packed.append(loxi.generic_util.pad_to(8, length))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_feature_prop_instructions_miss()
-        _type = reader.read("!H")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.instruction_ids = loxi.generic_util.unpack_list(reader, ofp.instruction_id.instruction_id.unpack)
-        orig_reader.skip_align()
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.instruction_ids != other.instruction_ids: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_feature_prop_instructions_miss {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("instruction_ids = ");
-                q.pp(self.instruction_ids)
-            q.breakable()
-        q.text('}')
-
-table_feature_prop.subtypes[1] = table_feature_prop_instructions_miss
-
-class table_feature_prop_match(table_feature_prop):
-    type = 8
-
-    def __init__(self, oxm_ids=None):
-        if oxm_ids != None:
-            self.oxm_ids = oxm_ids
-        else:
-            self.oxm_ids = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(loxi.generic_util.pack_list(self.oxm_ids))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        packed.append(loxi.generic_util.pad_to(8, length))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_feature_prop_match()
-        _type = reader.read("!H")[0]
-        assert(_type == 8)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.oxm_ids = loxi.generic_util.unpack_list(reader, ofp.common.uint32.unpack)
-        orig_reader.skip_align()
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.oxm_ids != other.oxm_ids: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_feature_prop_match {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("oxm_ids = ");
-                q.pp(self.oxm_ids)
-            q.breakable()
-        q.text('}')
-
-table_feature_prop.subtypes[8] = table_feature_prop_match
-
-class table_feature_prop_next_tables(table_feature_prop):
-    type = 2
-
-    def __init__(self, next_table_ids=None):
-        if next_table_ids != None:
-            self.next_table_ids = next_table_ids
-        else:
-            self.next_table_ids = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(loxi.generic_util.pack_list(self.next_table_ids))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        packed.append(loxi.generic_util.pad_to(8, length))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_feature_prop_next_tables()
-        _type = reader.read("!H")[0]
-        assert(_type == 2)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.next_table_ids = loxi.generic_util.unpack_list(reader, ofp.common.uint8.unpack)
-        orig_reader.skip_align()
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.next_table_ids != other.next_table_ids: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_feature_prop_next_tables {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("next_table_ids = ");
-                q.pp(self.next_table_ids)
-            q.breakable()
-        q.text('}')
-
-table_feature_prop.subtypes[2] = table_feature_prop_next_tables
-
-class table_feature_prop_next_tables_miss(table_feature_prop):
-    type = 3
-
-    def __init__(self, next_table_ids=None):
-        if next_table_ids != None:
-            self.next_table_ids = next_table_ids
-        else:
-            self.next_table_ids = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(loxi.generic_util.pack_list(self.next_table_ids))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        packed.append(loxi.generic_util.pad_to(8, length))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_feature_prop_next_tables_miss()
-        _type = reader.read("!H")[0]
-        assert(_type == 3)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.next_table_ids = loxi.generic_util.unpack_list(reader, ofp.common.uint8.unpack)
-        orig_reader.skip_align()
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.next_table_ids != other.next_table_ids: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_feature_prop_next_tables_miss {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("next_table_ids = ");
-                q.pp(self.next_table_ids)
-            q.breakable()
-        q.text('}')
-
-table_feature_prop.subtypes[3] = table_feature_prop_next_tables_miss
-
-class table_feature_prop_table_sync_from(table_feature_prop):
-    type = 16
-
-    def __init__(self, table_ids=None):
-        if table_ids != None:
-            self.table_ids = table_ids
-        else:
-            self.table_ids = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(loxi.generic_util.pack_list(self.table_ids))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        packed.append(loxi.generic_util.pad_to(8, length))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_feature_prop_table_sync_from()
-        _type = reader.read("!H")[0]
-        assert(_type == 16)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.table_ids = loxi.generic_util.unpack_list(reader, ofp.common.uint8.unpack)
-        orig_reader.skip_align()
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.table_ids != other.table_ids: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_feature_prop_table_sync_from {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("table_ids = ");
-                q.pp(self.table_ids)
-            q.breakable()
-        q.text('}')
-
-table_feature_prop.subtypes[16] = table_feature_prop_table_sync_from
-
-class table_feature_prop_wildcards(table_feature_prop):
-    type = 10
-
-    def __init__(self, oxm_ids=None):
-        if oxm_ids != None:
-            self.oxm_ids = oxm_ids
-        else:
-            self.oxm_ids = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(loxi.generic_util.pack_list(self.oxm_ids))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        packed.append(loxi.generic_util.pad_to(8, length))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_feature_prop_wildcards()
-        _type = reader.read("!H")[0]
-        assert(_type == 10)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.oxm_ids = loxi.generic_util.unpack_list(reader, ofp.common.uint32.unpack)
-        orig_reader.skip_align()
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.oxm_ids != other.oxm_ids: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_feature_prop_wildcards {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("oxm_ids = ");
-                q.pp(self.oxm_ids)
-            q.breakable()
-        q.text('}')
-
-table_feature_prop.subtypes[10] = table_feature_prop_wildcards
-
-class table_feature_prop_write_actions(table_feature_prop):
-    type = 4
-
-    def __init__(self, action_ids=None):
-        if action_ids != None:
-            self.action_ids = action_ids
-        else:
-            self.action_ids = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(loxi.generic_util.pack_list(self.action_ids))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        packed.append(loxi.generic_util.pad_to(8, length))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_feature_prop_write_actions()
-        _type = reader.read("!H")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.action_ids = loxi.generic_util.unpack_list(reader, ofp.action_id.action_id.unpack)
-        orig_reader.skip_align()
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.action_ids != other.action_ids: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_feature_prop_write_actions {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("action_ids = ");
-                q.pp(self.action_ids)
-            q.breakable()
-        q.text('}')
-
-table_feature_prop.subtypes[4] = table_feature_prop_write_actions
-
-class table_feature_prop_write_actions_miss(table_feature_prop):
-    type = 5
-
-    def __init__(self, action_ids=None):
-        if action_ids != None:
-            self.action_ids = action_ids
-        else:
-            self.action_ids = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(loxi.generic_util.pack_list(self.action_ids))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        packed.append(loxi.generic_util.pad_to(8, length))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_feature_prop_write_actions_miss()
-        _type = reader.read("!H")[0]
-        assert(_type == 5)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.action_ids = loxi.generic_util.unpack_list(reader, ofp.action_id.action_id.unpack)
-        orig_reader.skip_align()
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.action_ids != other.action_ids: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_feature_prop_write_actions_miss {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("action_ids = ");
-                q.pp(self.action_ids)
-            q.breakable()
-        q.text('}')
-
-table_feature_prop.subtypes[5] = table_feature_prop_write_actions_miss
-
-class table_feature_prop_write_setfield(table_feature_prop):
-    type = 12
-
-    def __init__(self, oxm_ids=None):
-        if oxm_ids != None:
-            self.oxm_ids = oxm_ids
-        else:
-            self.oxm_ids = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(loxi.generic_util.pack_list(self.oxm_ids))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        packed.append(loxi.generic_util.pad_to(8, length))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_feature_prop_write_setfield()
-        _type = reader.read("!H")[0]
-        assert(_type == 12)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.oxm_ids = loxi.generic_util.unpack_list(reader, ofp.common.uint32.unpack)
-        orig_reader.skip_align()
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.oxm_ids != other.oxm_ids: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_feature_prop_write_setfield {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("oxm_ids = ");
-                q.pp(self.oxm_ids)
-            q.breakable()
-        q.text('}')
-
-table_feature_prop.subtypes[12] = table_feature_prop_write_setfield
-
-class table_feature_prop_write_setfield_miss(table_feature_prop):
-    type = 13
-
-    def __init__(self, oxm_ids=None):
-        if oxm_ids != None:
-            self.oxm_ids = oxm_ids
-        else:
-            self.oxm_ids = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(loxi.generic_util.pack_list(self.oxm_ids))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        packed.append(loxi.generic_util.pad_to(8, length))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_feature_prop_write_setfield_miss()
-        _type = reader.read("!H")[0]
-        assert(_type == 13)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.oxm_ids = loxi.generic_util.unpack_list(reader, ofp.common.uint32.unpack)
-        orig_reader.skip_align()
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.oxm_ids != other.oxm_ids: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_feature_prop_write_setfield_miss {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("oxm_ids = ");
-                q.pp(self.oxm_ids)
-            q.breakable()
-        q.text('}')
-
-table_feature_prop.subtypes[13] = table_feature_prop_write_setfield_miss
-
-class table_features(loxi.OFObject):
-
-    def __init__(self, table_id=None, name=None, metadata_match=None, metadata_write=None, config=None, max_entries=None, properties=None):
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if name != None:
-            self.name = name
-        else:
-            self.name = ""
-        if metadata_match != None:
-            self.metadata_match = metadata_match
-        else:
-            self.metadata_match = 0
-        if metadata_write != None:
-            self.metadata_write = metadata_write
-        else:
-            self.metadata_write = 0
-        if config != None:
-            self.config = config
-        else:
-            self.config = 0
-        if max_entries != None:
-            self.max_entries = max_entries
-        else:
-            self.max_entries = 0
-        if properties != None:
-            self.properties = properties
-        else:
-            self.properties = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 0
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append('\x00' * 5)
-        packed.append(struct.pack("!32s", self.name))
-        packed.append(struct.pack("!Q", self.metadata_match))
-        packed.append(struct.pack("!Q", self.metadata_write))
-        packed.append(struct.pack("!L", self.config))
-        packed.append(struct.pack("!L", self.max_entries))
-        packed.append(loxi.generic_util.pack_list(self.properties))
-        length = sum([len(x) for x in packed])
-        packed[0] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_features()
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 2)
-        obj.table_id = reader.read("!B")[0]
-        reader.skip(5)
-        obj.name = reader.read("!32s")[0].rstrip("\x00")
-        obj.metadata_match = reader.read("!Q")[0]
-        obj.metadata_write = reader.read("!Q")[0]
-        obj.config = reader.read("!L")[0]
-        obj.max_entries = reader.read("!L")[0]
-        obj.properties = loxi.generic_util.unpack_list(reader, ofp.common.table_feature_prop.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.table_id != other.table_id: return False
-        if self.name != other.name: return False
-        if self.metadata_match != other.metadata_match: return False
-        if self.metadata_write != other.metadata_write: return False
-        if self.config != other.config: return False
-        if self.max_entries != other.max_entries: return False
-        if self.properties != other.properties: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_features {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("name = ");
-                q.pp(self.name)
-                q.text(","); q.breakable()
-                q.text("metadata_match = ");
-                q.text("%#x" % self.metadata_match)
-                q.text(","); q.breakable()
-                q.text("metadata_write = ");
-                q.text("%#x" % self.metadata_write)
-                q.text(","); q.breakable()
-                q.text("config = ");
-                q.text("%#x" % self.config)
-                q.text(","); q.breakable()
-                q.text("max_entries = ");
-                q.text("%#x" % self.max_entries)
-                q.text(","); q.breakable()
-                q.text("properties = ");
-                q.pp(self.properties)
-            q.breakable()
-        q.text('}')
-
-
-class table_mod_prop_eviction(loxi.OFObject):
-    type = 2
-
-    def __init__(self, flags=None):
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.flags))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_mod_prop_eviction()
-        _type = reader.read("!H")[0]
-        assert(_type == 2)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.flags = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_mod_prop_eviction {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-
-class table_mod_prop_experimenter(loxi.OFObject):
-    subtypes = {}
-
-    type = 65535
-
-    def __init__(self, experimenter=None, exp_type=None):
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        if exp_type != None:
-            self.exp_type = exp_type
-        else:
-            self.exp_type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.exp_type))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 4)
-        subclass = table_mod_prop_experimenter.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = table_mod_prop_experimenter()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.experimenter = reader.read("!L")[0]
-        obj.exp_type = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.experimenter != other.experimenter: return False
-        if self.exp_type != other.exp_type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_mod_prop_experimenter {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("exp_type = ");
-                q.text("%#x" % self.exp_type)
-            q.breakable()
-        q.text('}')
-
-
-class table_mod_prop_vacancy(loxi.OFObject):
-    type = 3
-
-    def __init__(self, vacancy_down=None, vacancy_up=None, vacancy=None):
-        if vacancy_down != None:
-            self.vacancy_down = vacancy_down
-        else:
-            self.vacancy_down = 0
-        if vacancy_up != None:
-            self.vacancy_up = vacancy_up
-        else:
-            self.vacancy_up = 0
-        if vacancy != None:
-            self.vacancy = vacancy
-        else:
-            self.vacancy = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!B", self.vacancy_down))
-        packed.append(struct.pack("!B", self.vacancy_up))
-        packed.append(struct.pack("!B", self.vacancy))
-        packed.append('\x00' * 1)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_mod_prop_vacancy()
-        _type = reader.read("!H")[0]
-        assert(_type == 3)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.vacancy_down = reader.read("!B")[0]
-        obj.vacancy_up = reader.read("!B")[0]
-        obj.vacancy = reader.read("!B")[0]
-        reader.skip(1)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.vacancy_down != other.vacancy_down: return False
-        if self.vacancy_up != other.vacancy_up: return False
-        if self.vacancy != other.vacancy: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_mod_prop_vacancy {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("vacancy_down = ");
-                q.text("%#x" % self.vacancy_down)
-                q.text(","); q.breakable()
-                q.text("vacancy_up = ");
-                q.text("%#x" % self.vacancy_up)
-                q.text(","); q.breakable()
-                q.text("vacancy = ");
-                q.text("%#x" % self.vacancy)
-            q.breakable()
-        q.text('}')
-
-
-class table_stats_entry(loxi.OFObject):
-
-    def __init__(self, table_id=None, active_count=None, lookup_count=None, matched_count=None):
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if active_count != None:
-            self.active_count = active_count
-        else:
-            self.active_count = 0
-        if lookup_count != None:
-            self.lookup_count = lookup_count
-        else:
-            self.lookup_count = 0
-        if matched_count != None:
-            self.matched_count = matched_count
-        else:
-            self.matched_count = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append('\x00' * 3)
-        packed.append(struct.pack("!L", self.active_count))
-        packed.append(struct.pack("!Q", self.lookup_count))
-        packed.append(struct.pack("!Q", self.matched_count))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_stats_entry()
-        obj.table_id = reader.read("!B")[0]
-        reader.skip(3)
-        obj.active_count = reader.read("!L")[0]
-        obj.lookup_count = reader.read("!Q")[0]
-        obj.matched_count = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.table_id != other.table_id: return False
-        if self.active_count != other.active_count: return False
-        if self.lookup_count != other.lookup_count: return False
-        if self.matched_count != other.matched_count: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_stats_entry {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("active_count = ");
-                q.text("%#x" % self.active_count)
-                q.text(","); q.breakable()
-                q.text("lookup_count = ");
-                q.text("%#x" % self.lookup_count)
-                q.text(","); q.breakable()
-                q.text("matched_count = ");
-                q.text("%#x" % self.matched_count)
-            q.breakable()
-        q.text('}')
-
-
-class uint32(loxi.OFObject):
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = uint32()
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("uint32 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-
-class uint64(loxi.OFObject):
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!Q", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = uint64()
-        obj.value = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("uint64 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-
-class uint8(loxi.OFObject):
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = uint8()
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("uint8 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-
-
-match = match_v3
diff --git a/python/ofagent/loxi/of14/const.py b/python/ofagent/loxi/of14/const.py
deleted file mode 100644
index f942ac0..0000000
--- a/python/ofagent/loxi/of14/const.py
+++ /dev/null
@@ -1,1646 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template const.py
-# Do not modify
-
-OFP_VERSION = 5
-
-# Identifiers from group macro_definitions
-OFP_MAX_TABLE_NAME_LEN = 32
-OFP_MAX_PORT_NAME_LEN = 16
-OFP_TCP_PORT = 6653
-OFP_SSL_PORT = 6653
-OFP_ETH_ALEN = 6
-OFP_DEFAULT_MISS_SEND_LEN = 128
-OFP_VLAN_NONE = 0
-OFP_FLOW_PERMANENT = 0
-OFP_DEFAULT_PRIORITY = 32768
-OFP_NO_BUFFER = 4294967295
-DESC_STR_LEN = 256
-SERIAL_NUM_LEN = 32
-OFPQ_ALL = 4294967295
-OFPQ_MAX_RATE_UNCFG = 65535
-OFPQ_MIN_RATE_UNCFG = 65535
-
-# Identifiers from group of_bsn_hash_packet_field
-OFP_BSN_HASH_FIELD_DISABLE = 1
-OFP_BSN_HASH_FIELD_DST_MAC = 2
-OFP_BSN_HASH_FIELD_SRC_MAC = 4
-OFP_BSN_HASH_FIELD_ETH_TYPE = 8
-OFP_BSN_HASH_FIELD_VLAN_ID = 16
-OFP_BSN_HASH_FIELD_INNER_L2 = 32
-OFP_BSN_HASH_FIELD_INNER_L3 = 64
-OFP_BSN_HASH_FIELD_SRC_IP = 128
-OFP_BSN_HASH_FIELD_DST_IP = 256
-OFP_BSN_HASH_FIELD_IP_PROTO = 512
-OFP_BSN_HASH_FIELD_SRC_L4_PORT = 1024
-OFP_BSN_HASH_FIELD_DST_L4_PORT = 2048
-OFP_BSN_HASH_FIELD_MPLS_LABEL1 = 4096
-OFP_BSN_HASH_FIELD_MPLS_LABEL2 = 8192
-OFP_BSN_HASH_FIELD_MPLS_LABEL3 = 16384
-OFP_BSN_HASH_FIELD_MPLS_LABEL_HI_BITS = 32768
-OFP_BSN_HASH_FIELD_MPLS_PAYLOAD_SRC_IP = 65536
-OFP_BSN_HASH_FIELD_MPLS_PAYLOAD_DST_IP = 131072
-OFP_BSN_HASH_FIELD_SYMMETRIC = 262144
-
-of_bsn_hash_packet_field_map = {
-    1: 'OFP_BSN_HASH_FIELD_DISABLE',
-    2: 'OFP_BSN_HASH_FIELD_DST_MAC',
-    4: 'OFP_BSN_HASH_FIELD_SRC_MAC',
-    8: 'OFP_BSN_HASH_FIELD_ETH_TYPE',
-    16: 'OFP_BSN_HASH_FIELD_VLAN_ID',
-    32: 'OFP_BSN_HASH_FIELD_INNER_L2',
-    64: 'OFP_BSN_HASH_FIELD_INNER_L3',
-    128: 'OFP_BSN_HASH_FIELD_SRC_IP',
-    256: 'OFP_BSN_HASH_FIELD_DST_IP',
-    512: 'OFP_BSN_HASH_FIELD_IP_PROTO',
-    1024: 'OFP_BSN_HASH_FIELD_SRC_L4_PORT',
-    2048: 'OFP_BSN_HASH_FIELD_DST_L4_PORT',
-    4096: 'OFP_BSN_HASH_FIELD_MPLS_LABEL1',
-    8192: 'OFP_BSN_HASH_FIELD_MPLS_LABEL2',
-    16384: 'OFP_BSN_HASH_FIELD_MPLS_LABEL3',
-    32768: 'OFP_BSN_HASH_FIELD_MPLS_LABEL_HI_BITS',
-    65536: 'OFP_BSN_HASH_FIELD_MPLS_PAYLOAD_SRC_IP',
-    131072: 'OFP_BSN_HASH_FIELD_MPLS_PAYLOAD_DST_IP',
-    262144: 'OFP_BSN_HASH_FIELD_SYMMETRIC',
-}
-
-# Identifiers from group of_bsn_hash_packet_type
-OF_BSN_HASH_PACKET_L2 = 0
-OF_BSN_HASH_PACKET_L2GRE = 1
-OF_BSN_HASH_PACKET_IPV4 = 3
-OF_BSN_HASH_PACKET_IPV6 = 4
-OF_BSN_HASH_PACKET_GTP = 5
-OF_BSN_HASH_PACKET_MPLS = 6
-OF_BSN_HASH_PACKET_SYMMETRIC = 7
-
-of_bsn_hash_packet_type_map = {
-    0: 'OF_BSN_HASH_PACKET_L2',
-    1: 'OF_BSN_HASH_PACKET_L2GRE',
-    3: 'OF_BSN_HASH_PACKET_IPV4',
-    4: 'OF_BSN_HASH_PACKET_IPV6',
-    5: 'OF_BSN_HASH_PACKET_GTP',
-    6: 'OF_BSN_HASH_PACKET_MPLS',
-    7: 'OF_BSN_HASH_PACKET_SYMMETRIC',
-}
-
-# Identifiers from group of_bsn_hash_type
-OFP_BSN_HASH_TYPE_L2 = 0
-OFP_BSN_HASH_TYPE_L3 = 1
-OFP_BSN_HASH_TYPE_ENHANCED = 2
-
-of_bsn_hash_type_map = {
-    0: 'OFP_BSN_HASH_TYPE_L2',
-    1: 'OFP_BSN_HASH_TYPE_L3',
-    2: 'OFP_BSN_HASH_TYPE_ENHANCED',
-}
-
-# Identifiers from group of_bsn_lacp_convergence_status
-LACP_SUCCESS = 0
-LACP_TIMEDOUT = 1
-LACP_OUT_OF_SYNC = 2
-
-of_bsn_lacp_convergence_status_map = {
-    0: 'LACP_SUCCESS',
-    1: 'LACP_TIMEDOUT',
-    2: 'LACP_OUT_OF_SYNC',
-}
-
-# Identifiers from group of_bsn_pdu_slot_num
-BSN_PDU_SLOT_NUM_ANY = 255
-
-of_bsn_pdu_slot_num_map = {
-    255: 'BSN_PDU_SLOT_NUM_ANY',
-}
-
-# Identifiers from group of_bsn_vlan_counter
-OFP_BSN_VLAN_COUNTER_RX_BYTES = 0
-OFP_BSN_VLAN_COUNTER_RX_PACKETS = 1
-OFP_BSN_VLAN_COUNTER_TX_BYTES = 2
-OFP_BSN_VLAN_COUNTER_TX_PACKETS = 3
-
-of_bsn_vlan_counter_map = {
-    0: 'OFP_BSN_VLAN_COUNTER_RX_BYTES',
-    1: 'OFP_BSN_VLAN_COUNTER_RX_PACKETS',
-    2: 'OFP_BSN_VLAN_COUNTER_TX_BYTES',
-    3: 'OFP_BSN_VLAN_COUNTER_TX_PACKETS',
-}
-
-# Identifiers from group of_bsn_vrf_counter
-OFP_BSN_VRF_COUNTER_BYTES = 0
-OFP_BSN_VRF_COUNTER_PACKETS = 1
-
-of_bsn_vrf_counter_map = {
-    0: 'OFP_BSN_VRF_COUNTER_BYTES',
-    1: 'OFP_BSN_VRF_COUNTER_PACKETS',
-}
-
-# Identifiers from group ofp_action_type
-OFPAT_OUTPUT = 0
-OFPAT_COPY_TTL_OUT = 11
-OFPAT_COPY_TTL_IN = 12
-OFPAT_SET_MPLS_TTL = 15
-OFPAT_DEC_MPLS_TTL = 16
-OFPAT_PUSH_VLAN = 17
-OFPAT_POP_VLAN = 18
-OFPAT_PUSH_MPLS = 19
-OFPAT_POP_MPLS = 20
-OFPAT_SET_QUEUE = 21
-OFPAT_GROUP = 22
-OFPAT_SET_NW_TTL = 23
-OFPAT_DEC_NW_TTL = 24
-OFPAT_SET_FIELD = 25
-OFPAT_PUSH_PBB = 26
-OFPAT_POP_PBB = 27
-OFPAT_EXPERIMENTER = 65535
-
-ofp_action_type_map = {
-    0: 'OFPAT_OUTPUT',
-    11: 'OFPAT_COPY_TTL_OUT',
-    12: 'OFPAT_COPY_TTL_IN',
-    15: 'OFPAT_SET_MPLS_TTL',
-    16: 'OFPAT_DEC_MPLS_TTL',
-    17: 'OFPAT_PUSH_VLAN',
-    18: 'OFPAT_POP_VLAN',
-    19: 'OFPAT_PUSH_MPLS',
-    20: 'OFPAT_POP_MPLS',
-    21: 'OFPAT_SET_QUEUE',
-    22: 'OFPAT_GROUP',
-    23: 'OFPAT_SET_NW_TTL',
-    24: 'OFPAT_DEC_NW_TTL',
-    25: 'OFPAT_SET_FIELD',
-    26: 'OFPAT_PUSH_PBB',
-    27: 'OFPAT_POP_PBB',
-    65535: 'OFPAT_EXPERIMENTER',
-}
-
-# Identifiers from group ofp_async_config_failed_code
-OFPACFC_INVALID = 0
-OFPACFC_UNSUPPORTED = 1
-OFPACFC_EPERM = 2
-
-ofp_async_config_failed_code_map = {
-    0: 'OFPACFC_INVALID',
-    1: 'OFPACFC_UNSUPPORTED',
-    2: 'OFPACFC_EPERM',
-}
-
-# Identifiers from group ofp_bad_action_code
-OFPBAC_BAD_TYPE = 0
-OFPBAC_BAD_LEN = 1
-OFPBAC_BAD_EXPERIMENTER = 2
-OFPBAC_BAD_EXPERIMENTER_TYPE = 3
-OFPBAC_BAD_OUT_PORT = 4
-OFPBAC_BAD_ARGUMENT = 5
-OFPBAC_EPERM = 6
-OFPBAC_TOO_MANY = 7
-OFPBAC_BAD_QUEUE = 8
-OFPBAC_BAD_OUT_GROUP = 9
-OFPBAC_MATCH_INCONSISTENT = 10
-OFPBAC_UNSUPPORTED_ORDER = 11
-OFPBAC_BAD_TAG = 12
-OFPBAC_BAD_SET_TYPE = 13
-OFPBAC_BAD_SET_LEN = 14
-OFPBAC_BAD_SET_ARGUMENT = 15
-
-ofp_bad_action_code_map = {
-    0: 'OFPBAC_BAD_TYPE',
-    1: 'OFPBAC_BAD_LEN',
-    2: 'OFPBAC_BAD_EXPERIMENTER',
-    3: 'OFPBAC_BAD_EXPERIMENTER_TYPE',
-    4: 'OFPBAC_BAD_OUT_PORT',
-    5: 'OFPBAC_BAD_ARGUMENT',
-    6: 'OFPBAC_EPERM',
-    7: 'OFPBAC_TOO_MANY',
-    8: 'OFPBAC_BAD_QUEUE',
-    9: 'OFPBAC_BAD_OUT_GROUP',
-    10: 'OFPBAC_MATCH_INCONSISTENT',
-    11: 'OFPBAC_UNSUPPORTED_ORDER',
-    12: 'OFPBAC_BAD_TAG',
-    13: 'OFPBAC_BAD_SET_TYPE',
-    14: 'OFPBAC_BAD_SET_LEN',
-    15: 'OFPBAC_BAD_SET_ARGUMENT',
-}
-
-# Identifiers from group ofp_bad_instruction_code
-OFPBIC_UNKNOWN_INST = 0
-OFPBIC_UNSUP_INST = 1
-OFPBIC_BAD_TABLE_ID = 2
-OFPBIC_UNSUP_METADATA = 3
-OFPBIC_UNSUP_METADATA_MASK = 4
-OFPBIC_BAD_EXPERIMENTER = 5
-OFPBIC_BAD_EXPERIMENTER_TYPE = 6
-OFPBIC_BAD_LEN = 7
-OFPBIC_EPERM = 8
-OFPBIC_DUP_INST = 9
-
-ofp_bad_instruction_code_map = {
-    0: 'OFPBIC_UNKNOWN_INST',
-    1: 'OFPBIC_UNSUP_INST',
-    2: 'OFPBIC_BAD_TABLE_ID',
-    3: 'OFPBIC_UNSUP_METADATA',
-    4: 'OFPBIC_UNSUP_METADATA_MASK',
-    5: 'OFPBIC_BAD_EXPERIMENTER',
-    6: 'OFPBIC_BAD_EXPERIMENTER_TYPE',
-    7: 'OFPBIC_BAD_LEN',
-    8: 'OFPBIC_EPERM',
-    9: 'OFPBIC_DUP_INST',
-}
-
-# Identifiers from group ofp_bad_match_code
-OFPBMC_BAD_TYPE = 0
-OFPBMC_BAD_LEN = 1
-OFPBMC_BAD_TAG = 2
-OFPBMC_BAD_DL_ADDR_MASK = 3
-OFPBMC_BAD_NW_ADDR_MASK = 4
-OFPBMC_BAD_WILDCARDS = 5
-OFPBMC_BAD_FIELD = 6
-OFPBMC_BAD_VALUE = 7
-OFPBMC_BAD_MASK = 8
-OFPBMC_BAD_PREREQ = 9
-OFPBMC_DUP_FIELD = 10
-OFPBMC_EPERM = 11
-
-ofp_bad_match_code_map = {
-    0: 'OFPBMC_BAD_TYPE',
-    1: 'OFPBMC_BAD_LEN',
-    2: 'OFPBMC_BAD_TAG',
-    3: 'OFPBMC_BAD_DL_ADDR_MASK',
-    4: 'OFPBMC_BAD_NW_ADDR_MASK',
-    5: 'OFPBMC_BAD_WILDCARDS',
-    6: 'OFPBMC_BAD_FIELD',
-    7: 'OFPBMC_BAD_VALUE',
-    8: 'OFPBMC_BAD_MASK',
-    9: 'OFPBMC_BAD_PREREQ',
-    10: 'OFPBMC_DUP_FIELD',
-    11: 'OFPBMC_EPERM',
-}
-
-# Identifiers from group ofp_bad_property_code
-OFPBPC_BAD_TYPE = 0
-OFPBPC_BAD_LEN = 1
-OFPBPC_BAD_VALUE = 2
-OFPBPC_TOO_MANY = 3
-OFPBPC_DUP_TYPE = 4
-OFPBPC_BAD_EXPERIMENTER = 5
-OFPBPC_BAD_EXP_TYPE = 6
-OFPBPC_BAD_EXP_VALUE = 7
-OFPBPC_EPERM = 8
-
-ofp_bad_property_code_map = {
-    0: 'OFPBPC_BAD_TYPE',
-    1: 'OFPBPC_BAD_LEN',
-    2: 'OFPBPC_BAD_VALUE',
-    3: 'OFPBPC_TOO_MANY',
-    4: 'OFPBPC_DUP_TYPE',
-    5: 'OFPBPC_BAD_EXPERIMENTER',
-    6: 'OFPBPC_BAD_EXP_TYPE',
-    7: 'OFPBPC_BAD_EXP_VALUE',
-    8: 'OFPBPC_EPERM',
-}
-
-# Identifiers from group ofp_bad_request_code
-OFPBRC_BAD_VERSION = 0
-OFPBRC_BAD_TYPE = 1
-OFPBRC_BAD_STAT = 2
-OFPBRC_BAD_EXPERIMENTER = 3
-OFPBRC_BAD_EXPERIMENTER_TYPE = 4
-OFPBRC_EPERM = 5
-OFPBRC_BAD_LEN = 6
-OFPBRC_BUFFER_EMPTY = 7
-OFPBRC_BUFFER_UNKNOWN = 8
-OFPBRC_BAD_TABLE_ID = 9
-OFPBRC_IS_SLAVE = 10
-OFPBRC_BAD_PORT = 11
-OFPBRC_BAD_PACKET = 12
-OFPBRC_MULTIPART_BUFFER_OVERFLOW = 13
-OFPBRC_MULTIPART_REQUEST_TIMEOUT = 14
-OFPBRC_MULTIPART_REPLY_TIMEOUT = 15
-
-ofp_bad_request_code_map = {
-    0: 'OFPBRC_BAD_VERSION',
-    1: 'OFPBRC_BAD_TYPE',
-    2: 'OFPBRC_BAD_STAT',
-    3: 'OFPBRC_BAD_EXPERIMENTER',
-    4: 'OFPBRC_BAD_EXPERIMENTER_TYPE',
-    5: 'OFPBRC_EPERM',
-    6: 'OFPBRC_BAD_LEN',
-    7: 'OFPBRC_BUFFER_EMPTY',
-    8: 'OFPBRC_BUFFER_UNKNOWN',
-    9: 'OFPBRC_BAD_TABLE_ID',
-    10: 'OFPBRC_IS_SLAVE',
-    11: 'OFPBRC_BAD_PORT',
-    12: 'OFPBRC_BAD_PACKET',
-    13: 'OFPBRC_MULTIPART_BUFFER_OVERFLOW',
-    14: 'OFPBRC_MULTIPART_REQUEST_TIMEOUT',
-    15: 'OFPBRC_MULTIPART_REPLY_TIMEOUT',
-}
-
-# Identifiers from group ofp_bsn_anchor
-OFP_BSN_ANCHOR_PACKET_START = 0
-OFP_BSN_ANCHOR_L3_HEADER_START = 1
-OFP_BSN_ANCHOR_L4_HEADER_START = 2
-OFP_BSN_ANCHOR_L4_PAYLOAD_START = 3
-
-ofp_bsn_anchor_map = {
-    0: 'OFP_BSN_ANCHOR_PACKET_START',
-    1: 'OFP_BSN_ANCHOR_L3_HEADER_START',
-    2: 'OFP_BSN_ANCHOR_L4_HEADER_START',
-    3: 'OFP_BSN_ANCHOR_L4_PAYLOAD_START',
-}
-
-# Identifiers from group ofp_bsn_controller_connection_state
-OFP_BSN_CONTROLLER_CONNECTION_STATE_DISCONNECTED = 0
-OFP_BSN_CONTROLLER_CONNECTION_STATE_CONNECTED = 1
-
-ofp_bsn_controller_connection_state_map = {
-    0: 'OFP_BSN_CONTROLLER_CONNECTION_STATE_DISCONNECTED',
-    1: 'OFP_BSN_CONTROLLER_CONNECTION_STATE_CONNECTED',
-}
-
-# Identifiers from group ofp_bsn_decap
-OFP_BSN_DECAP_VXLAN = 0
-OFP_BSN_DECAP_ERSPAN = 1
-OFP_BSN_DECAP_L2_GRE = 2
-OFP_BSN_DECAP_NVGRE = 3
-OFP_BSN_DECAP_CAPWAP = 4
-OFP_BSN_DECAP_L2_MPLS = 5
-OFP_BSN_DECAP_L3_GRE = 6
-OFP_BSN_DECAP_GTP = 7
-OFP_BSN_DECAP_L3_MPLS = 8
-
-ofp_bsn_decap_map = {
-    0: 'OFP_BSN_DECAP_VXLAN',
-    1: 'OFP_BSN_DECAP_ERSPAN',
-    2: 'OFP_BSN_DECAP_L2_GRE',
-    3: 'OFP_BSN_DECAP_NVGRE',
-    4: 'OFP_BSN_DECAP_CAPWAP',
-    5: 'OFP_BSN_DECAP_L2_MPLS',
-    6: 'OFP_BSN_DECAP_L3_GRE',
-    7: 'OFP_BSN_DECAP_GTP',
-    8: 'OFP_BSN_DECAP_L3_MPLS',
-}
-
-# Identifiers from group ofp_bsn_lacp_state
-OFP_BSN_LACP_STATE_ACTIVITY = 1
-OFP_BSN_LACP_STATE_TIMEOUT = 2
-OFP_BSN_LACP_STATE_AGGREGATION = 4
-OFP_BSN_LACP_STATE_SYNCHRONIZATION = 8
-OFP_BSN_LACP_STATE_COLLECTING = 16
-OFP_BSN_LACP_STATE_DISTRIBUTING = 32
-OFP_BSN_LACP_STATE_DEFAULTED = 64
-OFP_BSN_LACP_STATE_EXPIRED = 128
-
-ofp_bsn_lacp_state_map = {
-    1: 'OFP_BSN_LACP_STATE_ACTIVITY',
-    2: 'OFP_BSN_LACP_STATE_TIMEOUT',
-    4: 'OFP_BSN_LACP_STATE_AGGREGATION',
-    8: 'OFP_BSN_LACP_STATE_SYNCHRONIZATION',
-    16: 'OFP_BSN_LACP_STATE_COLLECTING',
-    32: 'OFP_BSN_LACP_STATE_DISTRIBUTING',
-    64: 'OFP_BSN_LACP_STATE_DEFAULTED',
-    128: 'OFP_BSN_LACP_STATE_EXPIRED',
-}
-
-# Identifiers from group ofp_bsn_loglevel
-OFP_BSN_LOGLEVEL_MSG = 0
-OFP_BSN_LOGLEVEL_ERROR = 1
-OFP_BSN_LOGLEVEL_WARN = 2
-OFP_BSN_LOGLEVEL_INFO = 3
-OFP_BSN_LOGLEVEL_VERBOSE = 4
-OFP_BSN_LOGLEVEL_TRACE = 5
-
-ofp_bsn_loglevel_map = {
-    0: 'OFP_BSN_LOGLEVEL_MSG',
-    1: 'OFP_BSN_LOGLEVEL_ERROR',
-    2: 'OFP_BSN_LOGLEVEL_WARN',
-    3: 'OFP_BSN_LOGLEVEL_INFO',
-    4: 'OFP_BSN_LOGLEVEL_VERBOSE',
-    5: 'OFP_BSN_LOGLEVEL_TRACE',
-}
-
-# Identifiers from group ofp_bsn_lua_upload_flags
-OFP_BSN_LUA_UPLOAD_MORE = 1
-OFP_BSN_LUA_UPLOAD_FORCE = 2
-
-ofp_bsn_lua_upload_flags_map = {
-    1: 'OFP_BSN_LUA_UPLOAD_MORE',
-    2: 'OFP_BSN_LUA_UPLOAD_FORCE',
-}
-
-# Identifiers from group ofp_bsn_pktin_flag
-OFP_BSN_PKTIN_FLAG_PDU = 1
-OFP_BSN_PKTIN_FLAG_NEW_HOST = 2
-OFP_BSN_PKTIN_FLAG_STATION_MOVE = 4
-OFP_BSN_PKTIN_FLAG_ARP = 8
-OFP_BSN_PKTIN_FLAG_DHCP = 16
-OFP_BSN_PKTIN_FLAG_L2_CPU = 32
-OFP_BSN_PKTIN_FLAG_DEBUG = 64
-OFP_BSN_PKTIN_FLAG_TTL_EXPIRED = 128
-OFP_BSN_PKTIN_FLAG_L3_MISS = 256
-OFP_BSN_PKTIN_FLAG_L3_CPU = 512
-OFP_BSN_PKTIN_FLAG_INGRESS_ACL = 1024
-OFP_BSN_PKTIN_FLAG_SFLOW = 2048
-OFP_BSN_PKTIN_FLAG_ARP_CACHE = 4096
-OFP_BSN_PKTIN_FLAG_ARP_TARGET = 8192
-OFP_BSN_PKTIN_FLAG_IGMP = 16384
-OFP_BSN_PKTIN_FLAG_PIM = 32768
-OFP_BSN_PKTIN_FLAG_VXLAN_SIP_MISS = 65536
-OFP_BSN_PKTIN_FLAG_MC_RESERVED = 131072
-
-ofp_bsn_pktin_flag_map = {
-    1: 'OFP_BSN_PKTIN_FLAG_PDU',
-    2: 'OFP_BSN_PKTIN_FLAG_NEW_HOST',
-    4: 'OFP_BSN_PKTIN_FLAG_STATION_MOVE',
-    8: 'OFP_BSN_PKTIN_FLAG_ARP',
-    16: 'OFP_BSN_PKTIN_FLAG_DHCP',
-    32: 'OFP_BSN_PKTIN_FLAG_L2_CPU',
-    64: 'OFP_BSN_PKTIN_FLAG_DEBUG',
-    128: 'OFP_BSN_PKTIN_FLAG_TTL_EXPIRED',
-    256: 'OFP_BSN_PKTIN_FLAG_L3_MISS',
-    512: 'OFP_BSN_PKTIN_FLAG_L3_CPU',
-    1024: 'OFP_BSN_PKTIN_FLAG_INGRESS_ACL',
-    2048: 'OFP_BSN_PKTIN_FLAG_SFLOW',
-    4096: 'OFP_BSN_PKTIN_FLAG_ARP_CACHE',
-    8192: 'OFP_BSN_PKTIN_FLAG_ARP_TARGET',
-    16384: 'OFP_BSN_PKTIN_FLAG_IGMP',
-    32768: 'OFP_BSN_PKTIN_FLAG_PIM',
-    65536: 'OFP_BSN_PKTIN_FLAG_VXLAN_SIP_MISS',
-    131072: 'OFP_BSN_PKTIN_FLAG_MC_RESERVED',
-}
-
-# Identifiers from group ofp_bsn_port_counter
-OFP_BSN_PORT_COUNTER_RX_BYTES = 0
-OFP_BSN_PORT_COUNTER_RX_PACKETS_UNICAST = 1
-OFP_BSN_PORT_COUNTER_RX_PACKETS_BROADCAST = 2
-OFP_BSN_PORT_COUNTER_RX_PACKETS_MULTICAST = 3
-OFP_BSN_PORT_COUNTER_RX_DROPPED = 4
-OFP_BSN_PORT_COUNTER_RX_ERRORS = 5
-OFP_BSN_PORT_COUNTER_TX_BYTES = 6
-OFP_BSN_PORT_COUNTER_TX_PACKETS_UNICAST = 7
-OFP_BSN_PORT_COUNTER_TX_PACKETS_BROADCAST = 8
-OFP_BSN_PORT_COUNTER_TX_PACKETS_MULTICAST = 9
-OFP_BSN_PORT_COUNTER_TX_DROPPED = 10
-OFP_BSN_PORT_COUNTER_TX_ERRORS = 11
-OFP_BSN_PORT_COUNTER_RX_RUNTS = 12
-OFP_BSN_PORT_COUNTER_RX_GIANTS = 13
-OFP_BSN_PORT_COUNTER_RX_CRC_ERRORS = 14
-OFP_BSN_PORT_COUNTER_RX_ALIGNMENT_ERRORS = 15
-OFP_BSN_PORT_COUNTER_RX_SYMBOL_ERRORS = 16
-OFP_BSN_PORT_COUNTER_RX_PAUSE_INPUT = 17
-OFP_BSN_PORT_COUNTER_TX_COLLISIONS = 18
-OFP_BSN_PORT_COUNTER_TX_LATE_COLLISIONS = 19
-OFP_BSN_PORT_COUNTER_TX_DEFERRED = 20
-OFP_BSN_PORT_COUNTER_TX_PAUSE_OUTPUT = 21
-OFP_BSN_PORT_COUNTER_RX_PACKETS = 22
-OFP_BSN_PORT_COUNTER_TX_PACKETS = 23
-OFP_BSN_PORT_COUNTER_RX_LENGTH_ERRORS = 24
-OFP_BSN_PORT_COUNTER_RX_OVERFLOW_ERRORS = 25
-OFP_BSN_PORT_COUNTER_TX_CARRIER_ERRORS = 26
-OFP_BSN_PORT_COUNTER_RX_PACKETS_BAD_VLAN = 27
-OFP_BSN_PORT_COUNTER_LINK_UP = 28
-OFP_BSN_PORT_COUNTER_LINK_DOWN = 29
-
-ofp_bsn_port_counter_map = {
-    0: 'OFP_BSN_PORT_COUNTER_RX_BYTES',
-    1: 'OFP_BSN_PORT_COUNTER_RX_PACKETS_UNICAST',
-    2: 'OFP_BSN_PORT_COUNTER_RX_PACKETS_BROADCAST',
-    3: 'OFP_BSN_PORT_COUNTER_RX_PACKETS_MULTICAST',
-    4: 'OFP_BSN_PORT_COUNTER_RX_DROPPED',
-    5: 'OFP_BSN_PORT_COUNTER_RX_ERRORS',
-    6: 'OFP_BSN_PORT_COUNTER_TX_BYTES',
-    7: 'OFP_BSN_PORT_COUNTER_TX_PACKETS_UNICAST',
-    8: 'OFP_BSN_PORT_COUNTER_TX_PACKETS_BROADCAST',
-    9: 'OFP_BSN_PORT_COUNTER_TX_PACKETS_MULTICAST',
-    10: 'OFP_BSN_PORT_COUNTER_TX_DROPPED',
-    11: 'OFP_BSN_PORT_COUNTER_TX_ERRORS',
-    12: 'OFP_BSN_PORT_COUNTER_RX_RUNTS',
-    13: 'OFP_BSN_PORT_COUNTER_RX_GIANTS',
-    14: 'OFP_BSN_PORT_COUNTER_RX_CRC_ERRORS',
-    15: 'OFP_BSN_PORT_COUNTER_RX_ALIGNMENT_ERRORS',
-    16: 'OFP_BSN_PORT_COUNTER_RX_SYMBOL_ERRORS',
-    17: 'OFP_BSN_PORT_COUNTER_RX_PAUSE_INPUT',
-    18: 'OFP_BSN_PORT_COUNTER_TX_COLLISIONS',
-    19: 'OFP_BSN_PORT_COUNTER_TX_LATE_COLLISIONS',
-    20: 'OFP_BSN_PORT_COUNTER_TX_DEFERRED',
-    21: 'OFP_BSN_PORT_COUNTER_TX_PAUSE_OUTPUT',
-    22: 'OFP_BSN_PORT_COUNTER_RX_PACKETS',
-    23: 'OFP_BSN_PORT_COUNTER_TX_PACKETS',
-    24: 'OFP_BSN_PORT_COUNTER_RX_LENGTH_ERRORS',
-    25: 'OFP_BSN_PORT_COUNTER_RX_OVERFLOW_ERRORS',
-    26: 'OFP_BSN_PORT_COUNTER_TX_CARRIER_ERRORS',
-    27: 'OFP_BSN_PORT_COUNTER_RX_PACKETS_BAD_VLAN',
-    28: 'OFP_BSN_PORT_COUNTER_LINK_UP',
-    29: 'OFP_BSN_PORT_COUNTER_LINK_DOWN',
-}
-
-# Identifiers from group ofp_bsn_port_vxlan_mode
-OFP_BSN_PORT_VXLAN_RECIRCULATION_ENABLE = 0
-OFP_BSN_PORT_VXLAN_TERMINATION_ENABLE = 1
-
-ofp_bsn_port_vxlan_mode_map = {
-    0: 'OFP_BSN_PORT_VXLAN_RECIRCULATION_ENABLE',
-    1: 'OFP_BSN_PORT_VXLAN_TERMINATION_ENABLE',
-}
-
-# Identifiers from group ofp_bsn_rate_unit
-OFP_BSN_RATE_UNIT_PPS = 0
-OFP_BSN_RATE_UNIT_KBITPS = 1
-
-ofp_bsn_rate_unit_map = {
-    0: 'OFP_BSN_RATE_UNIT_PPS',
-    1: 'OFP_BSN_RATE_UNIT_KBITPS',
-}
-
-# Identifiers from group ofp_bsn_status
-OFP_BSN_STATUS_DISABLE = 0
-OFP_BSN_STATUS_ENABLE = 1
-
-ofp_bsn_status_map = {
-    0: 'OFP_BSN_STATUS_DISABLE',
-    1: 'OFP_BSN_STATUS_ENABLE',
-}
-
-# Identifiers from group ofp_bsn_tcp_flag
-OFP_BSN_TCP_FLAG_FIN = 1
-OFP_BSN_TCP_FLAG_SYN = 2
-OFP_BSN_TCP_FLAG_RST = 4
-OFP_BSN_TCP_FLAG_PSH = 8
-OFP_BSN_TCP_FLAG_ACK = 16
-OFP_BSN_TCP_FLAG_URG = 32
-OFP_BSN_TCP_FLAG_ECE = 64
-OFP_BSN_TCP_FLAG_CWR = 128
-OFP_BSN_TCP_FLAG_NS = 256
-
-ofp_bsn_tcp_flag_map = {
-    1: 'OFP_BSN_TCP_FLAG_FIN',
-    2: 'OFP_BSN_TCP_FLAG_SYN',
-    4: 'OFP_BSN_TCP_FLAG_RST',
-    8: 'OFP_BSN_TCP_FLAG_PSH',
-    16: 'OFP_BSN_TCP_FLAG_ACK',
-    32: 'OFP_BSN_TCP_FLAG_URG',
-    64: 'OFP_BSN_TCP_FLAG_ECE',
-    128: 'OFP_BSN_TCP_FLAG_CWR',
-    256: 'OFP_BSN_TCP_FLAG_NS',
-}
-
-# Identifiers from group ofp_bsn_udf_anchor
-OFP_BSN_UDF_ANCHOR_PACKET_START = 0
-OFP_BSN_UDF_ANCHOR_L3_HEADER_START = 1
-OFP_BSN_UDF_ANCHOR_L4_HEADER_START = 2
-
-ofp_bsn_udf_anchor_map = {
-    0: 'OFP_BSN_UDF_ANCHOR_PACKET_START',
-    1: 'OFP_BSN_UDF_ANCHOR_L3_HEADER_START',
-    2: 'OFP_BSN_UDF_ANCHOR_L4_HEADER_START',
-}
-
-# Identifiers from group ofp_bsn_vlan_counter_constants
-OFP_BSN_VLAN_ALL = 65535
-
-ofp_bsn_vlan_counter_constants_map = {
-    65535: 'OFP_BSN_VLAN_ALL',
-}
-
-# Identifiers from group ofp_bsn_vport_l2gre_flags
-OF_BSN_VPORT_L2GRE_LOCAL_MAC_IS_VALID = 1
-OF_BSN_VPORT_L2GRE_DSCP_ASSIGN = 2
-OF_BSN_VPORT_L2GRE_DSCP_COPY = 4
-OF_BSN_VPORT_L2GRE_LOOPBACK_IS_VALID = 8
-OF_BSN_VPORT_L2GRE_RATE_LIMIT_IS_VALID = 16
-
-ofp_bsn_vport_l2gre_flags_map = {
-    1: 'OF_BSN_VPORT_L2GRE_LOCAL_MAC_IS_VALID',
-    2: 'OF_BSN_VPORT_L2GRE_DSCP_ASSIGN',
-    4: 'OF_BSN_VPORT_L2GRE_DSCP_COPY',
-    8: 'OF_BSN_VPORT_L2GRE_LOOPBACK_IS_VALID',
-    16: 'OF_BSN_VPORT_L2GRE_RATE_LIMIT_IS_VALID',
-}
-
-# Identifiers from group ofp_bsn_vport_q_in_q_untagged
-OF_BSN_VPORT_Q_IN_Q_UNTAGGED = 65535
-
-ofp_bsn_vport_q_in_q_untagged_map = {
-    65535: 'OF_BSN_VPORT_Q_IN_Q_UNTAGGED',
-}
-
-# Identifiers from group ofp_bsn_vport_status
-OF_BSN_VPORT_STATUS_OK = 0
-OF_BSN_VPORT_STATUS_FAILED = 1
-
-ofp_bsn_vport_status_map = {
-    0: 'OF_BSN_VPORT_STATUS_OK',
-    1: 'OF_BSN_VPORT_STATUS_FAILED',
-}
-
-# Identifiers from group ofp_bsn_vrf_counter_constants
-OFP_BSN_VRF_ALL = 4294967295
-
-ofp_bsn_vrf_counter_constants_map = {
-    4294967295: 'OFP_BSN_VRF_ALL',
-}
-
-# Identifiers from group ofp_bundle_ctrl_type
-OFPBCT_OPEN_REQUEST = 0
-OFPBCT_OPEN_REPLY = 1
-OFPBCT_CLOSE_REQUEST = 2
-OFPBCT_CLOSE_REPLY = 3
-OFPBCT_COMMIT_REQUEST = 4
-OFPBCT_COMMIT_REPLY = 5
-OFPBCT_DISCARD_REQUEST = 6
-OFPBCT_DISCARD_REPLY = 7
-
-ofp_bundle_ctrl_type_map = {
-    0: 'OFPBCT_OPEN_REQUEST',
-    1: 'OFPBCT_OPEN_REPLY',
-    2: 'OFPBCT_CLOSE_REQUEST',
-    3: 'OFPBCT_CLOSE_REPLY',
-    4: 'OFPBCT_COMMIT_REQUEST',
-    5: 'OFPBCT_COMMIT_REPLY',
-    6: 'OFPBCT_DISCARD_REQUEST',
-    7: 'OFPBCT_DISCARD_REPLY',
-}
-
-# Identifiers from group ofp_bundle_failed_code
-OFPBFC_UNKNOWN = 0
-OFPBFC_EPERM = 1
-OFPBFC_BAD_ID = 2
-OFPBFC_BUNDLE_EXIST = 3
-OFPBFC_BUNDLE_CLOSED = 4
-OFPBFC_OUT_OF_BUNDLES = 5
-OFPBFC_BAD_TYPE = 6
-OFPBFC_BAD_FLAGS = 7
-OFPBFC_MSG_BAD_LEN = 8
-OFPBFC_MSG_BAD_XID = 9
-OFPBFC_MSG_UNSUP = 10
-OFPBFC_MSG_CONFLICT = 11
-OFPBFC_MSG_TOO_MANY = 12
-OFPBFC_MSG_FAILED = 13
-OFPBFC_TIMEOUT = 14
-OFPBFC_BUNDLE_IN_PROGRESS = 15
-
-ofp_bundle_failed_code_map = {
-    0: 'OFPBFC_UNKNOWN',
-    1: 'OFPBFC_EPERM',
-    2: 'OFPBFC_BAD_ID',
-    3: 'OFPBFC_BUNDLE_EXIST',
-    4: 'OFPBFC_BUNDLE_CLOSED',
-    5: 'OFPBFC_OUT_OF_BUNDLES',
-    6: 'OFPBFC_BAD_TYPE',
-    7: 'OFPBFC_BAD_FLAGS',
-    8: 'OFPBFC_MSG_BAD_LEN',
-    9: 'OFPBFC_MSG_BAD_XID',
-    10: 'OFPBFC_MSG_UNSUP',
-    11: 'OFPBFC_MSG_CONFLICT',
-    12: 'OFPBFC_MSG_TOO_MANY',
-    13: 'OFPBFC_MSG_FAILED',
-    14: 'OFPBFC_TIMEOUT',
-    15: 'OFPBFC_BUNDLE_IN_PROGRESS',
-}
-
-# Identifiers from group ofp_bundle_flags
-OFPBF_ATOMIC = 1
-OFPBF_ORDERED = 2
-
-ofp_bundle_flags_map = {
-    1: 'OFPBF_ATOMIC',
-    2: 'OFPBF_ORDERED',
-}
-
-# Identifiers from group ofp_capabilities
-OFPC_FLOW_STATS = 1
-OFPC_TABLE_STATS = 2
-OFPC_PORT_STATS = 4
-OFPC_GROUP_STATS = 8
-OFPC_IP_REASM = 32
-OFPC_QUEUE_STATS = 64
-OFPC_PORT_BLOCKED = 256
-
-ofp_capabilities_map = {
-    1: 'OFPC_FLOW_STATS',
-    2: 'OFPC_TABLE_STATS',
-    4: 'OFPC_PORT_STATS',
-    8: 'OFPC_GROUP_STATS',
-    32: 'OFPC_IP_REASM',
-    64: 'OFPC_QUEUE_STATS',
-    256: 'OFPC_PORT_BLOCKED',
-}
-
-# Identifiers from group ofp_config_flags
-OFPC_FRAG_NORMAL = 0
-OFPC_FRAG_DROP = 1
-OFPC_FRAG_REASM = 2
-OFPC_FRAG_MASK = 3
-
-ofp_config_flags_map = {
-    0: 'OFPC_FRAG_NORMAL',
-    1: 'OFPC_FRAG_DROP',
-    2: 'OFPC_FRAG_REASM',
-    3: 'OFPC_FRAG_MASK',
-}
-
-# Identifiers from group ofp_controller_max_len
-OFPCML_MAX = 65509
-OFPCML_NO_BUFFER = 65535
-
-ofp_controller_max_len_map = {
-    65509: 'OFPCML_MAX',
-    65535: 'OFPCML_NO_BUFFER',
-}
-
-# Identifiers from group ofp_controller_role
-OFPCR_ROLE_NOCHANGE = 0
-OFPCR_ROLE_EQUAL = 1
-OFPCR_ROLE_MASTER = 2
-OFPCR_ROLE_SLAVE = 3
-
-ofp_controller_role_map = {
-    0: 'OFPCR_ROLE_NOCHANGE',
-    1: 'OFPCR_ROLE_EQUAL',
-    2: 'OFPCR_ROLE_MASTER',
-    3: 'OFPCR_ROLE_SLAVE',
-}
-
-# Identifiers from group ofp_controller_role_reason
-OFPCRR_MASTER_REQUEST = 0
-OFPCRR_CONFIG = 1
-OFPCRR_EXPERIMENTER = 2
-
-ofp_controller_role_reason_map = {
-    0: 'OFPCRR_MASTER_REQUEST',
-    1: 'OFPCRR_CONFIG',
-    2: 'OFPCRR_EXPERIMENTER',
-}
-
-# Identifiers from group ofp_error_type
-OFPET_HELLO_FAILED = 0
-OFPET_BAD_REQUEST = 1
-OFPET_BAD_ACTION = 2
-OFPET_BAD_INSTRUCTION = 3
-OFPET_BAD_MATCH = 4
-OFPET_FLOW_MOD_FAILED = 5
-OFPET_GROUP_MOD_FAILED = 6
-OFPET_PORT_MOD_FAILED = 7
-OFPET_TABLE_MOD_FAILED = 8
-OFPET_QUEUE_OP_FAILED = 9
-OFPET_SWITCH_CONFIG_FAILED = 10
-OFPET_ROLE_REQUEST_FAILED = 11
-OFPET_METER_MOD_FAILED = 12
-OFPET_TABLE_FEATURES_FAILED = 13
-OFPET_BAD_PROPERTY = 14
-OFPET_ASYNC_CONFIG_FAILED = 15
-OFPET_FLOW_MONITOR_FAILED = 16
-OFPET_BUNDLE_FAILED = 17
-OFPET_EXPERIMENTER = 65535
-
-ofp_error_type_map = {
-    0: 'OFPET_HELLO_FAILED',
-    1: 'OFPET_BAD_REQUEST',
-    2: 'OFPET_BAD_ACTION',
-    3: 'OFPET_BAD_INSTRUCTION',
-    4: 'OFPET_BAD_MATCH',
-    5: 'OFPET_FLOW_MOD_FAILED',
-    6: 'OFPET_GROUP_MOD_FAILED',
-    7: 'OFPET_PORT_MOD_FAILED',
-    8: 'OFPET_TABLE_MOD_FAILED',
-    9: 'OFPET_QUEUE_OP_FAILED',
-    10: 'OFPET_SWITCH_CONFIG_FAILED',
-    11: 'OFPET_ROLE_REQUEST_FAILED',
-    12: 'OFPET_METER_MOD_FAILED',
-    13: 'OFPET_TABLE_FEATURES_FAILED',
-    14: 'OFPET_BAD_PROPERTY',
-    15: 'OFPET_ASYNC_CONFIG_FAILED',
-    16: 'OFPET_FLOW_MONITOR_FAILED',
-    17: 'OFPET_BUNDLE_FAILED',
-    65535: 'OFPET_EXPERIMENTER',
-}
-
-# Identifiers from group ofp_flow_mod_command
-OFPFC_ADD = 0
-OFPFC_MODIFY = 1
-OFPFC_MODIFY_STRICT = 2
-OFPFC_DELETE = 3
-OFPFC_DELETE_STRICT = 4
-
-ofp_flow_mod_command_map = {
-    0: 'OFPFC_ADD',
-    1: 'OFPFC_MODIFY',
-    2: 'OFPFC_MODIFY_STRICT',
-    3: 'OFPFC_DELETE',
-    4: 'OFPFC_DELETE_STRICT',
-}
-
-# Identifiers from group ofp_flow_mod_failed_code
-OFPFMFC_UNKNOWN = 0
-OFPFMFC_TABLE_FULL = 1
-OFPFMFC_BAD_TABLE_ID = 2
-OFPFMFC_OVERLAP = 3
-OFPFMFC_EPERM = 4
-OFPFMFC_BAD_TIMEOUT = 5
-OFPFMFC_BAD_COMMAND = 6
-OFPFMFC_BAD_FLAGS = 7
-OFPFMFC_CANT_SYNC = 8
-OFPFMFC_BAD_PRIORITY = 9
-
-ofp_flow_mod_failed_code_map = {
-    0: 'OFPFMFC_UNKNOWN',
-    1: 'OFPFMFC_TABLE_FULL',
-    2: 'OFPFMFC_BAD_TABLE_ID',
-    3: 'OFPFMFC_OVERLAP',
-    4: 'OFPFMFC_EPERM',
-    5: 'OFPFMFC_BAD_TIMEOUT',
-    6: 'OFPFMFC_BAD_COMMAND',
-    7: 'OFPFMFC_BAD_FLAGS',
-    8: 'OFPFMFC_CANT_SYNC',
-    9: 'OFPFMFC_BAD_PRIORITY',
-}
-
-# Identifiers from group ofp_flow_mod_flags
-OFPFF_SEND_FLOW_REM = 1
-OFPFF_CHECK_OVERLAP = 2
-OFPFF_RESET_COUNTS = 4
-OFPFF_NO_PKT_COUNTS = 8
-OFPFF_NO_BYT_COUNTS = 16
-OFPFF_BSN_SEND_IDLE = 128
-
-ofp_flow_mod_flags_map = {
-    1: 'OFPFF_SEND_FLOW_REM',
-    2: 'OFPFF_CHECK_OVERLAP',
-    4: 'OFPFF_RESET_COUNTS',
-    8: 'OFPFF_NO_PKT_COUNTS',
-    16: 'OFPFF_NO_BYT_COUNTS',
-    128: 'OFPFF_BSN_SEND_IDLE',
-}
-
-# Identifiers from group ofp_flow_monitor_failed_code
-OFPMOFC_UNKNOWN = 0
-OFPMOFC_MONITOR_EXISTS = 1
-OFPMOFC_INVALID_MONITOR = 2
-OFPMOFC_UNKNOWN_MONITOR = 3
-OFPMOFC_BAD_COMMAND = 4
-OFPMOFC_BAD_FLAGS = 5
-OFPMOFC_BAD_TABLE_ID = 6
-OFPMOFC_BAD_OUT = 7
-
-ofp_flow_monitor_failed_code_map = {
-    0: 'OFPMOFC_UNKNOWN',
-    1: 'OFPMOFC_MONITOR_EXISTS',
-    2: 'OFPMOFC_INVALID_MONITOR',
-    3: 'OFPMOFC_UNKNOWN_MONITOR',
-    4: 'OFPMOFC_BAD_COMMAND',
-    5: 'OFPMOFC_BAD_FLAGS',
-    6: 'OFPMOFC_BAD_TABLE_ID',
-    7: 'OFPMOFC_BAD_OUT',
-}
-
-# Identifiers from group ofp_flow_removed_reason
-OFPRR_IDLE_TIMEOUT = 0
-OFPRR_HARD_TIMEOUT = 1
-OFPRR_DELETE = 2
-OFPRR_GROUP_DELETE = 3
-OFPRR_METER_DELETE = 4
-OFPRR_EVICTION = 5
-
-ofp_flow_removed_reason_map = {
-    0: 'OFPRR_IDLE_TIMEOUT',
-    1: 'OFPRR_HARD_TIMEOUT',
-    2: 'OFPRR_DELETE',
-    3: 'OFPRR_GROUP_DELETE',
-    4: 'OFPRR_METER_DELETE',
-    5: 'OFPRR_EVICTION',
-}
-
-# Identifiers from group ofp_group
-OFPG_MAX = 4294967040
-OFPG_ALL = 4294967292
-OFPG_ANY = 4294967295
-
-ofp_group_map = {
-    4294967040: 'OFPG_MAX',
-    4294967292: 'OFPG_ALL',
-    4294967295: 'OFPG_ANY',
-}
-
-# Identifiers from group ofp_group_capabilities
-OFPGFC_SELECT_WEIGHT = 1
-OFPGFC_SELECT_LIVENESS = 2
-OFPGFC_CHAINING = 4
-OFPGFC_CHAINING_CHECKS = 8
-
-ofp_group_capabilities_map = {
-    1: 'OFPGFC_SELECT_WEIGHT',
-    2: 'OFPGFC_SELECT_LIVENESS',
-    4: 'OFPGFC_CHAINING',
-    8: 'OFPGFC_CHAINING_CHECKS',
-}
-
-# Identifiers from group ofp_group_mod_command
-OFPGC_ADD = 0
-OFPGC_MODIFY = 1
-OFPGC_DELETE = 2
-
-ofp_group_mod_command_map = {
-    0: 'OFPGC_ADD',
-    1: 'OFPGC_MODIFY',
-    2: 'OFPGC_DELETE',
-}
-
-# Identifiers from group ofp_group_mod_failed_code
-OFPGMFC_GROUP_EXISTS = 0
-OFPGMFC_INVALID_GROUP = 1
-OFPGMFC_WEIGHT_UNSUPPORTED = 2
-OFPGMFC_OUT_OF_GROUPS = 3
-OFPGMFC_OUT_OF_BUCKETS = 4
-OFPGMFC_CHAINING_UNSUPPORTED = 5
-OFPGMFC_WATCH_UNSUPPORTED = 6
-OFPGMFC_LOOP = 7
-OFPGMFC_UNKNOWN_GROUP = 8
-OFPGMFC_CHAINED_GROUP = 9
-OFPGMFC_BAD_TYPE = 10
-OFPGMFC_BAD_COMMAND = 11
-OFPGMFC_BAD_BUCKET = 12
-OFPGMFC_BAD_WATCH = 13
-OFPGMFC_EPERM = 14
-
-ofp_group_mod_failed_code_map = {
-    0: 'OFPGMFC_GROUP_EXISTS',
-    1: 'OFPGMFC_INVALID_GROUP',
-    2: 'OFPGMFC_WEIGHT_UNSUPPORTED',
-    3: 'OFPGMFC_OUT_OF_GROUPS',
-    4: 'OFPGMFC_OUT_OF_BUCKETS',
-    5: 'OFPGMFC_CHAINING_UNSUPPORTED',
-    6: 'OFPGMFC_WATCH_UNSUPPORTED',
-    7: 'OFPGMFC_LOOP',
-    8: 'OFPGMFC_UNKNOWN_GROUP',
-    9: 'OFPGMFC_CHAINED_GROUP',
-    10: 'OFPGMFC_BAD_TYPE',
-    11: 'OFPGMFC_BAD_COMMAND',
-    12: 'OFPGMFC_BAD_BUCKET',
-    13: 'OFPGMFC_BAD_WATCH',
-    14: 'OFPGMFC_EPERM',
-}
-
-# Identifiers from group ofp_group_type
-OFPGT_ALL = 0
-OFPGT_SELECT = 1
-OFPGT_INDIRECT = 2
-OFPGT_FF = 3
-
-ofp_group_type_map = {
-    0: 'OFPGT_ALL',
-    1: 'OFPGT_SELECT',
-    2: 'OFPGT_INDIRECT',
-    3: 'OFPGT_FF',
-}
-
-# Identifiers from group ofp_hello_elem_type
-OFPHET_VERSIONBITMAP = 1
-
-ofp_hello_elem_type_map = {
-    1: 'OFPHET_VERSIONBITMAP',
-}
-
-# Identifiers from group ofp_hello_failed_code
-OFPHFC_INCOMPATIBLE = 0
-OFPHFC_EPERM = 1
-
-ofp_hello_failed_code_map = {
-    0: 'OFPHFC_INCOMPATIBLE',
-    1: 'OFPHFC_EPERM',
-}
-
-# Identifiers from group ofp_instruction_type
-OFPIT_GOTO_TABLE = 1
-OFPIT_WRITE_METADATA = 2
-OFPIT_WRITE_ACTIONS = 3
-OFPIT_APPLY_ACTIONS = 4
-OFPIT_CLEAR_ACTIONS = 5
-OFPIT_METER = 6
-OFPIT_EXPERIMENTER = 65535
-
-ofp_instruction_type_map = {
-    1: 'OFPIT_GOTO_TABLE',
-    2: 'OFPIT_WRITE_METADATA',
-    3: 'OFPIT_WRITE_ACTIONS',
-    4: 'OFPIT_APPLY_ACTIONS',
-    5: 'OFPIT_CLEAR_ACTIONS',
-    6: 'OFPIT_METER',
-    65535: 'OFPIT_EXPERIMENTER',
-}
-
-# Identifiers from group ofp_ipv6exthdr_flags
-OFPIEH_NONEXT = 1
-OFPIEH_ESP = 2
-OFPIEH_AUTH = 4
-OFPIEH_DEST = 8
-OFPIEH_FRAG = 16
-OFPIEH_ROUTER = 32
-OFPIEH_HOP = 64
-OFPIEH_UNREP = 128
-OFPIEH_UNSEQ = 256
-
-ofp_ipv6exthdr_flags_map = {
-    1: 'OFPIEH_NONEXT',
-    2: 'OFPIEH_ESP',
-    4: 'OFPIEH_AUTH',
-    8: 'OFPIEH_DEST',
-    16: 'OFPIEH_FRAG',
-    32: 'OFPIEH_ROUTER',
-    64: 'OFPIEH_HOP',
-    128: 'OFPIEH_UNREP',
-    256: 'OFPIEH_UNSEQ',
-}
-
-# Identifiers from group ofp_match_type
-OFPMT_STANDARD = 0
-OFPMT_OXM = 1
-
-ofp_match_type_map = {
-    0: 'OFPMT_STANDARD',
-    1: 'OFPMT_OXM',
-}
-
-# Identifiers from group ofp_meter
-OFPM_MAX = 4294901760
-OFPM_SLOWPATH = 4294967293
-OFPM_CONTROLLER = 4294967294
-OFPM_ALL = 4294967295
-
-ofp_meter_map = {
-    4294901760: 'OFPM_MAX',
-    4294967293: 'OFPM_SLOWPATH',
-    4294967294: 'OFPM_CONTROLLER',
-    4294967295: 'OFPM_ALL',
-}
-
-# Identifiers from group ofp_meter_band_type
-OFPMBT_DROP = 1
-OFPMBT_DSCP_REMARK = 2
-OFPMBT_EXPERIMENTER = 65535
-
-ofp_meter_band_type_map = {
-    1: 'OFPMBT_DROP',
-    2: 'OFPMBT_DSCP_REMARK',
-    65535: 'OFPMBT_EXPERIMENTER',
-}
-
-# Identifiers from group ofp_meter_flags
-OFPMF_KBPS = 1
-OFPMF_PKTPS = 2
-OFPMF_BURST = 4
-OFPMF_STATS = 8
-
-ofp_meter_flags_map = {
-    1: 'OFPMF_KBPS',
-    2: 'OFPMF_PKTPS',
-    4: 'OFPMF_BURST',
-    8: 'OFPMF_STATS',
-}
-
-# Identifiers from group ofp_meter_mod_command
-OFPMC_ADD = 0
-OFPMC_MODIFY = 1
-OFPMC_DELETE = 2
-
-ofp_meter_mod_command_map = {
-    0: 'OFPMC_ADD',
-    1: 'OFPMC_MODIFY',
-    2: 'OFPMC_DELETE',
-}
-
-# Identifiers from group ofp_meter_mod_failed_code
-OFPMMFC_UNKNOWN = 0
-OFPMMFC_METER_EXISTS = 1
-OFPMMFC_INVALID_METER = 2
-OFPMMFC_UNKNOWN_METER = 3
-OFPMMFC_BAD_COMMAND = 4
-OFPMMFC_BAD_FLAGS = 5
-OFPMMFC_BAD_RATE = 6
-OFPMMFC_BAD_BURST = 7
-OFPMMFC_BAD_BAND = 8
-OFPMMFC_BAD_BAND_VALUE = 9
-OFPMMFC_OUT_OF_METERS = 10
-OFPMMFC_OUT_OF_BANDS = 11
-
-ofp_meter_mod_failed_code_map = {
-    0: 'OFPMMFC_UNKNOWN',
-    1: 'OFPMMFC_METER_EXISTS',
-    2: 'OFPMMFC_INVALID_METER',
-    3: 'OFPMMFC_UNKNOWN_METER',
-    4: 'OFPMMFC_BAD_COMMAND',
-    5: 'OFPMMFC_BAD_FLAGS',
-    6: 'OFPMMFC_BAD_RATE',
-    7: 'OFPMMFC_BAD_BURST',
-    8: 'OFPMMFC_BAD_BAND',
-    9: 'OFPMMFC_BAD_BAND_VALUE',
-    10: 'OFPMMFC_OUT_OF_METERS',
-    11: 'OFPMMFC_OUT_OF_BANDS',
-}
-
-# Identifiers from group ofp_optical_port_features
-OFPOPF_RX_TUNE = 1
-OFPOPF_TX_TUNE = 2
-OFPOPF_TX_PWR = 4
-OFPOPF_USE_FREQ = 8
-
-ofp_optical_port_features_map = {
-    1: 'OFPOPF_RX_TUNE',
-    2: 'OFPOPF_TX_TUNE',
-    4: 'OFPOPF_TX_PWR',
-    8: 'OFPOPF_USE_FREQ',
-}
-
-# Identifiers from group ofp_oxm_class
-OFPXMC_NXM_0 = 0
-OFPXMC_NXM_1 = 1
-OFPXMC_OPENFLOW_BASIC = 32768
-OFPXMC_EXPERIMENTER = 65535
-
-ofp_oxm_class_map = {
-    0: 'OFPXMC_NXM_0',
-    1: 'OFPXMC_NXM_1',
-    32768: 'OFPXMC_OPENFLOW_BASIC',
-    65535: 'OFPXMC_EXPERIMENTER',
-}
-
-# Identifiers from group ofp_packet_in_reason
-OFPR_NO_MATCH = 0
-OFPR_ACTION = 1
-OFPR_INVALID_TTL = 2
-OFPR_ACTION_SET = 3
-OFPR_GROUP = 4
-OFPR_PACKET_OUT = 5
-OFPR_BSN_NEW_HOST = 128
-OFPR_BSN_STATION_MOVE = 129
-OFPR_BSN_BAD_VLAN = 130
-OFPR_BSN_DESTINATION_LOOKUP_FAILURE = 131
-OFPR_BSN_NO_ROUTE = 132
-OFPR_BSN_ICMP_ECHO_REQUEST = 133
-OFPR_BSN_DEST_NETWORK_UNREACHABLE = 134
-OFPR_BSN_DEST_HOST_UNREACHABLE = 135
-OFPR_BSN_DEST_PORT_UNREACHABLE = 136
-OFPR_BSN_FRAGMENTATION_REQUIRED = 137
-OFPR_BSN_ARP = 139
-OFPR_BSN_DHCP = 140
-OFPR_BSN_DEBUG = 141
-OFPR_BSN_PACKET_OF_DEATH = 142
-
-ofp_packet_in_reason_map = {
-    0: 'OFPR_NO_MATCH',
-    1: 'OFPR_ACTION',
-    2: 'OFPR_INVALID_TTL',
-    3: 'OFPR_ACTION_SET',
-    4: 'OFPR_GROUP',
-    5: 'OFPR_PACKET_OUT',
-    128: 'OFPR_BSN_NEW_HOST',
-    129: 'OFPR_BSN_STATION_MOVE',
-    130: 'OFPR_BSN_BAD_VLAN',
-    131: 'OFPR_BSN_DESTINATION_LOOKUP_FAILURE',
-    132: 'OFPR_BSN_NO_ROUTE',
-    133: 'OFPR_BSN_ICMP_ECHO_REQUEST',
-    134: 'OFPR_BSN_DEST_NETWORK_UNREACHABLE',
-    135: 'OFPR_BSN_DEST_HOST_UNREACHABLE',
-    136: 'OFPR_BSN_DEST_PORT_UNREACHABLE',
-    137: 'OFPR_BSN_FRAGMENTATION_REQUIRED',
-    139: 'OFPR_BSN_ARP',
-    140: 'OFPR_BSN_DHCP',
-    141: 'OFPR_BSN_DEBUG',
-    142: 'OFPR_BSN_PACKET_OF_DEATH',
-}
-
-# Identifiers from group ofp_port
-OFPP_MAX = 4294967040
-OFPP_IN_PORT = 4294967288
-OFPP_TABLE = 4294967289
-OFPP_NORMAL = 4294967290
-OFPP_FLOOD = 4294967291
-OFPP_ALL = 4294967292
-OFPP_CONTROLLER = 4294967293
-OFPP_LOCAL = 4294967294
-OFPP_ANY = 4294967295
-
-ofp_port_map = {
-    4294967040: 'OFPP_MAX',
-    4294967288: 'OFPP_IN_PORT',
-    4294967289: 'OFPP_TABLE',
-    4294967290: 'OFPP_NORMAL',
-    4294967291: 'OFPP_FLOOD',
-    4294967292: 'OFPP_ALL',
-    4294967293: 'OFPP_CONTROLLER',
-    4294967294: 'OFPP_LOCAL',
-    4294967295: 'OFPP_ANY',
-}
-
-# Identifiers from group ofp_port_config
-OFPPC_PORT_DOWN = 1
-OFPPC_NO_RECV = 4
-OFPPC_NO_FWD = 32
-OFPPC_NO_PACKET_IN = 64
-OFPPC_BSN_MIRROR_DEST = 2147483648
-
-ofp_port_config_map = {
-    1: 'OFPPC_PORT_DOWN',
-    4: 'OFPPC_NO_RECV',
-    32: 'OFPPC_NO_FWD',
-    64: 'OFPPC_NO_PACKET_IN',
-    2147483648: 'OFPPC_BSN_MIRROR_DEST',
-}
-
-# Identifiers from group ofp_port_features
-OFPPF_10MB_HD = 1
-OFPPF_10MB_FD = 2
-OFPPF_100MB_HD = 4
-OFPPF_100MB_FD = 8
-OFPPF_1GB_HD = 16
-OFPPF_1GB_FD = 32
-OFPPF_10GB_FD = 64
-OFPPF_40GB_FD = 128
-OFPPF_100GB_FD = 256
-OFPPF_1TB_FD = 512
-OFPPF_OTHER = 1024
-OFPPF_COPPER = 2048
-OFPPF_FIBER = 4096
-OFPPF_AUTONEG = 8192
-OFPPF_PAUSE = 16384
-OFPPF_PAUSE_ASYM = 32768
-OFPPF_BSN_BREAKOUT_CAPABLE = 2147483648
-
-ofp_port_features_map = {
-    1: 'OFPPF_10MB_HD',
-    2: 'OFPPF_10MB_FD',
-    4: 'OFPPF_100MB_HD',
-    8: 'OFPPF_100MB_FD',
-    16: 'OFPPF_1GB_HD',
-    32: 'OFPPF_1GB_FD',
-    64: 'OFPPF_10GB_FD',
-    128: 'OFPPF_40GB_FD',
-    256: 'OFPPF_100GB_FD',
-    512: 'OFPPF_1TB_FD',
-    1024: 'OFPPF_OTHER',
-    2048: 'OFPPF_COPPER',
-    4096: 'OFPPF_FIBER',
-    8192: 'OFPPF_AUTONEG',
-    16384: 'OFPPF_PAUSE',
-    32768: 'OFPPF_PAUSE_ASYM',
-    2147483648: 'OFPPF_BSN_BREAKOUT_CAPABLE',
-}
-
-# Identifiers from group ofp_port_mod_failed_code
-OFPPMFC_BAD_PORT = 0
-OFPPMFC_BAD_HW_ADDR = 1
-OFPPMFC_BAD_CONFIG = 2
-OFPPMFC_BAD_ADVERTISE = 3
-OFPPMFC_EPERM = 4
-
-ofp_port_mod_failed_code_map = {
-    0: 'OFPPMFC_BAD_PORT',
-    1: 'OFPPMFC_BAD_HW_ADDR',
-    2: 'OFPPMFC_BAD_CONFIG',
-    3: 'OFPPMFC_BAD_ADVERTISE',
-    4: 'OFPPMFC_EPERM',
-}
-
-# Identifiers from group ofp_port_reason
-OFPPR_ADD = 0
-OFPPR_DELETE = 1
-OFPPR_MODIFY = 2
-
-ofp_port_reason_map = {
-    0: 'OFPPR_ADD',
-    1: 'OFPPR_DELETE',
-    2: 'OFPPR_MODIFY',
-}
-
-# Identifiers from group ofp_port_state
-OFPPS_LINK_DOWN = 1
-OFPPS_BLOCKED = 2
-OFPPS_LIVE = 4
-
-ofp_port_state_map = {
-    1: 'OFPPS_LINK_DOWN',
-    2: 'OFPPS_BLOCKED',
-    4: 'OFPPS_LIVE',
-}
-
-# Identifiers from group ofp_port_stats_optical_flags
-OFPOSF_RX_TUNE = 1
-OFPOSF_TX_TUNE = 2
-OFPOSF_TX_PWR = 4
-OFPOSF_RX_PWR = 16
-OFPOSF_TX_BIAS = 32
-OFPOSF_TX_TEMP = 64
-
-ofp_port_stats_optical_flags_map = {
-    1: 'OFPOSF_RX_TUNE',
-    2: 'OFPOSF_TX_TUNE',
-    4: 'OFPOSF_TX_PWR',
-    16: 'OFPOSF_RX_PWR',
-    32: 'OFPOSF_TX_BIAS',
-    64: 'OFPOSF_TX_TEMP',
-}
-
-# Identifiers from group ofp_port_stats_prop_type
-OFPPSPT_ETHERNET = 0
-OFPPSPT_OPTICAL = 1
-OFPPSPT_EXPERIMENTER = 65535
-
-ofp_port_stats_prop_type_map = {
-    0: 'OFPPSPT_ETHERNET',
-    1: 'OFPPSPT_OPTICAL',
-    65535: 'OFPPSPT_EXPERIMENTER',
-}
-
-# Identifiers from group ofp_queue_op_failed_code
-OFPQOFC_BAD_PORT = 0
-OFPQOFC_BAD_QUEUE = 1
-OFPQOFC_EPERM = 2
-
-ofp_queue_op_failed_code_map = {
-    0: 'OFPQOFC_BAD_PORT',
-    1: 'OFPQOFC_BAD_QUEUE',
-    2: 'OFPQOFC_EPERM',
-}
-
-# Identifiers from group ofp_requestforward_reason
-OFPRFR_GROUP_MOD = 0
-OFPRFR_METER_MOD = 1
-
-ofp_requestforward_reason_map = {
-    0: 'OFPRFR_GROUP_MOD',
-    1: 'OFPRFR_METER_MOD',
-}
-
-# Identifiers from group ofp_role_request_failed_code
-OFPRRFC_STALE = 0
-OFPRRFC_UNSUP = 1
-OFPRRFC_BAD_ROLE = 2
-
-ofp_role_request_failed_code_map = {
-    0: 'OFPRRFC_STALE',
-    1: 'OFPRRFC_UNSUP',
-    2: 'OFPRRFC_BAD_ROLE',
-}
-
-# Identifiers from group ofp_stats_reply_flags
-OFPSF_REPLY_MORE = 1
-
-ofp_stats_reply_flags_map = {
-    1: 'OFPSF_REPLY_MORE',
-}
-
-# Identifiers from group ofp_stats_request_flags
-OFPSF_REQ_MORE = 1
-
-ofp_stats_request_flags_map = {
-    1: 'OFPSF_REQ_MORE',
-}
-
-# Identifiers from group ofp_stats_type
-OFPST_DESC = 0
-OFPST_FLOW = 1
-OFPST_AGGREGATE = 2
-OFPST_TABLE = 3
-OFPST_PORT = 4
-OFPST_QUEUE = 5
-OFPST_GROUP = 6
-OFPST_GROUP_DESC = 7
-OFPST_GROUP_FEATURES = 8
-OFPST_METER = 9
-OFPST_METER_CONFIG = 10
-OFPST_METER_FEATURES = 11
-OFPST_TABLE_FEATURES = 12
-OFPST_PORT_DESC = 13
-OFPMP_TABLE_DESC = 14
-OFPMP_QUEUE_DESC = 15
-OFPMP_FLOW_MONITOR = 16
-OFPST_EXPERIMENTER = 65535
-
-ofp_stats_type_map = {
-    0: 'OFPST_DESC',
-    1: 'OFPST_FLOW',
-    2: 'OFPST_AGGREGATE',
-    3: 'OFPST_TABLE',
-    4: 'OFPST_PORT',
-    5: 'OFPST_QUEUE',
-    6: 'OFPST_GROUP',
-    7: 'OFPST_GROUP_DESC',
-    8: 'OFPST_GROUP_FEATURES',
-    9: 'OFPST_METER',
-    10: 'OFPST_METER_CONFIG',
-    11: 'OFPST_METER_FEATURES',
-    12: 'OFPST_TABLE_FEATURES',
-    13: 'OFPST_PORT_DESC',
-    14: 'OFPMP_TABLE_DESC',
-    15: 'OFPMP_QUEUE_DESC',
-    16: 'OFPMP_FLOW_MONITOR',
-    65535: 'OFPST_EXPERIMENTER',
-}
-
-# Identifiers from group ofp_switch_config_failed_code
-OFPSCFC_BAD_FLAGS = 0
-OFPSCFC_BAD_LEN = 1
-OFPSCFC_EPERM = 2
-
-ofp_switch_config_failed_code_map = {
-    0: 'OFPSCFC_BAD_FLAGS',
-    1: 'OFPSCFC_BAD_LEN',
-    2: 'OFPSCFC_EPERM',
-}
-
-# Identifiers from group ofp_table
-OFPTT_MAX = 254
-OFPTT_ALL = 255
-
-ofp_table_map = {
-    254: 'OFPTT_MAX',
-    255: 'OFPTT_ALL',
-}
-
-# Identifiers from group ofp_table_config
-OFPTC_DEPRECATED_MASK = 3
-OFPTC_EVICTION = 4
-OFPTC_VACANCY_EVENTS = 8
-
-ofp_table_config_map = {
-    3: 'OFPTC_DEPRECATED_MASK',
-    4: 'OFPTC_EVICTION',
-    8: 'OFPTC_VACANCY_EVENTS',
-}
-
-# Identifiers from group ofp_table_feature_prop_type
-OFPTFPT_INSTRUCTIONS = 0
-OFPTFPT_INSTRUCTIONS_MISS = 1
-OFPTFPT_NEXT_TABLES = 2
-OFPTFPT_NEXT_TABLES_MISS = 3
-OFPTFPT_WRITE_ACTIONS = 4
-OFPTFPT_WRITE_ACTIONS_MISS = 5
-OFPTFPT_APPLY_ACTIONS = 6
-OFPTFPT_APPLY_ACTIONS_MISS = 7
-OFPTFPT_MATCH = 8
-OFPTFPT_WILDCARDS = 10
-OFPTFPT_WRITE_SETFIELD = 12
-OFPTFPT_WRITE_SETFIELD_MISS = 13
-OFPTFPT_APPLY_SETFIELD = 14
-OFPTFPT_APPLY_SETFIELD_MISS = 15
-OFPTFPT_TABLE_SYNC_FROM = 16
-OFPTFPT_EXPERIMENTER = 65534
-OFPTFPT_EXPERIMENTER_MISS = 65535
-
-ofp_table_feature_prop_type_map = {
-    0: 'OFPTFPT_INSTRUCTIONS',
-    1: 'OFPTFPT_INSTRUCTIONS_MISS',
-    2: 'OFPTFPT_NEXT_TABLES',
-    3: 'OFPTFPT_NEXT_TABLES_MISS',
-    4: 'OFPTFPT_WRITE_ACTIONS',
-    5: 'OFPTFPT_WRITE_ACTIONS_MISS',
-    6: 'OFPTFPT_APPLY_ACTIONS',
-    7: 'OFPTFPT_APPLY_ACTIONS_MISS',
-    8: 'OFPTFPT_MATCH',
-    10: 'OFPTFPT_WILDCARDS',
-    12: 'OFPTFPT_WRITE_SETFIELD',
-    13: 'OFPTFPT_WRITE_SETFIELD_MISS',
-    14: 'OFPTFPT_APPLY_SETFIELD',
-    15: 'OFPTFPT_APPLY_SETFIELD_MISS',
-    16: 'OFPTFPT_TABLE_SYNC_FROM',
-    65534: 'OFPTFPT_EXPERIMENTER',
-    65535: 'OFPTFPT_EXPERIMENTER_MISS',
-}
-
-# Identifiers from group ofp_table_features_failed_code
-OFPTFFC_BAD_TABLE = 0
-OFPTFFC_BAD_METADATA = 1
-OFPTFFC_EPERM = 5
-
-ofp_table_features_failed_code_map = {
-    0: 'OFPTFFC_BAD_TABLE',
-    1: 'OFPTFFC_BAD_METADATA',
-    5: 'OFPTFFC_EPERM',
-}
-
-# Identifiers from group ofp_table_mod_failed_code
-OFPTMFC_BAD_TABLE = 0
-OFPTMFC_BAD_CONFIG = 1
-OFPTMFC_EPERM = 2
-
-ofp_table_mod_failed_code_map = {
-    0: 'OFPTMFC_BAD_TABLE',
-    1: 'OFPTMFC_BAD_CONFIG',
-    2: 'OFPTMFC_EPERM',
-}
-
-# Identifiers from group ofp_table_mod_prop_eviction_flag
-OFPTMPEF_OTHER = 1
-OFPTMPEF_IMPORTANCE = 2
-OFPTMPEF_LIFETIME = 4
-
-ofp_table_mod_prop_eviction_flag_map = {
-    1: 'OFPTMPEF_OTHER',
-    2: 'OFPTMPEF_IMPORTANCE',
-    4: 'OFPTMPEF_LIFETIME',
-}
-
-# Identifiers from group ofp_table_reason
-OFPTR_VACANCY_DOWN = 3
-OFPTR_VACANCY_UP = 4
-
-ofp_table_reason_map = {
-    3: 'OFPTR_VACANCY_DOWN',
-    4: 'OFPTR_VACANCY_UP',
-}
-
-# Identifiers from group ofp_type
-OFPT_HELLO = 0
-OFPT_ERROR = 1
-OFPT_ECHO_REQUEST = 2
-OFPT_ECHO_REPLY = 3
-OFPT_EXPERIMENTER = 4
-OFPT_FEATURES_REQUEST = 5
-OFPT_FEATURES_REPLY = 6
-OFPT_GET_CONFIG_REQUEST = 7
-OFPT_GET_CONFIG_REPLY = 8
-OFPT_SET_CONFIG = 9
-OFPT_PACKET_IN = 10
-OFPT_FLOW_REMOVED = 11
-OFPT_PORT_STATUS = 12
-OFPT_PACKET_OUT = 13
-OFPT_FLOW_MOD = 14
-OFPT_GROUP_MOD = 15
-OFPT_PORT_MOD = 16
-OFPT_TABLE_MOD = 17
-OFPT_STATS_REQUEST = 18
-OFPT_STATS_REPLY = 19
-OFPT_BARRIER_REQUEST = 20
-OFPT_BARRIER_REPLY = 21
-OFPT_ROLE_REQUEST = 24
-OFPT_ROLE_REPLY = 25
-OFPT_GET_ASYNC_REQUEST = 26
-OFPT_GET_ASYNC_REPLY = 27
-OFPT_SET_ASYNC = 28
-OFPT_METER_MOD = 29
-OFPT_ROLE_STATUS = 30
-OFPT_TABLE_STATUS = 31
-OFPT_REQUESTFORWARD = 32
-OFPT_BUNDLE_CONTROL = 33
-OFPT_BUNDLE_ADD_MESSAGE = 34
-
-ofp_type_map = {
-    0: 'OFPT_HELLO',
-    1: 'OFPT_ERROR',
-    2: 'OFPT_ECHO_REQUEST',
-    3: 'OFPT_ECHO_REPLY',
-    4: 'OFPT_EXPERIMENTER',
-    5: 'OFPT_FEATURES_REQUEST',
-    6: 'OFPT_FEATURES_REPLY',
-    7: 'OFPT_GET_CONFIG_REQUEST',
-    8: 'OFPT_GET_CONFIG_REPLY',
-    9: 'OFPT_SET_CONFIG',
-    10: 'OFPT_PACKET_IN',
-    11: 'OFPT_FLOW_REMOVED',
-    12: 'OFPT_PORT_STATUS',
-    13: 'OFPT_PACKET_OUT',
-    14: 'OFPT_FLOW_MOD',
-    15: 'OFPT_GROUP_MOD',
-    16: 'OFPT_PORT_MOD',
-    17: 'OFPT_TABLE_MOD',
-    18: 'OFPT_STATS_REQUEST',
-    19: 'OFPT_STATS_REPLY',
-    20: 'OFPT_BARRIER_REQUEST',
-    21: 'OFPT_BARRIER_REPLY',
-    24: 'OFPT_ROLE_REQUEST',
-    25: 'OFPT_ROLE_REPLY',
-    26: 'OFPT_GET_ASYNC_REQUEST',
-    27: 'OFPT_GET_ASYNC_REPLY',
-    28: 'OFPT_SET_ASYNC',
-    29: 'OFPT_METER_MOD',
-    30: 'OFPT_ROLE_STATUS',
-    31: 'OFPT_TABLE_STATUS',
-    32: 'OFPT_REQUESTFORWARD',
-    33: 'OFPT_BUNDLE_CONTROL',
-    34: 'OFPT_BUNDLE_ADD_MESSAGE',
-}
-
-# Identifiers from group ofp_vlan_id
-OFPVID_NONE = 0
-OFPVID_PRESENT = 4096
-
-ofp_vlan_id_map = {
-    0: 'OFPVID_NONE',
-    4096: 'OFPVID_PRESENT',
-}
-
diff --git a/python/ofagent/loxi/of14/instruction.py b/python/ofagent/loxi/of14/instruction.py
deleted file mode 100644
index 62a1f61..0000000
--- a/python/ofagent/loxi/of14/instruction.py
+++ /dev/null
@@ -1,1120 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template module.py
-# Do not modify
-
-import struct
-import loxi
-import util
-import loxi.generic_util
-
-import sys
-ofp = sys.modules['loxi.of14']
-
-class instruction(loxi.OFObject):
-    subtypes = {}
-
-
-    def __init__(self, type=None):
-        if type != None:
-            self.type = type
-        else:
-            self.type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 0)
-        subclass = instruction.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = instruction()
-        obj.type = reader.read("!H")[0]
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type != other.type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("instruction {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-
-class apply_actions(instruction):
-    type = 4
-
-    def __init__(self, actions=None):
-        if actions != None:
-            self.actions = actions
-        else:
-            self.actions = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.actions))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = apply_actions()
-        _type = reader.read("!H")[0]
-        assert(_type == 4)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        obj.actions = loxi.generic_util.unpack_list(reader, ofp.action.action.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.actions != other.actions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("apply_actions {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("actions = ");
-                q.pp(self.actions)
-            q.breakable()
-        q.text('}')
-
-instruction.subtypes[4] = apply_actions
-
-class experimenter(instruction):
-    subtypes = {}
-
-    type = 65535
-
-    def __init__(self, experimenter=None, data=None):
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 4)
-        subclass = experimenter.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = experimenter()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.experimenter = reader.read("!L")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.experimenter != other.experimenter: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("experimenter {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-instruction.subtypes[65535] = experimenter
-
-class bsn(experimenter):
-    subtypes = {}
-
-    type = 65535
-    experimenter = 6035143
-
-    def __init__(self, subtype=None):
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 8)
-        subclass = bsn.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = bsn()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        obj.subtype = reader.read("!L")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.subtype != other.subtype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-experimenter.subtypes[6035143] = bsn
-
-class bsn_arp_offload(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 1
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_arp_offload()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 1)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_arp_offload {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[1] = bsn_arp_offload
-
-class bsn_auto_negotiation(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 11
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_auto_negotiation()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 11)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_auto_negotiation {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[11] = bsn_auto_negotiation
-
-class bsn_deny(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 5
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_deny()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 5)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_deny {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[5] = bsn_deny
-
-class bsn_dhcp_offload(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 2
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_dhcp_offload()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 2)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_dhcp_offload {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[2] = bsn_dhcp_offload
-
-class bsn_disable_l3(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 13
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_disable_l3()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 13)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_disable_l3 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[13] = bsn_disable_l3
-
-class bsn_disable_src_mac_check(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 0
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_disable_src_mac_check()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 0)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_disable_src_mac_check {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[0] = bsn_disable_src_mac_check
-
-class bsn_disable_vlan_counters(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 9
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_disable_vlan_counters()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 9)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_disable_vlan_counters {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[9] = bsn_disable_vlan_counters
-
-class bsn_internal_priority(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 12
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.value))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_internal_priority()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 12)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_internal_priority {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[12] = bsn_internal_priority
-
-class bsn_packet_of_death(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 6
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_packet_of_death()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 6)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_packet_of_death {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[6] = bsn_packet_of_death
-
-class bsn_permit(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 4
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_permit()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 4)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_permit {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[4] = bsn_permit
-
-class bsn_prioritize_pdus(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 7
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_prioritize_pdus()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 7)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_prioritize_pdus {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[7] = bsn_prioritize_pdus
-
-class bsn_require_vlan_xlate(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 8
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_require_vlan_xlate()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 8)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_require_vlan_xlate {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[8] = bsn_require_vlan_xlate
-
-class bsn_span_destination(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 10
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_span_destination()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 10)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_span_destination {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[10] = bsn_span_destination
-
-class clear_actions(instruction):
-    type = 5
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = clear_actions()
-        _type = reader.read("!H")[0]
-        assert(_type == 5)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("clear_actions {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-instruction.subtypes[5] = clear_actions
-
-class goto_table(instruction):
-    type = 1
-
-    def __init__(self, table_id=None):
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append('\x00' * 3)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = goto_table()
-        _type = reader.read("!H")[0]
-        assert(_type == 1)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.table_id = reader.read("!B")[0]
-        reader.skip(3)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.table_id != other.table_id: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("goto_table {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-            q.breakable()
-        q.text('}')
-
-instruction.subtypes[1] = goto_table
-
-class meter(instruction):
-    type = 6
-
-    def __init__(self, meter_id=None):
-        if meter_id != None:
-            self.meter_id = meter_id
-        else:
-            self.meter_id = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.meter_id))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = meter()
-        _type = reader.read("!H")[0]
-        assert(_type == 6)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.meter_id = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.meter_id != other.meter_id: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("meter {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("meter_id = ");
-                q.text("%#x" % self.meter_id)
-            q.breakable()
-        q.text('}')
-
-instruction.subtypes[6] = meter
-
-class write_actions(instruction):
-    type = 3
-
-    def __init__(self, actions=None):
-        if actions != None:
-            self.actions = actions
-        else:
-            self.actions = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.actions))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = write_actions()
-        _type = reader.read("!H")[0]
-        assert(_type == 3)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        obj.actions = loxi.generic_util.unpack_list(reader, ofp.action.action.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.actions != other.actions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("write_actions {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("actions = ");
-                q.pp(self.actions)
-            q.breakable()
-        q.text('}')
-
-instruction.subtypes[3] = write_actions
-
-class write_metadata(instruction):
-    type = 2
-
-    def __init__(self, metadata=None, metadata_mask=None):
-        if metadata != None:
-            self.metadata = metadata
-        else:
-            self.metadata = 0
-        if metadata_mask != None:
-            self.metadata_mask = metadata_mask
-        else:
-            self.metadata_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!Q", self.metadata))
-        packed.append(struct.pack("!Q", self.metadata_mask))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = write_metadata()
-        _type = reader.read("!H")[0]
-        assert(_type == 2)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        reader.skip(4)
-        obj.metadata = reader.read("!Q")[0]
-        obj.metadata_mask = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.metadata != other.metadata: return False
-        if self.metadata_mask != other.metadata_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("write_metadata {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("metadata = ");
-                q.text("%#x" % self.metadata)
-                q.text(","); q.breakable()
-                q.text("metadata_mask = ");
-                q.text("%#x" % self.metadata_mask)
-            q.breakable()
-        q.text('}')
-
-instruction.subtypes[2] = write_metadata
-
-
diff --git a/python/ofagent/loxi/of14/instruction_id.py b/python/ofagent/loxi/of14/instruction_id.py
deleted file mode 100644
index da9f84a..0000000
--- a/python/ofagent/loxi/of14/instruction_id.py
+++ /dev/null
@@ -1,1011 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template module.py
-# Do not modify
-
-import struct
-import loxi
-import util
-import loxi.generic_util
-
-import sys
-ofp = sys.modules['loxi.of14']
-
-class instruction_id(loxi.OFObject):
-    subtypes = {}
-
-
-    def __init__(self, type=None):
-        if type != None:
-            self.type = type
-        else:
-            self.type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 0)
-        subclass = instruction_id.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = instruction_id()
-        obj.type = reader.read("!H")[0]
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type != other.type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("instruction_id {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-
-class apply_actions(instruction_id):
-    type = 4
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = apply_actions()
-        _type = reader.read("!H")[0]
-        assert(_type == 4)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("apply_actions {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-instruction_id.subtypes[4] = apply_actions
-
-class experimenter(instruction_id):
-    subtypes = {}
-
-    type = 65535
-
-    def __init__(self, experimenter=None):
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 4)
-        subclass = experimenter.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = experimenter()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.experimenter = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.experimenter != other.experimenter: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("experimenter {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-instruction_id.subtypes[65535] = experimenter
-
-class bsn(experimenter):
-    subtypes = {}
-
-    type = 65535
-    experimenter = 6035143
-
-    def __init__(self, subtype=None):
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 8)
-        subclass = bsn.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = bsn()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        obj.subtype = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.subtype != other.subtype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-experimenter.subtypes[6035143] = bsn
-
-class bsn_arp_offload(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 1
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_arp_offload()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 1)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_arp_offload {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[1] = bsn_arp_offload
-
-class bsn_auto_negotiation(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 11
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_auto_negotiation()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 11)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_auto_negotiation {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[11] = bsn_auto_negotiation
-
-class bsn_deny(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 5
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_deny()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 5)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_deny {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[5] = bsn_deny
-
-class bsn_dhcp_offload(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 2
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_dhcp_offload()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 2)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_dhcp_offload {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[2] = bsn_dhcp_offload
-
-class bsn_disable_l3(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 13
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_disable_l3()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 13)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_disable_l3 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[13] = bsn_disable_l3
-
-class bsn_disable_src_mac_check(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 0
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_disable_src_mac_check()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 0)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_disable_src_mac_check {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[0] = bsn_disable_src_mac_check
-
-class bsn_disable_vlan_counters(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 9
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_disable_vlan_counters()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 9)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_disable_vlan_counters {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[9] = bsn_disable_vlan_counters
-
-class bsn_internal_priority(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 12
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_internal_priority()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 12)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_internal_priority {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[12] = bsn_internal_priority
-
-class bsn_packet_of_death(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 6
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_packet_of_death()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 6)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_packet_of_death {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[6] = bsn_packet_of_death
-
-class bsn_permit(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 4
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_permit()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_permit {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[4] = bsn_permit
-
-class bsn_prioritize_pdus(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 7
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_prioritize_pdus()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 7)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_prioritize_pdus {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[7] = bsn_prioritize_pdus
-
-class bsn_require_vlan_xlate(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 8
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_require_vlan_xlate()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 8)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_require_vlan_xlate {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[8] = bsn_require_vlan_xlate
-
-class bsn_span_destination(bsn):
-    type = 65535
-    experimenter = 6035143
-    subtype = 10
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_span_destination()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 10)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_span_destination {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[10] = bsn_span_destination
-
-class clear_actions(instruction_id):
-    type = 5
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = clear_actions()
-        _type = reader.read("!H")[0]
-        assert(_type == 5)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("clear_actions {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-instruction_id.subtypes[5] = clear_actions
-
-class goto_table(instruction_id):
-    type = 1
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = goto_table()
-        _type = reader.read("!H")[0]
-        assert(_type == 1)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("goto_table {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-instruction_id.subtypes[1] = goto_table
-
-class meter(instruction_id):
-    type = 6
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = meter()
-        _type = reader.read("!H")[0]
-        assert(_type == 6)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("meter {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-instruction_id.subtypes[6] = meter
-
-class write_actions(instruction_id):
-    type = 3
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = write_actions()
-        _type = reader.read("!H")[0]
-        assert(_type == 3)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("write_actions {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-instruction_id.subtypes[3] = write_actions
-
-class write_metadata(instruction_id):
-    type = 2
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = write_metadata()
-        _type = reader.read("!H")[0]
-        assert(_type == 2)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("write_metadata {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-instruction_id.subtypes[2] = write_metadata
-
-
diff --git a/python/ofagent/loxi/of14/message.py b/python/ofagent/loxi/of14/message.py
deleted file mode 100644
index 68dc3ab..0000000
--- a/python/ofagent/loxi/of14/message.py
+++ /dev/null
@@ -1,16405 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template module.py
-# Do not modify
-
-import struct
-import loxi
-import util
-import loxi.generic_util
-
-import sys
-ofp = sys.modules['loxi.of14']
-
-class message(loxi.OFObject):
-    subtypes = {}
-
-    version = 5
-
-    def __init__(self, type=None, xid=None):
-        if type != None:
-            self.type = type
-        else:
-            self.type = 0
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('B', 1)
-        subclass = message.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = message()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        obj.type = reader.read("!B")[0]
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type != other.type: return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("message {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-
-class stats_reply(message):
-    subtypes = {}
-
-    version = 5
-    type = 19
-
-    def __init__(self, xid=None, stats_type=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if stats_type != None:
-            self.stats_type = stats_type
-        else:
-            self.stats_type = 0
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 8)
-        subclass = stats_reply.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.stats_type = reader.read("!H")[0]
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.stats_type != other.stats_type: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[19] = stats_reply
-
-class aggregate_stats_reply(stats_reply):
-    version = 5
-    type = 19
-    stats_type = 2
-
-    def __init__(self, xid=None, flags=None, packet_count=None, byte_count=None, flow_count=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if packet_count != None:
-            self.packet_count = packet_count
-        else:
-            self.packet_count = 0
-        if byte_count != None:
-            self.byte_count = byte_count
-        else:
-            self.byte_count = 0
-        if flow_count != None:
-            self.flow_count = flow_count
-        else:
-            self.flow_count = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!Q", self.packet_count))
-        packed.append(struct.pack("!Q", self.byte_count))
-        packed.append(struct.pack("!L", self.flow_count))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = aggregate_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 2)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.packet_count = reader.read("!Q")[0]
-        obj.byte_count = reader.read("!Q")[0]
-        obj.flow_count = reader.read("!L")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.packet_count != other.packet_count: return False
-        if self.byte_count != other.byte_count: return False
-        if self.flow_count != other.flow_count: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("aggregate_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("packet_count = ");
-                q.text("%#x" % self.packet_count)
-                q.text(","); q.breakable()
-                q.text("byte_count = ");
-                q.text("%#x" % self.byte_count)
-                q.text(","); q.breakable()
-                q.text("flow_count = ");
-                q.text("%#x" % self.flow_count)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[2] = aggregate_stats_reply
-
-class stats_request(message):
-    subtypes = {}
-
-    version = 5
-    type = 18
-
-    def __init__(self, xid=None, stats_type=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if stats_type != None:
-            self.stats_type = stats_type
-        else:
-            self.stats_type = 0
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 8)
-        subclass = stats_request.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.stats_type = reader.read("!H")[0]
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.stats_type != other.stats_type: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[18] = stats_request
-
-class aggregate_stats_request(stats_request):
-    version = 5
-    type = 18
-    stats_type = 2
-
-    def __init__(self, xid=None, flags=None, table_id=None, out_port=None, out_group=None, cookie=None, cookie_mask=None, match=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if out_port != None:
-            self.out_port = out_port
-        else:
-            self.out_port = 0
-        if out_group != None:
-            self.out_group = out_group
-        else:
-            self.out_group = 0
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if cookie_mask != None:
-            self.cookie_mask = cookie_mask
-        else:
-            self.cookie_mask = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append('\x00' * 3)
-        packed.append(util.pack_port_no(self.out_port))
-        packed.append(struct.pack("!L", self.out_group))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(struct.pack("!Q", self.cookie_mask))
-        packed.append(self.match.pack())
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = aggregate_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 2)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.table_id = reader.read("!B")[0]
-        reader.skip(3)
-        obj.out_port = util.unpack_port_no(reader)
-        obj.out_group = reader.read("!L")[0]
-        reader.skip(4)
-        obj.cookie = reader.read("!Q")[0]
-        obj.cookie_mask = reader.read("!Q")[0]
-        obj.match = ofp.match.unpack(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.table_id != other.table_id: return False
-        if self.out_port != other.out_port: return False
-        if self.out_group != other.out_group: return False
-        if self.cookie != other.cookie: return False
-        if self.cookie_mask != other.cookie_mask: return False
-        if self.match != other.match: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("aggregate_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("out_port = ");
-                q.text(util.pretty_port(self.out_port))
-                q.text(","); q.breakable()
-                q.text("out_group = ");
-                q.text("%#x" % self.out_group)
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("cookie_mask = ");
-                q.text("%#x" % self.cookie_mask)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[2] = aggregate_stats_request
-
-class error_msg(message):
-    subtypes = {}
-
-    version = 5
-    type = 1
-
-    def __init__(self, xid=None, err_type=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if err_type != None:
-            self.err_type = err_type
-        else:
-            self.err_type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 8)
-        subclass = error_msg.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.err_type = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.err_type != other.err_type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-message.subtypes[1] = error_msg
-
-class async_config_failed_error_msg(error_msg):
-    version = 5
-    type = 1
-    err_type = 15
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = async_config_failed_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 15)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("async_config_failed_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[15] = async_config_failed_error_msg
-
-class async_get_reply(message):
-    version = 5
-    type = 27
-
-    def __init__(self, xid=None, properties=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if properties != None:
-            self.properties = properties
-        else:
-            self.properties = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(loxi.generic_util.pack_list(self.properties))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = async_get_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 27)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.properties = loxi.generic_util.unpack_list(reader, ofp.async_config_prop.async_config_prop.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.properties != other.properties: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("async_get_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("properties = ");
-                q.pp(self.properties)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[27] = async_get_reply
-
-class async_get_request(message):
-    version = 5
-    type = 26
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = async_get_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 26)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("async_get_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-message.subtypes[26] = async_get_request
-
-class async_set(message):
-    version = 5
-    type = 28
-
-    def __init__(self, xid=None, properties=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if properties != None:
-            self.properties = properties
-        else:
-            self.properties = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(loxi.generic_util.pack_list(self.properties))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = async_set()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 28)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.properties = loxi.generic_util.unpack_list(reader, ofp.async_config_prop.async_config_prop.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.properties != other.properties: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("async_set {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("properties = ");
-                q.pp(self.properties)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[28] = async_set
-
-class bad_action_error_msg(error_msg):
-    version = 5
-    type = 1
-    err_type = 2
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bad_action_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 2)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bad_action_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[2] = bad_action_error_msg
-
-class bad_instruction_error_msg(error_msg):
-    version = 5
-    type = 1
-    err_type = 3
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bad_instruction_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 3)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bad_instruction_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[3] = bad_instruction_error_msg
-
-class bad_match_error_msg(error_msg):
-    version = 5
-    type = 1
-    err_type = 4
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bad_match_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 4)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bad_match_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[4] = bad_match_error_msg
-
-class bad_property_error_msg(error_msg):
-    version = 5
-    type = 1
-    err_type = 14
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bad_property_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 14)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bad_property_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[14] = bad_property_error_msg
-
-class bad_request_error_msg(error_msg):
-    version = 5
-    type = 1
-    err_type = 1
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bad_request_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 1)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bad_request_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[1] = bad_request_error_msg
-
-class barrier_reply(message):
-    version = 5
-    type = 21
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = barrier_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 21)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("barrier_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-message.subtypes[21] = barrier_reply
-
-class barrier_request(message):
-    version = 5
-    type = 20
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = barrier_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 20)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("barrier_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-message.subtypes[20] = barrier_request
-
-class experimenter(message):
-    subtypes = {}
-
-    version = 5
-    type = 4
-
-    def __init__(self, xid=None, experimenter=None, subtype=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 8)
-        subclass = experimenter.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = experimenter()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.experimenter = reader.read("!L")[0]
-        obj.subtype = reader.read("!L")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.experimenter != other.experimenter: return False
-        if self.subtype != other.subtype: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("experimenter {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("subtype = ");
-                q.text("%#x" % self.subtype)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[4] = experimenter
-
-class bsn_header(experimenter):
-    subtypes = {}
-
-    version = 5
-    type = 4
-    experimenter = 6035143
-
-    def __init__(self, xid=None, subtype=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 12)
-        subclass = bsn_header.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = bsn_header()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        obj.subtype = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.subtype != other.subtype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_header {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-experimenter.subtypes[6035143] = bsn_header
-
-class bsn_arp_idle(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 60
-
-    def __init__(self, xid=None, vlan_vid=None, ipv4_addr=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if vlan_vid != None:
-            self.vlan_vid = vlan_vid
-        else:
-            self.vlan_vid = 0
-        if ipv4_addr != None:
-            self.ipv4_addr = ipv4_addr
-        else:
-            self.ipv4_addr = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!H", self.vlan_vid))
-        packed.append('\x00' * 2)
-        packed.append(struct.pack("!L", self.ipv4_addr))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_arp_idle()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 60)
-        obj.vlan_vid = reader.read("!H")[0]
-        reader.skip(2)
-        obj.ipv4_addr = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.vlan_vid != other.vlan_vid: return False
-        if self.ipv4_addr != other.ipv4_addr: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_arp_idle {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("vlan_vid = ");
-                q.text("%#x" % self.vlan_vid)
-                q.text(","); q.breakable()
-                q.text("ipv4_addr = ");
-                q.text(util.pretty_ipv4(self.ipv4_addr))
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[60] = bsn_arp_idle
-
-class experimenter_error_msg(error_msg):
-    subtypes = {}
-
-    version = 5
-    type = 1
-    err_type = 65535
-
-    def __init__(self, xid=None, subtype=None, experimenter=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.subtype))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 12)
-        subclass = experimenter_error_msg.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = experimenter_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 65535)
-        obj.subtype = reader.read("!H")[0]
-        obj.experimenter = reader.read("!L")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.subtype != other.subtype: return False
-        if self.experimenter != other.experimenter: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("experimenter_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("subtype = ");
-                q.text("%#x" % self.subtype)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[65535] = experimenter_error_msg
-
-class bsn_base_error(experimenter_error_msg):
-    subtypes = {}
-
-    version = 5
-    type = 1
-    err_type = 65535
-    experimenter = 6035143
-
-    def __init__(self, xid=None, subtype=None, err_msg=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        if err_msg != None:
-            self.err_msg = err_msg
-        else:
-            self.err_msg = ""
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.subtype))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!256s", self.err_msg))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 10)
-        subclass = bsn_base_error.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = bsn_base_error()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 65535)
-        obj.subtype = reader.read("!H")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        obj.err_msg = reader.read("!256s")[0].rstrip("\x00")
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.subtype != other.subtype: return False
-        if self.err_msg != other.err_msg: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_base_error {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("err_msg = ");
-                q.pp(self.err_msg)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-experimenter_error_msg.subtypes[6035143] = bsn_base_error
-
-class bsn_bw_clear_data_reply(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 22
-
-    def __init__(self, xid=None, status=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if status != None:
-            self.status = status
-        else:
-            self.status = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.status))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_bw_clear_data_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 22)
-        obj.status = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.status != other.status: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_bw_clear_data_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("status = ");
-                q.text("%#x" % self.status)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[22] = bsn_bw_clear_data_reply
-
-class bsn_bw_clear_data_request(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 21
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_bw_clear_data_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 21)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_bw_clear_data_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[21] = bsn_bw_clear_data_request
-
-class bsn_bw_enable_get_reply(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 20
-
-    def __init__(self, xid=None, enabled=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if enabled != None:
-            self.enabled = enabled
-        else:
-            self.enabled = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.enabled))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_bw_enable_get_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 20)
-        obj.enabled = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.enabled != other.enabled: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_bw_enable_get_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("enabled = ");
-                q.text("%#x" % self.enabled)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[20] = bsn_bw_enable_get_reply
-
-class bsn_bw_enable_get_request(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 19
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_bw_enable_get_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 19)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_bw_enable_get_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[19] = bsn_bw_enable_get_request
-
-class bsn_bw_enable_set_reply(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 23
-
-    def __init__(self, xid=None, enable=None, status=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if enable != None:
-            self.enable = enable
-        else:
-            self.enable = 0
-        if status != None:
-            self.status = status
-        else:
-            self.status = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.enable))
-        packed.append(struct.pack("!L", self.status))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_bw_enable_set_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 23)
-        obj.enable = reader.read("!L")[0]
-        obj.status = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.enable != other.enable: return False
-        if self.status != other.status: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_bw_enable_set_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("enable = ");
-                q.text("%#x" % self.enable)
-                q.text(","); q.breakable()
-                q.text("status = ");
-                q.text("%#x" % self.status)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[23] = bsn_bw_enable_set_reply
-
-class bsn_bw_enable_set_request(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 18
-
-    def __init__(self, xid=None, enable=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if enable != None:
-            self.enable = enable
-        else:
-            self.enable = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.enable))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_bw_enable_set_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 18)
-        obj.enable = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.enable != other.enable: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_bw_enable_set_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("enable = ");
-                q.text("%#x" % self.enable)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[18] = bsn_bw_enable_set_request
-
-class bsn_controller_connections_reply(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 57
-
-    def __init__(self, xid=None, connections=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if connections != None:
-            self.connections = connections
-        else:
-            self.connections = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(loxi.generic_util.pack_list(self.connections))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_controller_connections_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 57)
-        obj.connections = loxi.generic_util.unpack_list(reader, ofp.common.bsn_controller_connection.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.connections != other.connections: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_controller_connections_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("connections = ");
-                q.pp(self.connections)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[57] = bsn_controller_connections_reply
-
-class bsn_controller_connections_request(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 56
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_controller_connections_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 56)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_controller_connections_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[56] = bsn_controller_connections_request
-
-class experimenter_stats_reply(stats_reply):
-    subtypes = {}
-
-    version = 5
-    type = 19
-    stats_type = 65535
-
-    def __init__(self, xid=None, flags=None, experimenter=None, subtype=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 16)
-        subclass = experimenter_stats_reply.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = experimenter_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.experimenter = reader.read("!L")[0]
-        obj.subtype = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.experimenter != other.experimenter: return False
-        if self.subtype != other.subtype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("experimenter_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("subtype = ");
-                q.text("%#x" % self.subtype)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[65535] = experimenter_stats_reply
-
-class bsn_stats_reply(experimenter_stats_reply):
-    subtypes = {}
-
-    version = 5
-    type = 19
-    stats_type = 65535
-    experimenter = 6035143
-
-    def __init__(self, xid=None, flags=None, subtype=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 20)
-        subclass = bsn_stats_reply.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = bsn_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        obj.subtype = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.subtype != other.subtype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-experimenter_stats_reply.subtypes[6035143] = bsn_stats_reply
-
-class bsn_debug_counter_desc_stats_reply(bsn_stats_reply):
-    version = 5
-    type = 19
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 13
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_debug_counter_desc_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 13)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.bsn_debug_counter_desc_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_debug_counter_desc_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_reply.subtypes[13] = bsn_debug_counter_desc_stats_reply
-
-class experimenter_stats_request(stats_request):
-    subtypes = {}
-
-    version = 5
-    type = 18
-    stats_type = 65535
-
-    def __init__(self, xid=None, flags=None, experimenter=None, subtype=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 16)
-        subclass = experimenter_stats_request.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = experimenter_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.experimenter = reader.read("!L")[0]
-        obj.subtype = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.experimenter != other.experimenter: return False
-        if self.subtype != other.subtype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("experimenter_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("subtype = ");
-                q.text("%#x" % self.subtype)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[65535] = experimenter_stats_request
-
-class bsn_stats_request(experimenter_stats_request):
-    subtypes = {}
-
-    version = 5
-    type = 18
-    stats_type = 65535
-    experimenter = 6035143
-
-    def __init__(self, xid=None, flags=None, subtype=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 20)
-        subclass = bsn_stats_request.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = bsn_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        obj.subtype = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.subtype != other.subtype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-experimenter_stats_request.subtypes[6035143] = bsn_stats_request
-
-class bsn_debug_counter_desc_stats_request(bsn_stats_request):
-    version = 5
-    type = 18
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 13
-
-    def __init__(self, xid=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_debug_counter_desc_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 13)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_debug_counter_desc_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_request.subtypes[13] = bsn_debug_counter_desc_stats_request
-
-class bsn_debug_counter_stats_reply(bsn_stats_reply):
-    version = 5
-    type = 19
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 12
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_debug_counter_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 12)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.bsn_debug_counter_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_debug_counter_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_reply.subtypes[12] = bsn_debug_counter_stats_reply
-
-class bsn_debug_counter_stats_request(bsn_stats_request):
-    version = 5
-    type = 18
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 12
-
-    def __init__(self, xid=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_debug_counter_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 12)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_debug_counter_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_request.subtypes[12] = bsn_debug_counter_stats_request
-
-class bsn_error(bsn_base_error):
-    version = 5
-    type = 1
-    err_type = 65535
-    subtype = 1
-    experimenter = 6035143
-
-    def __init__(self, xid=None, err_msg=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if err_msg != None:
-            self.err_msg = err_msg
-        else:
-            self.err_msg = ""
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.subtype))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!256s", self.err_msg))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_error()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 65535)
-        _subtype = reader.read("!H")[0]
-        assert(_subtype == 1)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        obj.err_msg = reader.read("!256s")[0].rstrip("\x00")
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.err_msg != other.err_msg: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_error {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("err_msg = ");
-                q.pp(self.err_msg)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-bsn_base_error.subtypes[1] = bsn_error
-
-class bsn_flow_checksum_bucket_stats_reply(bsn_stats_reply):
-    version = 5
-    type = 19
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 10
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_flow_checksum_bucket_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 10)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.bsn_flow_checksum_bucket_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_flow_checksum_bucket_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_reply.subtypes[10] = bsn_flow_checksum_bucket_stats_reply
-
-class bsn_flow_checksum_bucket_stats_request(bsn_stats_request):
-    version = 5
-    type = 18
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 10
-
-    def __init__(self, xid=None, flags=None, table_id=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!B", self.table_id))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_flow_checksum_bucket_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 10)
-        obj.table_id = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.table_id != other.table_id: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_flow_checksum_bucket_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_request.subtypes[10] = bsn_flow_checksum_bucket_stats_request
-
-class bsn_flow_idle(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 40
-
-    def __init__(self, xid=None, cookie=None, priority=None, table_id=None, match=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if priority != None:
-            self.priority = priority
-        else:
-            self.priority = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(struct.pack("!H", self.priority))
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append('\x00' * 5)
-        packed.append(self.match.pack())
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_flow_idle()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 40)
-        obj.cookie = reader.read("!Q")[0]
-        obj.priority = reader.read("!H")[0]
-        obj.table_id = reader.read("!B")[0]
-        reader.skip(5)
-        obj.match = ofp.match.unpack(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.cookie != other.cookie: return False
-        if self.priority != other.priority: return False
-        if self.table_id != other.table_id: return False
-        if self.match != other.match: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_flow_idle {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("priority = ");
-                q.text("%#x" % self.priority)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[40] = bsn_flow_idle
-
-class bsn_flow_idle_enable_get_reply(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 39
-
-    def __init__(self, xid=None, enabled=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if enabled != None:
-            self.enabled = enabled
-        else:
-            self.enabled = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.enabled))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_flow_idle_enable_get_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 39)
-        obj.enabled = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.enabled != other.enabled: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_flow_idle_enable_get_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("enabled = ");
-                q.text("%#x" % self.enabled)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[39] = bsn_flow_idle_enable_get_reply
-
-class bsn_flow_idle_enable_get_request(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 38
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_flow_idle_enable_get_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 38)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_flow_idle_enable_get_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[38] = bsn_flow_idle_enable_get_request
-
-class bsn_flow_idle_enable_set_reply(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 37
-
-    def __init__(self, xid=None, enable=None, status=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if enable != None:
-            self.enable = enable
-        else:
-            self.enable = 0
-        if status != None:
-            self.status = status
-        else:
-            self.status = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.enable))
-        packed.append(struct.pack("!L", self.status))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_flow_idle_enable_set_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 37)
-        obj.enable = reader.read("!L")[0]
-        obj.status = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.enable != other.enable: return False
-        if self.status != other.status: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_flow_idle_enable_set_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("enable = ");
-                q.text("%#x" % self.enable)
-                q.text(","); q.breakable()
-                q.text("status = ");
-                q.text("%#x" % self.status)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[37] = bsn_flow_idle_enable_set_reply
-
-class bsn_flow_idle_enable_set_request(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 36
-
-    def __init__(self, xid=None, enable=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if enable != None:
-            self.enable = enable
-        else:
-            self.enable = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.enable))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_flow_idle_enable_set_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 36)
-        obj.enable = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.enable != other.enable: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_flow_idle_enable_set_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("enable = ");
-                q.text("%#x" % self.enable)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[36] = bsn_flow_idle_enable_set_request
-
-class bsn_generic_async(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 68
-
-    def __init__(self, xid=None, name=None, tlvs=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if name != None:
-            self.name = name
-        else:
-            self.name = ""
-        if tlvs != None:
-            self.tlvs = tlvs
-        else:
-            self.tlvs = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!64s", self.name))
-        packed.append(loxi.generic_util.pack_list(self.tlvs))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_generic_async()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 68)
-        obj.name = reader.read("!64s")[0].rstrip("\x00")
-        obj.tlvs = loxi.generic_util.unpack_list(reader, ofp.bsn_tlv.bsn_tlv.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.name != other.name: return False
-        if self.tlvs != other.tlvs: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_generic_async {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("name = ");
-                q.pp(self.name)
-                q.text(","); q.breakable()
-                q.text("tlvs = ");
-                q.pp(self.tlvs)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[68] = bsn_generic_async
-
-class bsn_generic_command(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 71
-
-    def __init__(self, xid=None, name=None, tlvs=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if name != None:
-            self.name = name
-        else:
-            self.name = ""
-        if tlvs != None:
-            self.tlvs = tlvs
-        else:
-            self.tlvs = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!64s", self.name))
-        packed.append(loxi.generic_util.pack_list(self.tlvs))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_generic_command()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 71)
-        obj.name = reader.read("!64s")[0].rstrip("\x00")
-        obj.tlvs = loxi.generic_util.unpack_list(reader, ofp.bsn_tlv.bsn_tlv.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.name != other.name: return False
-        if self.tlvs != other.tlvs: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_generic_command {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("name = ");
-                q.pp(self.name)
-                q.text(","); q.breakable()
-                q.text("tlvs = ");
-                q.pp(self.tlvs)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[71] = bsn_generic_command
-
-class bsn_generic_stats_reply(bsn_stats_reply):
-    version = 5
-    type = 19
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 16
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_generic_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 16)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.bsn_generic_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_generic_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_reply.subtypes[16] = bsn_generic_stats_reply
-
-class bsn_generic_stats_request(bsn_stats_request):
-    version = 5
-    type = 18
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 16
-
-    def __init__(self, xid=None, flags=None, name=None, tlvs=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if name != None:
-            self.name = name
-        else:
-            self.name = ""
-        if tlvs != None:
-            self.tlvs = tlvs
-        else:
-            self.tlvs = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!64s", self.name))
-        packed.append(loxi.generic_util.pack_list(self.tlvs))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_generic_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 16)
-        obj.name = reader.read("!64s")[0].rstrip("\x00")
-        obj.tlvs = loxi.generic_util.unpack_list(reader, ofp.bsn_tlv.bsn_tlv.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.name != other.name: return False
-        if self.tlvs != other.tlvs: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_generic_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("name = ");
-                q.pp(self.name)
-                q.text(","); q.breakable()
-                q.text("tlvs = ");
-                q.pp(self.tlvs)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_request.subtypes[16] = bsn_generic_stats_request
-
-class bsn_gentable_bucket_stats_reply(bsn_stats_reply):
-    version = 5
-    type = 19
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 5
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_gentable_bucket_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 5)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.bsn_gentable_bucket_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_gentable_bucket_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_reply.subtypes[5] = bsn_gentable_bucket_stats_reply
-
-class bsn_gentable_bucket_stats_request(bsn_stats_request):
-    version = 5
-    type = 18
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 5
-
-    def __init__(self, xid=None, flags=None, table_id=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!H", self.table_id))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_gentable_bucket_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 5)
-        obj.table_id = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.table_id != other.table_id: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_gentable_bucket_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_request.subtypes[5] = bsn_gentable_bucket_stats_request
-
-class bsn_gentable_clear_reply(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 49
-
-    def __init__(self, xid=None, table_id=None, deleted_count=None, error_count=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if deleted_count != None:
-            self.deleted_count = deleted_count
-        else:
-            self.deleted_count = 0
-        if error_count != None:
-            self.error_count = error_count
-        else:
-            self.error_count = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!H", self.table_id))
-        packed.append('\x00' * 2)
-        packed.append(struct.pack("!L", self.deleted_count))
-        packed.append(struct.pack("!L", self.error_count))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_gentable_clear_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 49)
-        obj.table_id = reader.read("!H")[0]
-        reader.skip(2)
-        obj.deleted_count = reader.read("!L")[0]
-        obj.error_count = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.table_id != other.table_id: return False
-        if self.deleted_count != other.deleted_count: return False
-        if self.error_count != other.error_count: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_gentable_clear_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("deleted_count = ");
-                q.text("%#x" % self.deleted_count)
-                q.text(","); q.breakable()
-                q.text("error_count = ");
-                q.text("%#x" % self.error_count)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[49] = bsn_gentable_clear_reply
-
-class bsn_gentable_clear_request(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 48
-
-    def __init__(self, xid=None, table_id=None, checksum=None, checksum_mask=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if checksum != None:
-            self.checksum = checksum
-        else:
-            self.checksum = 0
-        if checksum_mask != None:
-            self.checksum_mask = checksum_mask
-        else:
-            self.checksum_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!H", self.table_id))
-        packed.append('\x00' * 2)
-        packed.append(util.pack_checksum_128(self.checksum))
-        packed.append(util.pack_checksum_128(self.checksum_mask))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_gentable_clear_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 48)
-        obj.table_id = reader.read("!H")[0]
-        reader.skip(2)
-        obj.checksum = util.unpack_checksum_128(reader)
-        obj.checksum_mask = util.unpack_checksum_128(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.table_id != other.table_id: return False
-        if self.checksum != other.checksum: return False
-        if self.checksum_mask != other.checksum_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_gentable_clear_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("checksum = ");
-                q.pp(self.checksum)
-                q.text(","); q.breakable()
-                q.text("checksum_mask = ");
-                q.pp(self.checksum_mask)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[48] = bsn_gentable_clear_request
-
-class bsn_gentable_desc_stats_reply(bsn_stats_reply):
-    version = 5
-    type = 19
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 4
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_gentable_desc_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 4)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.bsn_gentable_desc_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_gentable_desc_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_reply.subtypes[4] = bsn_gentable_desc_stats_reply
-
-class bsn_gentable_desc_stats_request(bsn_stats_request):
-    version = 5
-    type = 18
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 4
-
-    def __init__(self, xid=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_gentable_desc_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_gentable_desc_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_request.subtypes[4] = bsn_gentable_desc_stats_request
-
-class bsn_gentable_entry_add(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 46
-
-    def __init__(self, xid=None, table_id=None, checksum=None, key=None, value=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if checksum != None:
-            self.checksum = checksum
-        else:
-            self.checksum = 0
-        if key != None:
-            self.key = key
-        else:
-            self.key = []
-        if value != None:
-            self.value = value
-        else:
-            self.value = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!H", self.table_id))
-        packed.append(struct.pack("!H", 0)) # placeholder for key_length at index 7
-        packed.append(util.pack_checksum_128(self.checksum))
-        packed.append(loxi.generic_util.pack_list(self.key))
-        packed[7] = struct.pack("!H", len(packed[-1]))
-        packed.append(loxi.generic_util.pack_list(self.value))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_gentable_entry_add()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 46)
-        obj.table_id = reader.read("!H")[0]
-        _key_length = reader.read("!H")[0]
-        obj.checksum = util.unpack_checksum_128(reader)
-        obj.key = loxi.generic_util.unpack_list(reader.slice(_key_length), ofp.bsn_tlv.bsn_tlv.unpack)
-        obj.value = loxi.generic_util.unpack_list(reader, ofp.bsn_tlv.bsn_tlv.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.table_id != other.table_id: return False
-        if self.checksum != other.checksum: return False
-        if self.key != other.key: return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_gentable_entry_add {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("checksum = ");
-                q.pp(self.checksum)
-                q.text(","); q.breakable()
-                q.text("key = ");
-                q.pp(self.key)
-                q.text(","); q.breakable()
-                q.text("value = ");
-                q.pp(self.value)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[46] = bsn_gentable_entry_add
-
-class bsn_gentable_entry_delete(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 47
-
-    def __init__(self, xid=None, table_id=None, key=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if key != None:
-            self.key = key
-        else:
-            self.key = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!H", self.table_id))
-        packed.append(loxi.generic_util.pack_list(self.key))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_gentable_entry_delete()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 47)
-        obj.table_id = reader.read("!H")[0]
-        obj.key = loxi.generic_util.unpack_list(reader, ofp.bsn_tlv.bsn_tlv.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.table_id != other.table_id: return False
-        if self.key != other.key: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_gentable_entry_delete {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("key = ");
-                q.pp(self.key)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[47] = bsn_gentable_entry_delete
-
-class bsn_gentable_entry_desc_stats_reply(bsn_stats_reply):
-    version = 5
-    type = 19
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 2
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_gentable_entry_desc_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 2)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.bsn_gentable_entry_desc_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_gentable_entry_desc_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_reply.subtypes[2] = bsn_gentable_entry_desc_stats_reply
-
-class bsn_gentable_entry_desc_stats_request(bsn_stats_request):
-    version = 5
-    type = 18
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 2
-
-    def __init__(self, xid=None, flags=None, table_id=None, checksum=None, checksum_mask=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if checksum != None:
-            self.checksum = checksum
-        else:
-            self.checksum = 0
-        if checksum_mask != None:
-            self.checksum_mask = checksum_mask
-        else:
-            self.checksum_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!H", self.table_id))
-        packed.append('\x00' * 2)
-        packed.append(util.pack_checksum_128(self.checksum))
-        packed.append(util.pack_checksum_128(self.checksum_mask))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_gentable_entry_desc_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 2)
-        obj.table_id = reader.read("!H")[0]
-        reader.skip(2)
-        obj.checksum = util.unpack_checksum_128(reader)
-        obj.checksum_mask = util.unpack_checksum_128(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.table_id != other.table_id: return False
-        if self.checksum != other.checksum: return False
-        if self.checksum_mask != other.checksum_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_gentable_entry_desc_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("checksum = ");
-                q.pp(self.checksum)
-                q.text(","); q.breakable()
-                q.text("checksum_mask = ");
-                q.pp(self.checksum_mask)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_request.subtypes[2] = bsn_gentable_entry_desc_stats_request
-
-class bsn_gentable_entry_stats_reply(bsn_stats_reply):
-    version = 5
-    type = 19
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 3
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_gentable_entry_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 3)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.bsn_gentable_entry_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_gentable_entry_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_reply.subtypes[3] = bsn_gentable_entry_stats_reply
-
-class bsn_gentable_entry_stats_request(bsn_stats_request):
-    version = 5
-    type = 18
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 3
-
-    def __init__(self, xid=None, flags=None, table_id=None, checksum=None, checksum_mask=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if checksum != None:
-            self.checksum = checksum
-        else:
-            self.checksum = 0
-        if checksum_mask != None:
-            self.checksum_mask = checksum_mask
-        else:
-            self.checksum_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!H", self.table_id))
-        packed.append('\x00' * 2)
-        packed.append(util.pack_checksum_128(self.checksum))
-        packed.append(util.pack_checksum_128(self.checksum_mask))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_gentable_entry_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 3)
-        obj.table_id = reader.read("!H")[0]
-        reader.skip(2)
-        obj.checksum = util.unpack_checksum_128(reader)
-        obj.checksum_mask = util.unpack_checksum_128(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.table_id != other.table_id: return False
-        if self.checksum != other.checksum: return False
-        if self.checksum_mask != other.checksum_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_gentable_entry_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("checksum = ");
-                q.pp(self.checksum)
-                q.text(","); q.breakable()
-                q.text("checksum_mask = ");
-                q.pp(self.checksum_mask)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_request.subtypes[3] = bsn_gentable_entry_stats_request
-
-class bsn_gentable_set_buckets_size(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 50
-
-    def __init__(self, xid=None, table_id=None, buckets_size=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if buckets_size != None:
-            self.buckets_size = buckets_size
-        else:
-            self.buckets_size = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!H", self.table_id))
-        packed.append('\x00' * 2)
-        packed.append(struct.pack("!L", self.buckets_size))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_gentable_set_buckets_size()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 50)
-        obj.table_id = reader.read("!H")[0]
-        reader.skip(2)
-        obj.buckets_size = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.table_id != other.table_id: return False
-        if self.buckets_size != other.buckets_size: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_gentable_set_buckets_size {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("buckets_size = ");
-                q.text("%#x" % self.buckets_size)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[50] = bsn_gentable_set_buckets_size
-
-class bsn_gentable_stats_reply(bsn_stats_reply):
-    version = 5
-    type = 19
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 7
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_gentable_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 7)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.bsn_gentable_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_gentable_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_reply.subtypes[7] = bsn_gentable_stats_reply
-
-class bsn_gentable_stats_request(bsn_stats_request):
-    version = 5
-    type = 18
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 7
-
-    def __init__(self, xid=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_gentable_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 7)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_gentable_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_request.subtypes[7] = bsn_gentable_stats_request
-
-class bsn_get_interfaces_reply(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 10
-
-    def __init__(self, xid=None, interfaces=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if interfaces != None:
-            self.interfaces = interfaces
-        else:
-            self.interfaces = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(loxi.generic_util.pack_list(self.interfaces))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_get_interfaces_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 10)
-        obj.interfaces = loxi.generic_util.unpack_list(reader, ofp.common.bsn_interface.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.interfaces != other.interfaces: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_get_interfaces_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("interfaces = ");
-                q.pp(self.interfaces)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[10] = bsn_get_interfaces_reply
-
-class bsn_get_interfaces_request(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 9
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_get_interfaces_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 9)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_get_interfaces_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[9] = bsn_get_interfaces_request
-
-class bsn_get_mirroring_reply(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 5
-
-    def __init__(self, xid=None, report_mirror_ports=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if report_mirror_ports != None:
-            self.report_mirror_ports = report_mirror_ports
-        else:
-            self.report_mirror_ports = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!B", self.report_mirror_ports))
-        packed.append('\x00' * 3)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_get_mirroring_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 5)
-        obj.report_mirror_ports = reader.read("!B")[0]
-        reader.skip(3)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.report_mirror_ports != other.report_mirror_ports: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_get_mirroring_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("report_mirror_ports = ");
-                q.text("%#x" % self.report_mirror_ports)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[5] = bsn_get_mirroring_reply
-
-class bsn_get_mirroring_request(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 4
-
-    def __init__(self, xid=None, report_mirror_ports=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if report_mirror_ports != None:
-            self.report_mirror_ports = report_mirror_ports
-        else:
-            self.report_mirror_ports = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!B", self.report_mirror_ports))
-        packed.append('\x00' * 3)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_get_mirroring_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 4)
-        obj.report_mirror_ports = reader.read("!B")[0]
-        reader.skip(3)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.report_mirror_ports != other.report_mirror_ports: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_get_mirroring_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("report_mirror_ports = ");
-                q.text("%#x" % self.report_mirror_ports)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[4] = bsn_get_mirroring_request
-
-class bsn_get_switch_pipeline_reply(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 52
-
-    def __init__(self, xid=None, pipeline=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if pipeline != None:
-            self.pipeline = pipeline
-        else:
-            self.pipeline = ""
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!256s", self.pipeline))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_get_switch_pipeline_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 52)
-        obj.pipeline = reader.read("!256s")[0].rstrip("\x00")
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.pipeline != other.pipeline: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_get_switch_pipeline_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("pipeline = ");
-                q.pp(self.pipeline)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[52] = bsn_get_switch_pipeline_reply
-
-class bsn_get_switch_pipeline_request(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 51
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_get_switch_pipeline_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 51)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_get_switch_pipeline_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[51] = bsn_get_switch_pipeline_request
-
-class bsn_image_desc_stats_reply(bsn_stats_reply):
-    version = 5
-    type = 19
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 14
-
-    def __init__(self, xid=None, flags=None, image_checksum=None, startup_config_checksum=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if image_checksum != None:
-            self.image_checksum = image_checksum
-        else:
-            self.image_checksum = ""
-        if startup_config_checksum != None:
-            self.startup_config_checksum = startup_config_checksum
-        else:
-            self.startup_config_checksum = ""
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!256s", self.image_checksum))
-        packed.append(struct.pack("!256s", self.startup_config_checksum))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_image_desc_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 14)
-        obj.image_checksum = reader.read("!256s")[0].rstrip("\x00")
-        obj.startup_config_checksum = reader.read("!256s")[0].rstrip("\x00")
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.image_checksum != other.image_checksum: return False
-        if self.startup_config_checksum != other.startup_config_checksum: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_image_desc_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("image_checksum = ");
-                q.pp(self.image_checksum)
-                q.text(","); q.breakable()
-                q.text("startup_config_checksum = ");
-                q.pp(self.startup_config_checksum)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_reply.subtypes[14] = bsn_image_desc_stats_reply
-
-class bsn_image_desc_stats_request(bsn_stats_request):
-    version = 5
-    type = 18
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 14
-
-    def __init__(self, xid=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_image_desc_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 14)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_image_desc_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_request.subtypes[14] = bsn_image_desc_stats_request
-
-class bsn_lacp_convergence_notif(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 43
-
-    def __init__(self, xid=None, convergence_status=None, port_no=None, actor_sys_priority=None, actor_sys_mac=None, actor_port_priority=None, actor_port_num=None, actor_key=None, partner_sys_priority=None, partner_sys_mac=None, partner_port_priority=None, partner_port_num=None, partner_key=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if convergence_status != None:
-            self.convergence_status = convergence_status
-        else:
-            self.convergence_status = 0
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if actor_sys_priority != None:
-            self.actor_sys_priority = actor_sys_priority
-        else:
-            self.actor_sys_priority = 0
-        if actor_sys_mac != None:
-            self.actor_sys_mac = actor_sys_mac
-        else:
-            self.actor_sys_mac = [0,0,0,0,0,0]
-        if actor_port_priority != None:
-            self.actor_port_priority = actor_port_priority
-        else:
-            self.actor_port_priority = 0
-        if actor_port_num != None:
-            self.actor_port_num = actor_port_num
-        else:
-            self.actor_port_num = 0
-        if actor_key != None:
-            self.actor_key = actor_key
-        else:
-            self.actor_key = 0
-        if partner_sys_priority != None:
-            self.partner_sys_priority = partner_sys_priority
-        else:
-            self.partner_sys_priority = 0
-        if partner_sys_mac != None:
-            self.partner_sys_mac = partner_sys_mac
-        else:
-            self.partner_sys_mac = [0,0,0,0,0,0]
-        if partner_port_priority != None:
-            self.partner_port_priority = partner_port_priority
-        else:
-            self.partner_port_priority = 0
-        if partner_port_num != None:
-            self.partner_port_num = partner_port_num
-        else:
-            self.partner_port_num = 0
-        if partner_key != None:
-            self.partner_key = partner_key
-        else:
-            self.partner_key = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!B", self.convergence_status))
-        packed.append('\x00' * 3)
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(struct.pack("!H", self.actor_sys_priority))
-        packed.append(struct.pack("!6B", *self.actor_sys_mac))
-        packed.append(struct.pack("!H", self.actor_port_priority))
-        packed.append(struct.pack("!H", self.actor_port_num))
-        packed.append(struct.pack("!H", self.actor_key))
-        packed.append(struct.pack("!H", self.partner_sys_priority))
-        packed.append(struct.pack("!6B", *self.partner_sys_mac))
-        packed.append(struct.pack("!H", self.partner_port_priority))
-        packed.append(struct.pack("!H", self.partner_port_num))
-        packed.append(struct.pack("!H", self.partner_key))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_lacp_convergence_notif()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 43)
-        obj.convergence_status = reader.read("!B")[0]
-        reader.skip(3)
-        obj.port_no = util.unpack_port_no(reader)
-        obj.actor_sys_priority = reader.read("!H")[0]
-        obj.actor_sys_mac = list(reader.read('!6B'))
-        obj.actor_port_priority = reader.read("!H")[0]
-        obj.actor_port_num = reader.read("!H")[0]
-        obj.actor_key = reader.read("!H")[0]
-        obj.partner_sys_priority = reader.read("!H")[0]
-        obj.partner_sys_mac = list(reader.read('!6B'))
-        obj.partner_port_priority = reader.read("!H")[0]
-        obj.partner_port_num = reader.read("!H")[0]
-        obj.partner_key = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.convergence_status != other.convergence_status: return False
-        if self.port_no != other.port_no: return False
-        if self.actor_sys_priority != other.actor_sys_priority: return False
-        if self.actor_sys_mac != other.actor_sys_mac: return False
-        if self.actor_port_priority != other.actor_port_priority: return False
-        if self.actor_port_num != other.actor_port_num: return False
-        if self.actor_key != other.actor_key: return False
-        if self.partner_sys_priority != other.partner_sys_priority: return False
-        if self.partner_sys_mac != other.partner_sys_mac: return False
-        if self.partner_port_priority != other.partner_port_priority: return False
-        if self.partner_port_num != other.partner_port_num: return False
-        if self.partner_key != other.partner_key: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_lacp_convergence_notif {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("convergence_status = ");
-                q.text("%#x" % self.convergence_status)
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("actor_sys_priority = ");
-                q.text("%#x" % self.actor_sys_priority)
-                q.text(","); q.breakable()
-                q.text("actor_sys_mac = ");
-                q.text(util.pretty_mac(self.actor_sys_mac))
-                q.text(","); q.breakable()
-                q.text("actor_port_priority = ");
-                q.text("%#x" % self.actor_port_priority)
-                q.text(","); q.breakable()
-                q.text("actor_port_num = ");
-                q.text("%#x" % self.actor_port_num)
-                q.text(","); q.breakable()
-                q.text("actor_key = ");
-                q.text("%#x" % self.actor_key)
-                q.text(","); q.breakable()
-                q.text("partner_sys_priority = ");
-                q.text("%#x" % self.partner_sys_priority)
-                q.text(","); q.breakable()
-                q.text("partner_sys_mac = ");
-                q.text(util.pretty_mac(self.partner_sys_mac))
-                q.text(","); q.breakable()
-                q.text("partner_port_priority = ");
-                q.text("%#x" % self.partner_port_priority)
-                q.text(","); q.breakable()
-                q.text("partner_port_num = ");
-                q.text("%#x" % self.partner_port_num)
-                q.text(","); q.breakable()
-                q.text("partner_key = ");
-                q.text("%#x" % self.partner_key)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[43] = bsn_lacp_convergence_notif
-
-class bsn_lacp_stats_reply(bsn_stats_reply):
-    version = 5
-    type = 19
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 1
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_lacp_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 1)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.bsn_lacp_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_lacp_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_reply.subtypes[1] = bsn_lacp_stats_reply
-
-class bsn_lacp_stats_request(bsn_stats_request):
-    version = 5
-    type = 18
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 1
-
-    def __init__(self, xid=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_lacp_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 1)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_lacp_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_request.subtypes[1] = bsn_lacp_stats_request
-
-class bsn_log(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 63
-
-    def __init__(self, xid=None, loglevel=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if loglevel != None:
-            self.loglevel = loglevel
-        else:
-            self.loglevel = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!B", self.loglevel))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_log()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 63)
-        obj.loglevel = reader.read("!B")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.loglevel != other.loglevel: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_log {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("loglevel = ");
-                q.text("%#x" % self.loglevel)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[63] = bsn_log
-
-class bsn_lua_command_reply(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 66
-
-    def __init__(self, xid=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_lua_command_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 66)
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_lua_command_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[66] = bsn_lua_command_reply
-
-class bsn_lua_command_request(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 65
-
-    def __init__(self, xid=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_lua_command_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 65)
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_lua_command_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[65] = bsn_lua_command_request
-
-class bsn_lua_notification(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 67
-
-    def __init__(self, xid=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_lua_notification()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 67)
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_lua_notification {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[67] = bsn_lua_notification
-
-class bsn_lua_upload(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 64
-
-    def __init__(self, xid=None, flags=None, filename=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if filename != None:
-            self.filename = filename
-        else:
-            self.filename = ""
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append(struct.pack("!64s", self.filename))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_lua_upload()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 64)
-        obj.flags = reader.read("!H")[0]
-        obj.filename = reader.read("!64s")[0].rstrip("\x00")
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.filename != other.filename: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_lua_upload {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("filename = ");
-                q.pp(self.filename)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[64] = bsn_lua_upload
-
-class bsn_pdu_rx_reply(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 34
-
-    def __init__(self, xid=None, status=None, port_no=None, slot_num=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if status != None:
-            self.status = status
-        else:
-            self.status = 0
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if slot_num != None:
-            self.slot_num = slot_num
-        else:
-            self.slot_num = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.status))
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(struct.pack("!B", self.slot_num))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_pdu_rx_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 34)
-        obj.status = reader.read("!L")[0]
-        obj.port_no = util.unpack_port_no(reader)
-        obj.slot_num = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.status != other.status: return False
-        if self.port_no != other.port_no: return False
-        if self.slot_num != other.slot_num: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_pdu_rx_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("status = ");
-                q.text("%#x" % self.status)
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("slot_num = ");
-                q.text("%#x" % self.slot_num)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[34] = bsn_pdu_rx_reply
-
-class bsn_pdu_rx_request(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 33
-
-    def __init__(self, xid=None, timeout_ms=None, port_no=None, slot_num=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if timeout_ms != None:
-            self.timeout_ms = timeout_ms
-        else:
-            self.timeout_ms = 0
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if slot_num != None:
-            self.slot_num = slot_num
-        else:
-            self.slot_num = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.timeout_ms))
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(struct.pack("!B", self.slot_num))
-        packed.append('\x00' * 3)
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_pdu_rx_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 33)
-        obj.timeout_ms = reader.read("!L")[0]
-        obj.port_no = util.unpack_port_no(reader)
-        obj.slot_num = reader.read("!B")[0]
-        reader.skip(3)
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.timeout_ms != other.timeout_ms: return False
-        if self.port_no != other.port_no: return False
-        if self.slot_num != other.slot_num: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_pdu_rx_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("timeout_ms = ");
-                q.text("%#x" % self.timeout_ms)
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("slot_num = ");
-                q.text("%#x" % self.slot_num)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[33] = bsn_pdu_rx_request
-
-class bsn_pdu_rx_timeout(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 35
-
-    def __init__(self, xid=None, port_no=None, slot_num=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if slot_num != None:
-            self.slot_num = slot_num
-        else:
-            self.slot_num = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(struct.pack("!B", self.slot_num))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_pdu_rx_timeout()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 35)
-        obj.port_no = util.unpack_port_no(reader)
-        obj.slot_num = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.port_no != other.port_no: return False
-        if self.slot_num != other.slot_num: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_pdu_rx_timeout {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("slot_num = ");
-                q.text("%#x" % self.slot_num)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[35] = bsn_pdu_rx_timeout
-
-class bsn_pdu_tx_reply(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 32
-
-    def __init__(self, xid=None, status=None, port_no=None, slot_num=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if status != None:
-            self.status = status
-        else:
-            self.status = 0
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if slot_num != None:
-            self.slot_num = slot_num
-        else:
-            self.slot_num = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.status))
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(struct.pack("!B", self.slot_num))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_pdu_tx_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 32)
-        obj.status = reader.read("!L")[0]
-        obj.port_no = util.unpack_port_no(reader)
-        obj.slot_num = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.status != other.status: return False
-        if self.port_no != other.port_no: return False
-        if self.slot_num != other.slot_num: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_pdu_tx_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("status = ");
-                q.text("%#x" % self.status)
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("slot_num = ");
-                q.text("%#x" % self.slot_num)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[32] = bsn_pdu_tx_reply
-
-class bsn_pdu_tx_request(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 31
-
-    def __init__(self, xid=None, tx_interval_ms=None, port_no=None, slot_num=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if tx_interval_ms != None:
-            self.tx_interval_ms = tx_interval_ms
-        else:
-            self.tx_interval_ms = 0
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if slot_num != None:
-            self.slot_num = slot_num
-        else:
-            self.slot_num = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.tx_interval_ms))
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(struct.pack("!B", self.slot_num))
-        packed.append('\x00' * 3)
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_pdu_tx_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 31)
-        obj.tx_interval_ms = reader.read("!L")[0]
-        obj.port_no = util.unpack_port_no(reader)
-        obj.slot_num = reader.read("!B")[0]
-        reader.skip(3)
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.tx_interval_ms != other.tx_interval_ms: return False
-        if self.port_no != other.port_no: return False
-        if self.slot_num != other.slot_num: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_pdu_tx_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("tx_interval_ms = ");
-                q.text("%#x" % self.tx_interval_ms)
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("slot_num = ");
-                q.text("%#x" % self.slot_num)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[31] = bsn_pdu_tx_request
-
-class bsn_port_counter_stats_reply(bsn_stats_reply):
-    version = 5
-    type = 19
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 8
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_port_counter_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 8)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.bsn_port_counter_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_port_counter_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_reply.subtypes[8] = bsn_port_counter_stats_reply
-
-class bsn_port_counter_stats_request(bsn_stats_request):
-    version = 5
-    type = 18
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 8
-
-    def __init__(self, xid=None, flags=None, port_no=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(util.pack_port_no(self.port_no))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_port_counter_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 8)
-        obj.port_no = util.unpack_port_no(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.port_no != other.port_no: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_port_counter_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-            q.breakable()
-        q.text('}')
-
-bsn_stats_request.subtypes[8] = bsn_port_counter_stats_request
-
-class bsn_set_aux_cxns_reply(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 59
-
-    def __init__(self, xid=None, num_aux=None, status=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if num_aux != None:
-            self.num_aux = num_aux
-        else:
-            self.num_aux = 0
-        if status != None:
-            self.status = status
-        else:
-            self.status = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.num_aux))
-        packed.append(struct.pack("!L", self.status))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_set_aux_cxns_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 59)
-        obj.num_aux = reader.read("!L")[0]
-        obj.status = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.num_aux != other.num_aux: return False
-        if self.status != other.status: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_set_aux_cxns_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("num_aux = ");
-                q.text("%#x" % self.num_aux)
-                q.text(","); q.breakable()
-                q.text("status = ");
-                q.text("%#x" % self.status)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[59] = bsn_set_aux_cxns_reply
-
-class bsn_set_aux_cxns_request(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 58
-
-    def __init__(self, xid=None, num_aux=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if num_aux != None:
-            self.num_aux = num_aux
-        else:
-            self.num_aux = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.num_aux))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_set_aux_cxns_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 58)
-        obj.num_aux = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.num_aux != other.num_aux: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_set_aux_cxns_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("num_aux = ");
-                q.text("%#x" % self.num_aux)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[58] = bsn_set_aux_cxns_request
-
-class bsn_set_lacp_reply(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 42
-
-    def __init__(self, xid=None, status=None, port_no=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if status != None:
-            self.status = status
-        else:
-            self.status = 0
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.status))
-        packed.append(util.pack_port_no(self.port_no))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_set_lacp_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 42)
-        obj.status = reader.read("!L")[0]
-        obj.port_no = util.unpack_port_no(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.status != other.status: return False
-        if self.port_no != other.port_no: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_set_lacp_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("status = ");
-                q.text("%#x" % self.status)
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[42] = bsn_set_lacp_reply
-
-class bsn_set_lacp_request(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 41
-
-    def __init__(self, xid=None, enabled=None, port_no=None, actor_sys_priority=None, actor_sys_mac=None, actor_port_priority=None, actor_port_num=None, actor_key=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if enabled != None:
-            self.enabled = enabled
-        else:
-            self.enabled = 0
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if actor_sys_priority != None:
-            self.actor_sys_priority = actor_sys_priority
-        else:
-            self.actor_sys_priority = 0
-        if actor_sys_mac != None:
-            self.actor_sys_mac = actor_sys_mac
-        else:
-            self.actor_sys_mac = [0,0,0,0,0,0]
-        if actor_port_priority != None:
-            self.actor_port_priority = actor_port_priority
-        else:
-            self.actor_port_priority = 0
-        if actor_port_num != None:
-            self.actor_port_num = actor_port_num
-        else:
-            self.actor_port_num = 0
-        if actor_key != None:
-            self.actor_key = actor_key
-        else:
-            self.actor_key = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!B", self.enabled))
-        packed.append('\x00' * 3)
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(struct.pack("!H", self.actor_sys_priority))
-        packed.append(struct.pack("!6B", *self.actor_sys_mac))
-        packed.append(struct.pack("!H", self.actor_port_priority))
-        packed.append(struct.pack("!H", self.actor_port_num))
-        packed.append(struct.pack("!H", self.actor_key))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_set_lacp_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 41)
-        obj.enabled = reader.read("!B")[0]
-        reader.skip(3)
-        obj.port_no = util.unpack_port_no(reader)
-        obj.actor_sys_priority = reader.read("!H")[0]
-        obj.actor_sys_mac = list(reader.read('!6B'))
-        obj.actor_port_priority = reader.read("!H")[0]
-        obj.actor_port_num = reader.read("!H")[0]
-        obj.actor_key = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.enabled != other.enabled: return False
-        if self.port_no != other.port_no: return False
-        if self.actor_sys_priority != other.actor_sys_priority: return False
-        if self.actor_sys_mac != other.actor_sys_mac: return False
-        if self.actor_port_priority != other.actor_port_priority: return False
-        if self.actor_port_num != other.actor_port_num: return False
-        if self.actor_key != other.actor_key: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_set_lacp_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("enabled = ");
-                q.text("%#x" % self.enabled)
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("actor_sys_priority = ");
-                q.text("%#x" % self.actor_sys_priority)
-                q.text(","); q.breakable()
-                q.text("actor_sys_mac = ");
-                q.text(util.pretty_mac(self.actor_sys_mac))
-                q.text(","); q.breakable()
-                q.text("actor_port_priority = ");
-                q.text("%#x" % self.actor_port_priority)
-                q.text(","); q.breakable()
-                q.text("actor_port_num = ");
-                q.text("%#x" % self.actor_port_num)
-                q.text(","); q.breakable()
-                q.text("actor_key = ");
-                q.text("%#x" % self.actor_key)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[41] = bsn_set_lacp_request
-
-class bsn_set_mirroring(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 3
-
-    def __init__(self, xid=None, report_mirror_ports=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if report_mirror_ports != None:
-            self.report_mirror_ports = report_mirror_ports
-        else:
-            self.report_mirror_ports = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!B", self.report_mirror_ports))
-        packed.append('\x00' * 3)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_set_mirroring()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 3)
-        obj.report_mirror_ports = reader.read("!B")[0]
-        reader.skip(3)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.report_mirror_ports != other.report_mirror_ports: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_set_mirroring {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("report_mirror_ports = ");
-                q.text("%#x" % self.report_mirror_ports)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[3] = bsn_set_mirroring
-
-class bsn_set_pktin_suppression_reply(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 25
-
-    def __init__(self, xid=None, status=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if status != None:
-            self.status = status
-        else:
-            self.status = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.status))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_set_pktin_suppression_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 25)
-        obj.status = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.status != other.status: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_set_pktin_suppression_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("status = ");
-                q.text("%#x" % self.status)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[25] = bsn_set_pktin_suppression_reply
-
-class bsn_set_pktin_suppression_request(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 11
-
-    def __init__(self, xid=None, enabled=None, idle_timeout=None, hard_timeout=None, priority=None, cookie=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if enabled != None:
-            self.enabled = enabled
-        else:
-            self.enabled = 0
-        if idle_timeout != None:
-            self.idle_timeout = idle_timeout
-        else:
-            self.idle_timeout = 0
-        if hard_timeout != None:
-            self.hard_timeout = hard_timeout
-        else:
-            self.hard_timeout = 0
-        if priority != None:
-            self.priority = priority
-        else:
-            self.priority = 0
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!B", self.enabled))
-        packed.append('\x00' * 1)
-        packed.append(struct.pack("!H", self.idle_timeout))
-        packed.append(struct.pack("!H", self.hard_timeout))
-        packed.append(struct.pack("!H", self.priority))
-        packed.append(struct.pack("!Q", self.cookie))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_set_pktin_suppression_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 11)
-        obj.enabled = reader.read("!B")[0]
-        reader.skip(1)
-        obj.idle_timeout = reader.read("!H")[0]
-        obj.hard_timeout = reader.read("!H")[0]
-        obj.priority = reader.read("!H")[0]
-        obj.cookie = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.enabled != other.enabled: return False
-        if self.idle_timeout != other.idle_timeout: return False
-        if self.hard_timeout != other.hard_timeout: return False
-        if self.priority != other.priority: return False
-        if self.cookie != other.cookie: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_set_pktin_suppression_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("enabled = ");
-                q.text("%#x" % self.enabled)
-                q.text(","); q.breakable()
-                q.text("idle_timeout = ");
-                q.text("%#x" % self.idle_timeout)
-                q.text(","); q.breakable()
-                q.text("hard_timeout = ");
-                q.text("%#x" % self.hard_timeout)
-                q.text(","); q.breakable()
-                q.text("priority = ");
-                q.text("%#x" % self.priority)
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[11] = bsn_set_pktin_suppression_request
-
-class bsn_set_switch_pipeline_reply(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 54
-
-    def __init__(self, xid=None, status=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if status != None:
-            self.status = status
-        else:
-            self.status = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.status))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_set_switch_pipeline_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 54)
-        obj.status = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.status != other.status: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_set_switch_pipeline_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("status = ");
-                q.text("%#x" % self.status)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[54] = bsn_set_switch_pipeline_reply
-
-class bsn_set_switch_pipeline_request(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 53
-
-    def __init__(self, xid=None, pipeline=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if pipeline != None:
-            self.pipeline = pipeline
-        else:
-            self.pipeline = ""
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!256s", self.pipeline))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_set_switch_pipeline_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 53)
-        obj.pipeline = reader.read("!256s")[0].rstrip("\x00")
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.pipeline != other.pipeline: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_set_switch_pipeline_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("pipeline = ");
-                q.pp(self.pipeline)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[53] = bsn_set_switch_pipeline_request
-
-class bsn_switch_pipeline_stats_reply(bsn_stats_reply):
-    version = 5
-    type = 19
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 6
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_switch_pipeline_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 6)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.bsn_switch_pipeline_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_switch_pipeline_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_reply.subtypes[6] = bsn_switch_pipeline_stats_reply
-
-class bsn_switch_pipeline_stats_request(bsn_stats_request):
-    version = 5
-    type = 18
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 6
-
-    def __init__(self, xid=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_switch_pipeline_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 6)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_switch_pipeline_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_request.subtypes[6] = bsn_switch_pipeline_stats_request
-
-class bsn_table_checksum_stats_reply(bsn_stats_reply):
-    version = 5
-    type = 19
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 11
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_table_checksum_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 11)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.bsn_table_checksum_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_table_checksum_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_reply.subtypes[11] = bsn_table_checksum_stats_reply
-
-class bsn_table_checksum_stats_request(bsn_stats_request):
-    version = 5
-    type = 18
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 11
-
-    def __init__(self, xid=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_table_checksum_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 11)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_table_checksum_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_request.subtypes[11] = bsn_table_checksum_stats_request
-
-class bsn_table_set_buckets_size(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 61
-
-    def __init__(self, xid=None, table_id=None, buckets_size=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if buckets_size != None:
-            self.buckets_size = buckets_size
-        else:
-            self.buckets_size = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append('\x00' * 1)
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append('\x00' * 2)
-        packed.append(struct.pack("!L", self.buckets_size))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_table_set_buckets_size()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 61)
-        reader.skip(1)
-        obj.table_id = reader.read("!B")[0]
-        reader.skip(2)
-        obj.buckets_size = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.table_id != other.table_id: return False
-        if self.buckets_size != other.buckets_size: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_table_set_buckets_size {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("buckets_size = ");
-                q.text("%#x" % self.buckets_size)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[61] = bsn_table_set_buckets_size
-
-class bsn_takeover(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 69
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_takeover()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 69)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_takeover {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[69] = bsn_takeover
-
-class bsn_time_reply(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 45
-
-    def __init__(self, xid=None, time_ms=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if time_ms != None:
-            self.time_ms = time_ms
-        else:
-            self.time_ms = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!Q", self.time_ms))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_time_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 45)
-        obj.time_ms = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.time_ms != other.time_ms: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_time_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("time_ms = ");
-                q.text("%#x" % self.time_ms)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[45] = bsn_time_reply
-
-class bsn_time_request(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 44
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_time_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 44)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_time_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[44] = bsn_time_request
-
-class bsn_virtual_port_create_reply(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 16
-
-    def __init__(self, xid=None, status=None, vport_no=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if status != None:
-            self.status = status
-        else:
-            self.status = 0
-        if vport_no != None:
-            self.vport_no = vport_no
-        else:
-            self.vport_no = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.status))
-        packed.append(struct.pack("!L", self.vport_no))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_virtual_port_create_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 16)
-        obj.status = reader.read("!L")[0]
-        obj.vport_no = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.status != other.status: return False
-        if self.vport_no != other.vport_no: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_virtual_port_create_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("status = ");
-                q.text("%#x" % self.status)
-                q.text(","); q.breakable()
-                q.text("vport_no = ");
-                q.text("%#x" % self.vport_no)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[16] = bsn_virtual_port_create_reply
-
-class bsn_virtual_port_create_request(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 15
-
-    def __init__(self, xid=None, vport=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if vport != None:
-            self.vport = vport
-        else:
-            self.vport = ofp.bsn_vport()
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(self.vport.pack())
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_virtual_port_create_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 15)
-        obj.vport = ofp.bsn_vport.unpack(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.vport != other.vport: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_virtual_port_create_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("vport = ");
-                q.pp(self.vport)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[15] = bsn_virtual_port_create_request
-
-class bsn_virtual_port_remove_reply(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 26
-
-    def __init__(self, xid=None, status=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if status != None:
-            self.status = status
-        else:
-            self.status = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.status))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_virtual_port_remove_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 26)
-        obj.status = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.status != other.status: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_virtual_port_remove_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("status = ");
-                q.text("%#x" % self.status)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[26] = bsn_virtual_port_remove_reply
-
-class bsn_virtual_port_remove_request(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 17
-
-    def __init__(self, xid=None, vport_no=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if vport_no != None:
-            self.vport_no = vport_no
-        else:
-            self.vport_no = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.vport_no))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_virtual_port_remove_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 17)
-        obj.vport_no = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.vport_no != other.vport_no: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_virtual_port_remove_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("vport_no = ");
-                q.text("%#x" % self.vport_no)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[17] = bsn_virtual_port_remove_request
-
-class bsn_vlan_counter_clear(bsn_header):
-    version = 5
-    type = 4
-    experimenter = 6035143
-    subtype = 70
-
-    def __init__(self, xid=None, vlan_vid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if vlan_vid != None:
-            self.vlan_vid = vlan_vid
-        else:
-            self.vlan_vid = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!H", self.vlan_vid))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_vlan_counter_clear()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 70)
-        obj.vlan_vid = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.vlan_vid != other.vlan_vid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vlan_counter_clear {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("vlan_vid = ");
-                q.text("%#x" % self.vlan_vid)
-            q.breakable()
-        q.text('}')
-
-bsn_header.subtypes[70] = bsn_vlan_counter_clear
-
-class bsn_vlan_counter_stats_reply(bsn_stats_reply):
-    version = 5
-    type = 19
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 9
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_vlan_counter_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 9)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.bsn_vlan_counter_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vlan_counter_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_reply.subtypes[9] = bsn_vlan_counter_stats_reply
-
-class bsn_vlan_counter_stats_request(bsn_stats_request):
-    version = 5
-    type = 18
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 9
-
-    def __init__(self, xid=None, flags=None, vlan_vid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if vlan_vid != None:
-            self.vlan_vid = vlan_vid
-        else:
-            self.vlan_vid = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!H", self.vlan_vid))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_vlan_counter_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 9)
-        obj.vlan_vid = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.vlan_vid != other.vlan_vid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vlan_counter_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("vlan_vid = ");
-                q.text("%#x" % self.vlan_vid)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_request.subtypes[9] = bsn_vlan_counter_stats_request
-
-class bsn_vrf_counter_stats_reply(bsn_stats_reply):
-    version = 5
-    type = 19
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 15
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_vrf_counter_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 15)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.bsn_vrf_counter_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vrf_counter_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_reply.subtypes[15] = bsn_vrf_counter_stats_reply
-
-class bsn_vrf_counter_stats_request(bsn_stats_request):
-    version = 5
-    type = 18
-    stats_type = 65535
-    experimenter = 6035143
-    subtype = 15
-
-    def __init__(self, xid=None, flags=None, vrf=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if vrf != None:
-            self.vrf = vrf
-        else:
-            self.vrf = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        packed.append(struct.pack("!L", self.vrf))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_vrf_counter_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 65535)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _subtype = reader.read("!L")[0]
-        assert(_subtype == 15)
-        obj.vrf = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.vrf != other.vrf: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vrf_counter_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("vrf = ");
-                q.text("%#x" % self.vrf)
-            q.breakable()
-        q.text('}')
-
-bsn_stats_request.subtypes[15] = bsn_vrf_counter_stats_request
-
-class bundle_add_msg(message):
-    version = 5
-    type = 34
-
-    def __init__(self, xid=None, bundle_id=None, flags=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if bundle_id != None:
-            self.bundle_id = bundle_id
-        else:
-            self.bundle_id = 0
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.bundle_id))
-        packed.append('\x00' * 2)
-        packed.append(struct.pack("!H", self.flags))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bundle_add_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 34)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.bundle_id = reader.read("!L")[0]
-        reader.skip(2)
-        obj.flags = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.bundle_id != other.bundle_id: return False
-        if self.flags != other.flags: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bundle_add_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("bundle_id = ");
-                q.text("%#x" % self.bundle_id)
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[34] = bundle_add_msg
-
-class bundle_ctrl_msg(message):
-    version = 5
-    type = 33
-
-    def __init__(self, xid=None, bundle_id=None, bundle_ctrl_type=None, flags=None, properties=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if bundle_id != None:
-            self.bundle_id = bundle_id
-        else:
-            self.bundle_id = 0
-        if bundle_ctrl_type != None:
-            self.bundle_ctrl_type = bundle_ctrl_type
-        else:
-            self.bundle_ctrl_type = 0
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if properties != None:
-            self.properties = properties
-        else:
-            self.properties = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.bundle_id))
-        packed.append(struct.pack("!H", self.bundle_ctrl_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append(loxi.generic_util.pack_list(self.properties))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bundle_ctrl_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 33)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.bundle_id = reader.read("!L")[0]
-        obj.bundle_ctrl_type = reader.read("!H")[0]
-        obj.flags = reader.read("!H")[0]
-        obj.properties = loxi.generic_util.unpack_list(reader, ofp.bundle_prop.bundle_prop.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.bundle_id != other.bundle_id: return False
-        if self.bundle_ctrl_type != other.bundle_ctrl_type: return False
-        if self.flags != other.flags: return False
-        if self.properties != other.properties: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bundle_ctrl_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("bundle_id = ");
-                q.text("%#x" % self.bundle_id)
-                q.text(","); q.breakable()
-                q.text("bundle_ctrl_type = ");
-                q.text("%#x" % self.bundle_ctrl_type)
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("properties = ");
-                q.pp(self.properties)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[33] = bundle_ctrl_msg
-
-class bundle_failed_error_msg(error_msg):
-    version = 5
-    type = 1
-    err_type = 17
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bundle_failed_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 17)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bundle_failed_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[17] = bundle_failed_error_msg
-
-class desc_stats_reply(stats_reply):
-    version = 5
-    type = 19
-    stats_type = 0
-
-    def __init__(self, xid=None, flags=None, mfr_desc=None, hw_desc=None, sw_desc=None, serial_num=None, dp_desc=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if mfr_desc != None:
-            self.mfr_desc = mfr_desc
-        else:
-            self.mfr_desc = ""
-        if hw_desc != None:
-            self.hw_desc = hw_desc
-        else:
-            self.hw_desc = ""
-        if sw_desc != None:
-            self.sw_desc = sw_desc
-        else:
-            self.sw_desc = ""
-        if serial_num != None:
-            self.serial_num = serial_num
-        else:
-            self.serial_num = ""
-        if dp_desc != None:
-            self.dp_desc = dp_desc
-        else:
-            self.dp_desc = ""
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!256s", self.mfr_desc))
-        packed.append(struct.pack("!256s", self.hw_desc))
-        packed.append(struct.pack("!256s", self.sw_desc))
-        packed.append(struct.pack("!32s", self.serial_num))
-        packed.append(struct.pack("!256s", self.dp_desc))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = desc_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 0)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.mfr_desc = reader.read("!256s")[0].rstrip("\x00")
-        obj.hw_desc = reader.read("!256s")[0].rstrip("\x00")
-        obj.sw_desc = reader.read("!256s")[0].rstrip("\x00")
-        obj.serial_num = reader.read("!32s")[0].rstrip("\x00")
-        obj.dp_desc = reader.read("!256s")[0].rstrip("\x00")
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.mfr_desc != other.mfr_desc: return False
-        if self.hw_desc != other.hw_desc: return False
-        if self.sw_desc != other.sw_desc: return False
-        if self.serial_num != other.serial_num: return False
-        if self.dp_desc != other.dp_desc: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("desc_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("mfr_desc = ");
-                q.pp(self.mfr_desc)
-                q.text(","); q.breakable()
-                q.text("hw_desc = ");
-                q.pp(self.hw_desc)
-                q.text(","); q.breakable()
-                q.text("sw_desc = ");
-                q.pp(self.sw_desc)
-                q.text(","); q.breakable()
-                q.text("serial_num = ");
-                q.pp(self.serial_num)
-                q.text(","); q.breakable()
-                q.text("dp_desc = ");
-                q.pp(self.dp_desc)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[0] = desc_stats_reply
-
-class desc_stats_request(stats_request):
-    version = 5
-    type = 18
-    stats_type = 0
-
-    def __init__(self, xid=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = desc_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 0)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("desc_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[0] = desc_stats_request
-
-class echo_reply(message):
-    version = 5
-    type = 3
-
-    def __init__(self, xid=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = echo_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 3)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("echo_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[3] = echo_reply
-
-class echo_request(message):
-    version = 5
-    type = 2
-
-    def __init__(self, xid=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = echo_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 2)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("echo_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[2] = echo_request
-
-class features_reply(message):
-    version = 5
-    type = 6
-
-    def __init__(self, xid=None, datapath_id=None, n_buffers=None, n_tables=None, auxiliary_id=None, capabilities=None, reserved=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if datapath_id != None:
-            self.datapath_id = datapath_id
-        else:
-            self.datapath_id = 0
-        if n_buffers != None:
-            self.n_buffers = n_buffers
-        else:
-            self.n_buffers = 0
-        if n_tables != None:
-            self.n_tables = n_tables
-        else:
-            self.n_tables = 0
-        if auxiliary_id != None:
-            self.auxiliary_id = auxiliary_id
-        else:
-            self.auxiliary_id = 0
-        if capabilities != None:
-            self.capabilities = capabilities
-        else:
-            self.capabilities = 0
-        if reserved != None:
-            self.reserved = reserved
-        else:
-            self.reserved = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!Q", self.datapath_id))
-        packed.append(struct.pack("!L", self.n_buffers))
-        packed.append(struct.pack("!B", self.n_tables))
-        packed.append(struct.pack("!B", self.auxiliary_id))
-        packed.append('\x00' * 2)
-        packed.append(struct.pack("!L", self.capabilities))
-        packed.append(struct.pack("!L", self.reserved))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = features_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 6)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.datapath_id = reader.read("!Q")[0]
-        obj.n_buffers = reader.read("!L")[0]
-        obj.n_tables = reader.read("!B")[0]
-        obj.auxiliary_id = reader.read("!B")[0]
-        reader.skip(2)
-        obj.capabilities = reader.read("!L")[0]
-        obj.reserved = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.datapath_id != other.datapath_id: return False
-        if self.n_buffers != other.n_buffers: return False
-        if self.n_tables != other.n_tables: return False
-        if self.auxiliary_id != other.auxiliary_id: return False
-        if self.capabilities != other.capabilities: return False
-        if self.reserved != other.reserved: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("features_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("datapath_id = ");
-                q.text("%#x" % self.datapath_id)
-                q.text(","); q.breakable()
-                q.text("n_buffers = ");
-                q.text("%#x" % self.n_buffers)
-                q.text(","); q.breakable()
-                q.text("n_tables = ");
-                q.text("%#x" % self.n_tables)
-                q.text(","); q.breakable()
-                q.text("auxiliary_id = ");
-                q.text("%#x" % self.auxiliary_id)
-                q.text(","); q.breakable()
-                q.text("capabilities = ");
-                q.text("%#x" % self.capabilities)
-                q.text(","); q.breakable()
-                q.text("reserved = ");
-                q.text("%#x" % self.reserved)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[6] = features_reply
-
-class features_request(message):
-    version = 5
-    type = 5
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = features_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 5)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("features_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-message.subtypes[5] = features_request
-
-class flow_mod(message):
-    subtypes = {}
-
-    version = 5
-    type = 14
-
-    def __init__(self, xid=None, cookie=None, cookie_mask=None, table_id=None, _command=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, out_group=None, flags=None, match=None, instructions=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if cookie_mask != None:
-            self.cookie_mask = cookie_mask
-        else:
-            self.cookie_mask = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if _command != None:
-            self._command = _command
-        else:
-            self._command = 0
-        if idle_timeout != None:
-            self.idle_timeout = idle_timeout
-        else:
-            self.idle_timeout = 0
-        if hard_timeout != None:
-            self.hard_timeout = hard_timeout
-        else:
-            self.hard_timeout = 0
-        if priority != None:
-            self.priority = priority
-        else:
-            self.priority = 0
-        if buffer_id != None:
-            self.buffer_id = buffer_id
-        else:
-            self.buffer_id = 0
-        if out_port != None:
-            self.out_port = out_port
-        else:
-            self.out_port = 0
-        if out_group != None:
-            self.out_group = out_group
-        else:
-            self.out_group = 0
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        if instructions != None:
-            self.instructions = instructions
-        else:
-            self.instructions = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(struct.pack("!Q", self.cookie_mask))
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append(util.pack_fm_cmd(self._command))
-        packed.append(struct.pack("!H", self.idle_timeout))
-        packed.append(struct.pack("!H", self.hard_timeout))
-        packed.append(struct.pack("!H", self.priority))
-        packed.append(struct.pack("!L", self.buffer_id))
-        packed.append(util.pack_port_no(self.out_port))
-        packed.append(struct.pack("!L", self.out_group))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 2)
-        packed.append(self.match.pack())
-        packed.append(loxi.generic_util.pack_list(self.instructions))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('B', 25)
-        subclass = flow_mod.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = flow_mod()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 14)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.cookie = reader.read("!Q")[0]
-        obj.cookie_mask = reader.read("!Q")[0]
-        obj.table_id = reader.read("!B")[0]
-        obj._command = util.unpack_fm_cmd(reader)
-        obj.idle_timeout = reader.read("!H")[0]
-        obj.hard_timeout = reader.read("!H")[0]
-        obj.priority = reader.read("!H")[0]
-        obj.buffer_id = reader.read("!L")[0]
-        obj.out_port = util.unpack_port_no(reader)
-        obj.out_group = reader.read("!L")[0]
-        obj.flags = reader.read("!H")[0]
-        reader.skip(2)
-        obj.match = ofp.match.unpack(reader)
-        obj.instructions = loxi.generic_util.unpack_list(reader, ofp.instruction.instruction.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.cookie != other.cookie: return False
-        if self.cookie_mask != other.cookie_mask: return False
-        if self.table_id != other.table_id: return False
-        if self._command != other._command: return False
-        if self.idle_timeout != other.idle_timeout: return False
-        if self.hard_timeout != other.hard_timeout: return False
-        if self.priority != other.priority: return False
-        if self.buffer_id != other.buffer_id: return False
-        if self.out_port != other.out_port: return False
-        if self.out_group != other.out_group: return False
-        if self.flags != other.flags: return False
-        if self.match != other.match: return False
-        if self.instructions != other.instructions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_mod {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("cookie_mask = ");
-                q.text("%#x" % self.cookie_mask)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("idle_timeout = ");
-                q.text("%#x" % self.idle_timeout)
-                q.text(","); q.breakable()
-                q.text("hard_timeout = ");
-                q.text("%#x" % self.hard_timeout)
-                q.text(","); q.breakable()
-                q.text("priority = ");
-                q.text("%#x" % self.priority)
-                q.text(","); q.breakable()
-                q.text("buffer_id = ");
-                q.text("%#x" % self.buffer_id)
-                q.text(","); q.breakable()
-                q.text("out_port = ");
-                q.text(util.pretty_port(self.out_port))
-                q.text(","); q.breakable()
-                q.text("out_group = ");
-                q.text("%#x" % self.out_group)
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-                q.text(","); q.breakable()
-                q.text("instructions = ");
-                q.pp(self.instructions)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[14] = flow_mod
-
-class flow_add(flow_mod):
-    version = 5
-    type = 14
-    _command = 0
-
-    def __init__(self, xid=None, cookie=None, cookie_mask=None, table_id=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, out_group=None, flags=None, importance=None, match=None, instructions=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if cookie_mask != None:
-            self.cookie_mask = cookie_mask
-        else:
-            self.cookie_mask = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if idle_timeout != None:
-            self.idle_timeout = idle_timeout
-        else:
-            self.idle_timeout = 0
-        if hard_timeout != None:
-            self.hard_timeout = hard_timeout
-        else:
-            self.hard_timeout = 0
-        if priority != None:
-            self.priority = priority
-        else:
-            self.priority = 0
-        if buffer_id != None:
-            self.buffer_id = buffer_id
-        else:
-            self.buffer_id = 0
-        if out_port != None:
-            self.out_port = out_port
-        else:
-            self.out_port = 0
-        if out_group != None:
-            self.out_group = out_group
-        else:
-            self.out_group = 0
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if importance != None:
-            self.importance = importance
-        else:
-            self.importance = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        if instructions != None:
-            self.instructions = instructions
-        else:
-            self.instructions = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(struct.pack("!Q", self.cookie_mask))
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append(util.pack_fm_cmd(self._command))
-        packed.append(struct.pack("!H", self.idle_timeout))
-        packed.append(struct.pack("!H", self.hard_timeout))
-        packed.append(struct.pack("!H", self.priority))
-        packed.append(struct.pack("!L", self.buffer_id))
-        packed.append(util.pack_port_no(self.out_port))
-        packed.append(struct.pack("!L", self.out_group))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append(struct.pack("!H", self.importance))
-        packed.append(self.match.pack())
-        packed.append(loxi.generic_util.pack_list(self.instructions))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_add()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 14)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.cookie = reader.read("!Q")[0]
-        obj.cookie_mask = reader.read("!Q")[0]
-        obj.table_id = reader.read("!B")[0]
-        __command = util.unpack_fm_cmd(reader)
-        assert(__command == 0)
-        obj.idle_timeout = reader.read("!H")[0]
-        obj.hard_timeout = reader.read("!H")[0]
-        obj.priority = reader.read("!H")[0]
-        obj.buffer_id = reader.read("!L")[0]
-        obj.out_port = util.unpack_port_no(reader)
-        obj.out_group = reader.read("!L")[0]
-        obj.flags = reader.read("!H")[0]
-        obj.importance = reader.read("!H")[0]
-        obj.match = ofp.match.unpack(reader)
-        obj.instructions = loxi.generic_util.unpack_list(reader, ofp.instruction.instruction.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.cookie != other.cookie: return False
-        if self.cookie_mask != other.cookie_mask: return False
-        if self.table_id != other.table_id: return False
-        if self.idle_timeout != other.idle_timeout: return False
-        if self.hard_timeout != other.hard_timeout: return False
-        if self.priority != other.priority: return False
-        if self.buffer_id != other.buffer_id: return False
-        if self.out_port != other.out_port: return False
-        if self.out_group != other.out_group: return False
-        if self.flags != other.flags: return False
-        if self.importance != other.importance: return False
-        if self.match != other.match: return False
-        if self.instructions != other.instructions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_add {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("cookie_mask = ");
-                q.text("%#x" % self.cookie_mask)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("idle_timeout = ");
-                q.text("%#x" % self.idle_timeout)
-                q.text(","); q.breakable()
-                q.text("hard_timeout = ");
-                q.text("%#x" % self.hard_timeout)
-                q.text(","); q.breakable()
-                q.text("priority = ");
-                q.text("%#x" % self.priority)
-                q.text(","); q.breakable()
-                q.text("buffer_id = ");
-                q.text("%#x" % self.buffer_id)
-                q.text(","); q.breakable()
-                q.text("out_port = ");
-                q.text(util.pretty_port(self.out_port))
-                q.text(","); q.breakable()
-                q.text("out_group = ");
-                q.text("%#x" % self.out_group)
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("importance = ");
-                q.text("%#x" % self.importance)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-                q.text(","); q.breakable()
-                q.text("instructions = ");
-                q.pp(self.instructions)
-            q.breakable()
-        q.text('}')
-
-flow_mod.subtypes[0] = flow_add
-
-class flow_delete(flow_mod):
-    version = 5
-    type = 14
-    _command = 3
-
-    def __init__(self, xid=None, cookie=None, cookie_mask=None, table_id=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, out_group=None, flags=None, importance=None, match=None, instructions=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if cookie_mask != None:
-            self.cookie_mask = cookie_mask
-        else:
-            self.cookie_mask = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if idle_timeout != None:
-            self.idle_timeout = idle_timeout
-        else:
-            self.idle_timeout = 0
-        if hard_timeout != None:
-            self.hard_timeout = hard_timeout
-        else:
-            self.hard_timeout = 0
-        if priority != None:
-            self.priority = priority
-        else:
-            self.priority = 0
-        if buffer_id != None:
-            self.buffer_id = buffer_id
-        else:
-            self.buffer_id = 0
-        if out_port != None:
-            self.out_port = out_port
-        else:
-            self.out_port = 0
-        if out_group != None:
-            self.out_group = out_group
-        else:
-            self.out_group = 0
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if importance != None:
-            self.importance = importance
-        else:
-            self.importance = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        if instructions != None:
-            self.instructions = instructions
-        else:
-            self.instructions = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(struct.pack("!Q", self.cookie_mask))
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append(util.pack_fm_cmd(self._command))
-        packed.append(struct.pack("!H", self.idle_timeout))
-        packed.append(struct.pack("!H", self.hard_timeout))
-        packed.append(struct.pack("!H", self.priority))
-        packed.append(struct.pack("!L", self.buffer_id))
-        packed.append(util.pack_port_no(self.out_port))
-        packed.append(struct.pack("!L", self.out_group))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append(struct.pack("!H", self.importance))
-        packed.append(self.match.pack())
-        packed.append(loxi.generic_util.pack_list(self.instructions))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_delete()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 14)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.cookie = reader.read("!Q")[0]
-        obj.cookie_mask = reader.read("!Q")[0]
-        obj.table_id = reader.read("!B")[0]
-        __command = util.unpack_fm_cmd(reader)
-        assert(__command == 3)
-        obj.idle_timeout = reader.read("!H")[0]
-        obj.hard_timeout = reader.read("!H")[0]
-        obj.priority = reader.read("!H")[0]
-        obj.buffer_id = reader.read("!L")[0]
-        obj.out_port = util.unpack_port_no(reader)
-        obj.out_group = reader.read("!L")[0]
-        obj.flags = reader.read("!H")[0]
-        obj.importance = reader.read("!H")[0]
-        obj.match = ofp.match.unpack(reader)
-        obj.instructions = loxi.generic_util.unpack_list(reader, ofp.instruction.instruction.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.cookie != other.cookie: return False
-        if self.cookie_mask != other.cookie_mask: return False
-        if self.table_id != other.table_id: return False
-        if self.idle_timeout != other.idle_timeout: return False
-        if self.hard_timeout != other.hard_timeout: return False
-        if self.priority != other.priority: return False
-        if self.buffer_id != other.buffer_id: return False
-        if self.out_port != other.out_port: return False
-        if self.out_group != other.out_group: return False
-        if self.flags != other.flags: return False
-        if self.importance != other.importance: return False
-        if self.match != other.match: return False
-        if self.instructions != other.instructions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_delete {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("cookie_mask = ");
-                q.text("%#x" % self.cookie_mask)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("idle_timeout = ");
-                q.text("%#x" % self.idle_timeout)
-                q.text(","); q.breakable()
-                q.text("hard_timeout = ");
-                q.text("%#x" % self.hard_timeout)
-                q.text(","); q.breakable()
-                q.text("priority = ");
-                q.text("%#x" % self.priority)
-                q.text(","); q.breakable()
-                q.text("buffer_id = ");
-                q.text("%#x" % self.buffer_id)
-                q.text(","); q.breakable()
-                q.text("out_port = ");
-                q.text(util.pretty_port(self.out_port))
-                q.text(","); q.breakable()
-                q.text("out_group = ");
-                q.text("%#x" % self.out_group)
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("importance = ");
-                q.text("%#x" % self.importance)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-                q.text(","); q.breakable()
-                q.text("instructions = ");
-                q.pp(self.instructions)
-            q.breakable()
-        q.text('}')
-
-flow_mod.subtypes[3] = flow_delete
-
-class flow_delete_strict(flow_mod):
-    version = 5
-    type = 14
-    _command = 4
-
-    def __init__(self, xid=None, cookie=None, cookie_mask=None, table_id=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, out_group=None, flags=None, importance=None, match=None, instructions=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if cookie_mask != None:
-            self.cookie_mask = cookie_mask
-        else:
-            self.cookie_mask = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if idle_timeout != None:
-            self.idle_timeout = idle_timeout
-        else:
-            self.idle_timeout = 0
-        if hard_timeout != None:
-            self.hard_timeout = hard_timeout
-        else:
-            self.hard_timeout = 0
-        if priority != None:
-            self.priority = priority
-        else:
-            self.priority = 0
-        if buffer_id != None:
-            self.buffer_id = buffer_id
-        else:
-            self.buffer_id = 0
-        if out_port != None:
-            self.out_port = out_port
-        else:
-            self.out_port = 0
-        if out_group != None:
-            self.out_group = out_group
-        else:
-            self.out_group = 0
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if importance != None:
-            self.importance = importance
-        else:
-            self.importance = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        if instructions != None:
-            self.instructions = instructions
-        else:
-            self.instructions = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(struct.pack("!Q", self.cookie_mask))
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append(util.pack_fm_cmd(self._command))
-        packed.append(struct.pack("!H", self.idle_timeout))
-        packed.append(struct.pack("!H", self.hard_timeout))
-        packed.append(struct.pack("!H", self.priority))
-        packed.append(struct.pack("!L", self.buffer_id))
-        packed.append(util.pack_port_no(self.out_port))
-        packed.append(struct.pack("!L", self.out_group))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append(struct.pack("!H", self.importance))
-        packed.append(self.match.pack())
-        packed.append(loxi.generic_util.pack_list(self.instructions))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_delete_strict()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 14)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.cookie = reader.read("!Q")[0]
-        obj.cookie_mask = reader.read("!Q")[0]
-        obj.table_id = reader.read("!B")[0]
-        __command = util.unpack_fm_cmd(reader)
-        assert(__command == 4)
-        obj.idle_timeout = reader.read("!H")[0]
-        obj.hard_timeout = reader.read("!H")[0]
-        obj.priority = reader.read("!H")[0]
-        obj.buffer_id = reader.read("!L")[0]
-        obj.out_port = util.unpack_port_no(reader)
-        obj.out_group = reader.read("!L")[0]
-        obj.flags = reader.read("!H")[0]
-        obj.importance = reader.read("!H")[0]
-        obj.match = ofp.match.unpack(reader)
-        obj.instructions = loxi.generic_util.unpack_list(reader, ofp.instruction.instruction.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.cookie != other.cookie: return False
-        if self.cookie_mask != other.cookie_mask: return False
-        if self.table_id != other.table_id: return False
-        if self.idle_timeout != other.idle_timeout: return False
-        if self.hard_timeout != other.hard_timeout: return False
-        if self.priority != other.priority: return False
-        if self.buffer_id != other.buffer_id: return False
-        if self.out_port != other.out_port: return False
-        if self.out_group != other.out_group: return False
-        if self.flags != other.flags: return False
-        if self.importance != other.importance: return False
-        if self.match != other.match: return False
-        if self.instructions != other.instructions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_delete_strict {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("cookie_mask = ");
-                q.text("%#x" % self.cookie_mask)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("idle_timeout = ");
-                q.text("%#x" % self.idle_timeout)
-                q.text(","); q.breakable()
-                q.text("hard_timeout = ");
-                q.text("%#x" % self.hard_timeout)
-                q.text(","); q.breakable()
-                q.text("priority = ");
-                q.text("%#x" % self.priority)
-                q.text(","); q.breakable()
-                q.text("buffer_id = ");
-                q.text("%#x" % self.buffer_id)
-                q.text(","); q.breakable()
-                q.text("out_port = ");
-                q.text(util.pretty_port(self.out_port))
-                q.text(","); q.breakable()
-                q.text("out_group = ");
-                q.text("%#x" % self.out_group)
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("importance = ");
-                q.text("%#x" % self.importance)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-                q.text(","); q.breakable()
-                q.text("instructions = ");
-                q.pp(self.instructions)
-            q.breakable()
-        q.text('}')
-
-flow_mod.subtypes[4] = flow_delete_strict
-
-class flow_mod_failed_error_msg(error_msg):
-    version = 5
-    type = 1
-    err_type = 5
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_mod_failed_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 5)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_mod_failed_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[5] = flow_mod_failed_error_msg
-
-class flow_modify(flow_mod):
-    version = 5
-    type = 14
-    _command = 1
-
-    def __init__(self, xid=None, cookie=None, cookie_mask=None, table_id=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, out_group=None, flags=None, importance=None, match=None, instructions=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if cookie_mask != None:
-            self.cookie_mask = cookie_mask
-        else:
-            self.cookie_mask = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if idle_timeout != None:
-            self.idle_timeout = idle_timeout
-        else:
-            self.idle_timeout = 0
-        if hard_timeout != None:
-            self.hard_timeout = hard_timeout
-        else:
-            self.hard_timeout = 0
-        if priority != None:
-            self.priority = priority
-        else:
-            self.priority = 0
-        if buffer_id != None:
-            self.buffer_id = buffer_id
-        else:
-            self.buffer_id = 0
-        if out_port != None:
-            self.out_port = out_port
-        else:
-            self.out_port = 0
-        if out_group != None:
-            self.out_group = out_group
-        else:
-            self.out_group = 0
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if importance != None:
-            self.importance = importance
-        else:
-            self.importance = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        if instructions != None:
-            self.instructions = instructions
-        else:
-            self.instructions = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(struct.pack("!Q", self.cookie_mask))
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append(util.pack_fm_cmd(self._command))
-        packed.append(struct.pack("!H", self.idle_timeout))
-        packed.append(struct.pack("!H", self.hard_timeout))
-        packed.append(struct.pack("!H", self.priority))
-        packed.append(struct.pack("!L", self.buffer_id))
-        packed.append(util.pack_port_no(self.out_port))
-        packed.append(struct.pack("!L", self.out_group))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append(struct.pack("!H", self.importance))
-        packed.append(self.match.pack())
-        packed.append(loxi.generic_util.pack_list(self.instructions))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_modify()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 14)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.cookie = reader.read("!Q")[0]
-        obj.cookie_mask = reader.read("!Q")[0]
-        obj.table_id = reader.read("!B")[0]
-        __command = util.unpack_fm_cmd(reader)
-        assert(__command == 1)
-        obj.idle_timeout = reader.read("!H")[0]
-        obj.hard_timeout = reader.read("!H")[0]
-        obj.priority = reader.read("!H")[0]
-        obj.buffer_id = reader.read("!L")[0]
-        obj.out_port = util.unpack_port_no(reader)
-        obj.out_group = reader.read("!L")[0]
-        obj.flags = reader.read("!H")[0]
-        obj.importance = reader.read("!H")[0]
-        obj.match = ofp.match.unpack(reader)
-        obj.instructions = loxi.generic_util.unpack_list(reader, ofp.instruction.instruction.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.cookie != other.cookie: return False
-        if self.cookie_mask != other.cookie_mask: return False
-        if self.table_id != other.table_id: return False
-        if self.idle_timeout != other.idle_timeout: return False
-        if self.hard_timeout != other.hard_timeout: return False
-        if self.priority != other.priority: return False
-        if self.buffer_id != other.buffer_id: return False
-        if self.out_port != other.out_port: return False
-        if self.out_group != other.out_group: return False
-        if self.flags != other.flags: return False
-        if self.importance != other.importance: return False
-        if self.match != other.match: return False
-        if self.instructions != other.instructions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_modify {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("cookie_mask = ");
-                q.text("%#x" % self.cookie_mask)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("idle_timeout = ");
-                q.text("%#x" % self.idle_timeout)
-                q.text(","); q.breakable()
-                q.text("hard_timeout = ");
-                q.text("%#x" % self.hard_timeout)
-                q.text(","); q.breakable()
-                q.text("priority = ");
-                q.text("%#x" % self.priority)
-                q.text(","); q.breakable()
-                q.text("buffer_id = ");
-                q.text("%#x" % self.buffer_id)
-                q.text(","); q.breakable()
-                q.text("out_port = ");
-                q.text(util.pretty_port(self.out_port))
-                q.text(","); q.breakable()
-                q.text("out_group = ");
-                q.text("%#x" % self.out_group)
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("importance = ");
-                q.text("%#x" % self.importance)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-                q.text(","); q.breakable()
-                q.text("instructions = ");
-                q.pp(self.instructions)
-            q.breakable()
-        q.text('}')
-
-flow_mod.subtypes[1] = flow_modify
-
-class flow_modify_strict(flow_mod):
-    version = 5
-    type = 14
-    _command = 2
-
-    def __init__(self, xid=None, cookie=None, cookie_mask=None, table_id=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, out_group=None, flags=None, importance=None, match=None, instructions=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if cookie_mask != None:
-            self.cookie_mask = cookie_mask
-        else:
-            self.cookie_mask = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if idle_timeout != None:
-            self.idle_timeout = idle_timeout
-        else:
-            self.idle_timeout = 0
-        if hard_timeout != None:
-            self.hard_timeout = hard_timeout
-        else:
-            self.hard_timeout = 0
-        if priority != None:
-            self.priority = priority
-        else:
-            self.priority = 0
-        if buffer_id != None:
-            self.buffer_id = buffer_id
-        else:
-            self.buffer_id = 0
-        if out_port != None:
-            self.out_port = out_port
-        else:
-            self.out_port = 0
-        if out_group != None:
-            self.out_group = out_group
-        else:
-            self.out_group = 0
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if importance != None:
-            self.importance = importance
-        else:
-            self.importance = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        if instructions != None:
-            self.instructions = instructions
-        else:
-            self.instructions = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(struct.pack("!Q", self.cookie_mask))
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append(util.pack_fm_cmd(self._command))
-        packed.append(struct.pack("!H", self.idle_timeout))
-        packed.append(struct.pack("!H", self.hard_timeout))
-        packed.append(struct.pack("!H", self.priority))
-        packed.append(struct.pack("!L", self.buffer_id))
-        packed.append(util.pack_port_no(self.out_port))
-        packed.append(struct.pack("!L", self.out_group))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append(struct.pack("!H", self.importance))
-        packed.append(self.match.pack())
-        packed.append(loxi.generic_util.pack_list(self.instructions))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_modify_strict()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 14)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.cookie = reader.read("!Q")[0]
-        obj.cookie_mask = reader.read("!Q")[0]
-        obj.table_id = reader.read("!B")[0]
-        __command = util.unpack_fm_cmd(reader)
-        assert(__command == 2)
-        obj.idle_timeout = reader.read("!H")[0]
-        obj.hard_timeout = reader.read("!H")[0]
-        obj.priority = reader.read("!H")[0]
-        obj.buffer_id = reader.read("!L")[0]
-        obj.out_port = util.unpack_port_no(reader)
-        obj.out_group = reader.read("!L")[0]
-        obj.flags = reader.read("!H")[0]
-        obj.importance = reader.read("!H")[0]
-        obj.match = ofp.match.unpack(reader)
-        obj.instructions = loxi.generic_util.unpack_list(reader, ofp.instruction.instruction.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.cookie != other.cookie: return False
-        if self.cookie_mask != other.cookie_mask: return False
-        if self.table_id != other.table_id: return False
-        if self.idle_timeout != other.idle_timeout: return False
-        if self.hard_timeout != other.hard_timeout: return False
-        if self.priority != other.priority: return False
-        if self.buffer_id != other.buffer_id: return False
-        if self.out_port != other.out_port: return False
-        if self.out_group != other.out_group: return False
-        if self.flags != other.flags: return False
-        if self.importance != other.importance: return False
-        if self.match != other.match: return False
-        if self.instructions != other.instructions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_modify_strict {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("cookie_mask = ");
-                q.text("%#x" % self.cookie_mask)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("idle_timeout = ");
-                q.text("%#x" % self.idle_timeout)
-                q.text(","); q.breakable()
-                q.text("hard_timeout = ");
-                q.text("%#x" % self.hard_timeout)
-                q.text(","); q.breakable()
-                q.text("priority = ");
-                q.text("%#x" % self.priority)
-                q.text(","); q.breakable()
-                q.text("buffer_id = ");
-                q.text("%#x" % self.buffer_id)
-                q.text(","); q.breakable()
-                q.text("out_port = ");
-                q.text(util.pretty_port(self.out_port))
-                q.text(","); q.breakable()
-                q.text("out_group = ");
-                q.text("%#x" % self.out_group)
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("importance = ");
-                q.text("%#x" % self.importance)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-                q.text(","); q.breakable()
-                q.text("instructions = ");
-                q.pp(self.instructions)
-            q.breakable()
-        q.text('}')
-
-flow_mod.subtypes[2] = flow_modify_strict
-
-class flow_monitor_failed_error_msg(error_msg):
-    version = 5
-    type = 1
-    err_type = 16
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_monitor_failed_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 16)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_monitor_failed_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[16] = flow_monitor_failed_error_msg
-
-class flow_removed(message):
-    version = 5
-    type = 11
-
-    def __init__(self, xid=None, cookie=None, priority=None, reason=None, table_id=None, duration_sec=None, duration_nsec=None, idle_timeout=None, hard_timeout=None, packet_count=None, byte_count=None, match=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if priority != None:
-            self.priority = priority
-        else:
-            self.priority = 0
-        if reason != None:
-            self.reason = reason
-        else:
-            self.reason = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if duration_sec != None:
-            self.duration_sec = duration_sec
-        else:
-            self.duration_sec = 0
-        if duration_nsec != None:
-            self.duration_nsec = duration_nsec
-        else:
-            self.duration_nsec = 0
-        if idle_timeout != None:
-            self.idle_timeout = idle_timeout
-        else:
-            self.idle_timeout = 0
-        if hard_timeout != None:
-            self.hard_timeout = hard_timeout
-        else:
-            self.hard_timeout = 0
-        if packet_count != None:
-            self.packet_count = packet_count
-        else:
-            self.packet_count = 0
-        if byte_count != None:
-            self.byte_count = byte_count
-        else:
-            self.byte_count = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(struct.pack("!H", self.priority))
-        packed.append(struct.pack("!B", self.reason))
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append(struct.pack("!L", self.duration_sec))
-        packed.append(struct.pack("!L", self.duration_nsec))
-        packed.append(struct.pack("!H", self.idle_timeout))
-        packed.append(struct.pack("!H", self.hard_timeout))
-        packed.append(struct.pack("!Q", self.packet_count))
-        packed.append(struct.pack("!Q", self.byte_count))
-        packed.append(self.match.pack())
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_removed()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 11)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.cookie = reader.read("!Q")[0]
-        obj.priority = reader.read("!H")[0]
-        obj.reason = reader.read("!B")[0]
-        obj.table_id = reader.read("!B")[0]
-        obj.duration_sec = reader.read("!L")[0]
-        obj.duration_nsec = reader.read("!L")[0]
-        obj.idle_timeout = reader.read("!H")[0]
-        obj.hard_timeout = reader.read("!H")[0]
-        obj.packet_count = reader.read("!Q")[0]
-        obj.byte_count = reader.read("!Q")[0]
-        obj.match = ofp.match.unpack(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.cookie != other.cookie: return False
-        if self.priority != other.priority: return False
-        if self.reason != other.reason: return False
-        if self.table_id != other.table_id: return False
-        if self.duration_sec != other.duration_sec: return False
-        if self.duration_nsec != other.duration_nsec: return False
-        if self.idle_timeout != other.idle_timeout: return False
-        if self.hard_timeout != other.hard_timeout: return False
-        if self.packet_count != other.packet_count: return False
-        if self.byte_count != other.byte_count: return False
-        if self.match != other.match: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_removed {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("priority = ");
-                q.text("%#x" % self.priority)
-                q.text(","); q.breakable()
-                q.text("reason = ");
-                q.text("%#x" % self.reason)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("duration_sec = ");
-                q.text("%#x" % self.duration_sec)
-                q.text(","); q.breakable()
-                q.text("duration_nsec = ");
-                q.text("%#x" % self.duration_nsec)
-                q.text(","); q.breakable()
-                q.text("idle_timeout = ");
-                q.text("%#x" % self.idle_timeout)
-                q.text(","); q.breakable()
-                q.text("hard_timeout = ");
-                q.text("%#x" % self.hard_timeout)
-                q.text(","); q.breakable()
-                q.text("packet_count = ");
-                q.text("%#x" % self.packet_count)
-                q.text(","); q.breakable()
-                q.text("byte_count = ");
-                q.text("%#x" % self.byte_count)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[11] = flow_removed
-
-class flow_stats_reply(stats_reply):
-    version = 5
-    type = 19
-    stats_type = 1
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 1)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.flow_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[1] = flow_stats_reply
-
-class flow_stats_request(stats_request):
-    version = 5
-    type = 18
-    stats_type = 1
-
-    def __init__(self, xid=None, flags=None, table_id=None, out_port=None, out_group=None, cookie=None, cookie_mask=None, match=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if out_port != None:
-            self.out_port = out_port
-        else:
-            self.out_port = 0
-        if out_group != None:
-            self.out_group = out_group
-        else:
-            self.out_group = 0
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if cookie_mask != None:
-            self.cookie_mask = cookie_mask
-        else:
-            self.cookie_mask = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append('\x00' * 3)
-        packed.append(util.pack_port_no(self.out_port))
-        packed.append(struct.pack("!L", self.out_group))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(struct.pack("!Q", self.cookie_mask))
-        packed.append(self.match.pack())
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = flow_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 1)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.table_id = reader.read("!B")[0]
-        reader.skip(3)
-        obj.out_port = util.unpack_port_no(reader)
-        obj.out_group = reader.read("!L")[0]
-        reader.skip(4)
-        obj.cookie = reader.read("!Q")[0]
-        obj.cookie_mask = reader.read("!Q")[0]
-        obj.match = ofp.match.unpack(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.table_id != other.table_id: return False
-        if self.out_port != other.out_port: return False
-        if self.out_group != other.out_group: return False
-        if self.cookie != other.cookie: return False
-        if self.cookie_mask != other.cookie_mask: return False
-        if self.match != other.match: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("flow_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("out_port = ");
-                q.text(util.pretty_port(self.out_port))
-                q.text(","); q.breakable()
-                q.text("out_group = ");
-                q.text("%#x" % self.out_group)
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("cookie_mask = ");
-                q.text("%#x" % self.cookie_mask)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[1] = flow_stats_request
-
-class get_config_reply(message):
-    version = 5
-    type = 8
-
-    def __init__(self, xid=None, flags=None, miss_send_len=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if miss_send_len != None:
-            self.miss_send_len = miss_send_len
-        else:
-            self.miss_send_len = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append(struct.pack("!H", self.miss_send_len))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = get_config_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 8)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.flags = reader.read("!H")[0]
-        obj.miss_send_len = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.miss_send_len != other.miss_send_len: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("get_config_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("miss_send_len = ");
-                q.text("%#x" % self.miss_send_len)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[8] = get_config_reply
-
-class get_config_request(message):
-    version = 5
-    type = 7
-
-    def __init__(self, xid=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = get_config_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 7)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("get_config_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-message.subtypes[7] = get_config_request
-
-class group_mod(message):
-    subtypes = {}
-
-    version = 5
-    type = 15
-
-    def __init__(self, xid=None, command=None, group_type=None, group_id=None, buckets=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if command != None:
-            self.command = command
-        else:
-            self.command = 0
-        if group_type != None:
-            self.group_type = group_type
-        else:
-            self.group_type = 0
-        if group_id != None:
-            self.group_id = group_id
-        else:
-            self.group_id = 0
-        if buckets != None:
-            self.buckets = buckets
-        else:
-            self.buckets = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.command))
-        packed.append(struct.pack("!B", self.group_type))
-        packed.append('\x00' * 1)
-        packed.append(struct.pack("!L", self.group_id))
-        packed.append(loxi.generic_util.pack_list(self.buckets))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 8)
-        subclass = group_mod.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = group_mod()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 15)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.command = reader.read("!H")[0]
-        obj.group_type = reader.read("!B")[0]
-        reader.skip(1)
-        obj.group_id = reader.read("!L")[0]
-        obj.buckets = loxi.generic_util.unpack_list(reader, ofp.common.bucket.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.command != other.command: return False
-        if self.group_type != other.group_type: return False
-        if self.group_id != other.group_id: return False
-        if self.buckets != other.buckets: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_mod {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("group_type = ");
-                q.text("%#x" % self.group_type)
-                q.text(","); q.breakable()
-                q.text("group_id = ");
-                q.text("%#x" % self.group_id)
-                q.text(","); q.breakable()
-                q.text("buckets = ");
-                q.pp(self.buckets)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[15] = group_mod
-
-class group_add(group_mod):
-    version = 5
-    type = 15
-    command = 0
-
-    def __init__(self, xid=None, group_type=None, group_id=None, buckets=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if group_type != None:
-            self.group_type = group_type
-        else:
-            self.group_type = 0
-        if group_id != None:
-            self.group_id = group_id
-        else:
-            self.group_id = 0
-        if buckets != None:
-            self.buckets = buckets
-        else:
-            self.buckets = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.command))
-        packed.append(struct.pack("!B", self.group_type))
-        packed.append('\x00' * 1)
-        packed.append(struct.pack("!L", self.group_id))
-        packed.append(loxi.generic_util.pack_list(self.buckets))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group_add()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 15)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _command = reader.read("!H")[0]
-        assert(_command == 0)
-        obj.group_type = reader.read("!B")[0]
-        reader.skip(1)
-        obj.group_id = reader.read("!L")[0]
-        obj.buckets = loxi.generic_util.unpack_list(reader, ofp.common.bucket.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.group_type != other.group_type: return False
-        if self.group_id != other.group_id: return False
-        if self.buckets != other.buckets: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_add {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("group_type = ");
-                q.text("%#x" % self.group_type)
-                q.text(","); q.breakable()
-                q.text("group_id = ");
-                q.text("%#x" % self.group_id)
-                q.text(","); q.breakable()
-                q.text("buckets = ");
-                q.pp(self.buckets)
-            q.breakable()
-        q.text('}')
-
-group_mod.subtypes[0] = group_add
-
-class group_delete(group_mod):
-    version = 5
-    type = 15
-    command = 2
-
-    def __init__(self, xid=None, group_type=None, group_id=None, buckets=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if group_type != None:
-            self.group_type = group_type
-        else:
-            self.group_type = 0
-        if group_id != None:
-            self.group_id = group_id
-        else:
-            self.group_id = 0
-        if buckets != None:
-            self.buckets = buckets
-        else:
-            self.buckets = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.command))
-        packed.append(struct.pack("!B", self.group_type))
-        packed.append('\x00' * 1)
-        packed.append(struct.pack("!L", self.group_id))
-        packed.append(loxi.generic_util.pack_list(self.buckets))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group_delete()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 15)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _command = reader.read("!H")[0]
-        assert(_command == 2)
-        obj.group_type = reader.read("!B")[0]
-        reader.skip(1)
-        obj.group_id = reader.read("!L")[0]
-        obj.buckets = loxi.generic_util.unpack_list(reader, ofp.common.bucket.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.group_type != other.group_type: return False
-        if self.group_id != other.group_id: return False
-        if self.buckets != other.buckets: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_delete {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("group_type = ");
-                q.text("%#x" % self.group_type)
-                q.text(","); q.breakable()
-                q.text("group_id = ");
-                q.text("%#x" % self.group_id)
-                q.text(","); q.breakable()
-                q.text("buckets = ");
-                q.pp(self.buckets)
-            q.breakable()
-        q.text('}')
-
-group_mod.subtypes[2] = group_delete
-
-class group_desc_stats_reply(stats_reply):
-    version = 5
-    type = 19
-    stats_type = 7
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group_desc_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 7)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.group_desc_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_desc_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[7] = group_desc_stats_reply
-
-class group_desc_stats_request(stats_request):
-    version = 5
-    type = 18
-    stats_type = 7
-
-    def __init__(self, xid=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group_desc_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 7)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_desc_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[7] = group_desc_stats_request
-
-class group_features_stats_reply(stats_reply):
-    version = 5
-    type = 19
-    stats_type = 8
-
-    def __init__(self, xid=None, flags=None, types=None, capabilities=None, max_groups_all=None, max_groups_select=None, max_groups_indirect=None, max_groups_ff=None, actions_all=None, actions_select=None, actions_indirect=None, actions_ff=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if types != None:
-            self.types = types
-        else:
-            self.types = 0
-        if capabilities != None:
-            self.capabilities = capabilities
-        else:
-            self.capabilities = 0
-        if max_groups_all != None:
-            self.max_groups_all = max_groups_all
-        else:
-            self.max_groups_all = 0
-        if max_groups_select != None:
-            self.max_groups_select = max_groups_select
-        else:
-            self.max_groups_select = 0
-        if max_groups_indirect != None:
-            self.max_groups_indirect = max_groups_indirect
-        else:
-            self.max_groups_indirect = 0
-        if max_groups_ff != None:
-            self.max_groups_ff = max_groups_ff
-        else:
-            self.max_groups_ff = 0
-        if actions_all != None:
-            self.actions_all = actions_all
-        else:
-            self.actions_all = 0
-        if actions_select != None:
-            self.actions_select = actions_select
-        else:
-            self.actions_select = 0
-        if actions_indirect != None:
-            self.actions_indirect = actions_indirect
-        else:
-            self.actions_indirect = 0
-        if actions_ff != None:
-            self.actions_ff = actions_ff
-        else:
-            self.actions_ff = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.types))
-        packed.append(struct.pack("!L", self.capabilities))
-        packed.append(struct.pack("!L", self.max_groups_all))
-        packed.append(struct.pack("!L", self.max_groups_select))
-        packed.append(struct.pack("!L", self.max_groups_indirect))
-        packed.append(struct.pack("!L", self.max_groups_ff))
-        packed.append(struct.pack("!L", self.actions_all))
-        packed.append(struct.pack("!L", self.actions_select))
-        packed.append(struct.pack("!L", self.actions_indirect))
-        packed.append(struct.pack("!L", self.actions_ff))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group_features_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 8)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.types = reader.read("!L")[0]
-        obj.capabilities = reader.read("!L")[0]
-        obj.max_groups_all = reader.read("!L")[0]
-        obj.max_groups_select = reader.read("!L")[0]
-        obj.max_groups_indirect = reader.read("!L")[0]
-        obj.max_groups_ff = reader.read("!L")[0]
-        obj.actions_all = reader.read("!L")[0]
-        obj.actions_select = reader.read("!L")[0]
-        obj.actions_indirect = reader.read("!L")[0]
-        obj.actions_ff = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.types != other.types: return False
-        if self.capabilities != other.capabilities: return False
-        if self.max_groups_all != other.max_groups_all: return False
-        if self.max_groups_select != other.max_groups_select: return False
-        if self.max_groups_indirect != other.max_groups_indirect: return False
-        if self.max_groups_ff != other.max_groups_ff: return False
-        if self.actions_all != other.actions_all: return False
-        if self.actions_select != other.actions_select: return False
-        if self.actions_indirect != other.actions_indirect: return False
-        if self.actions_ff != other.actions_ff: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_features_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("types = ");
-                q.text("%#x" % self.types)
-                q.text(","); q.breakable()
-                q.text("capabilities = ");
-                q.text("%#x" % self.capabilities)
-                q.text(","); q.breakable()
-                q.text("max_groups_all = ");
-                q.text("%#x" % self.max_groups_all)
-                q.text(","); q.breakable()
-                q.text("max_groups_select = ");
-                q.text("%#x" % self.max_groups_select)
-                q.text(","); q.breakable()
-                q.text("max_groups_indirect = ");
-                q.text("%#x" % self.max_groups_indirect)
-                q.text(","); q.breakable()
-                q.text("max_groups_ff = ");
-                q.text("%#x" % self.max_groups_ff)
-                q.text(","); q.breakable()
-                q.text("actions_all = ");
-                q.text("%#x" % self.actions_all)
-                q.text(","); q.breakable()
-                q.text("actions_select = ");
-                q.text("%#x" % self.actions_select)
-                q.text(","); q.breakable()
-                q.text("actions_indirect = ");
-                q.text("%#x" % self.actions_indirect)
-                q.text(","); q.breakable()
-                q.text("actions_ff = ");
-                q.text("%#x" % self.actions_ff)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[8] = group_features_stats_reply
-
-class group_features_stats_request(stats_request):
-    version = 5
-    type = 18
-    stats_type = 8
-
-    def __init__(self, xid=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group_features_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 8)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_features_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[8] = group_features_stats_request
-
-class group_mod_failed_error_msg(error_msg):
-    version = 5
-    type = 1
-    err_type = 6
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group_mod_failed_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 6)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_mod_failed_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[6] = group_mod_failed_error_msg
-
-class group_modify(group_mod):
-    version = 5
-    type = 15
-    command = 1
-
-    def __init__(self, xid=None, group_type=None, group_id=None, buckets=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if group_type != None:
-            self.group_type = group_type
-        else:
-            self.group_type = 0
-        if group_id != None:
-            self.group_id = group_id
-        else:
-            self.group_id = 0
-        if buckets != None:
-            self.buckets = buckets
-        else:
-            self.buckets = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.command))
-        packed.append(struct.pack("!B", self.group_type))
-        packed.append('\x00' * 1)
-        packed.append(struct.pack("!L", self.group_id))
-        packed.append(loxi.generic_util.pack_list(self.buckets))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group_modify()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 15)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _command = reader.read("!H")[0]
-        assert(_command == 1)
-        obj.group_type = reader.read("!B")[0]
-        reader.skip(1)
-        obj.group_id = reader.read("!L")[0]
-        obj.buckets = loxi.generic_util.unpack_list(reader, ofp.common.bucket.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.group_type != other.group_type: return False
-        if self.group_id != other.group_id: return False
-        if self.buckets != other.buckets: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_modify {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("group_type = ");
-                q.text("%#x" % self.group_type)
-                q.text(","); q.breakable()
-                q.text("group_id = ");
-                q.text("%#x" % self.group_id)
-                q.text(","); q.breakable()
-                q.text("buckets = ");
-                q.pp(self.buckets)
-            q.breakable()
-        q.text('}')
-
-group_mod.subtypes[1] = group_modify
-
-class group_stats_reply(stats_reply):
-    version = 5
-    type = 19
-    stats_type = 6
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 6)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.group_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[6] = group_stats_reply
-
-class group_stats_request(stats_request):
-    version = 5
-    type = 18
-    stats_type = 6
-
-    def __init__(self, xid=None, flags=None, group_id=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if group_id != None:
-            self.group_id = group_id
-        else:
-            self.group_id = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.group_id))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = group_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 6)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.group_id = reader.read("!L")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.group_id != other.group_id: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("group_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("group_id = ");
-                q.text("%#x" % self.group_id)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[6] = group_stats_request
-
-class hello(message):
-    version = 5
-    type = 0
-
-    def __init__(self, xid=None, elements=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if elements != None:
-            self.elements = elements
-        else:
-            self.elements = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(loxi.generic_util.pack_list(self.elements))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = hello()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 0)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.elements = loxi.generic_util.unpack_list(reader, ofp.common.hello_elem.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.elements != other.elements: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("hello {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("elements = ");
-                q.pp(self.elements)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[0] = hello
-
-class hello_failed_error_msg(error_msg):
-    version = 5
-    type = 1
-    err_type = 0
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = hello_failed_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 0)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("hello_failed_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[0] = hello_failed_error_msg
-
-class meter_config_stats_reply(stats_reply):
-    version = 5
-    type = 19
-    stats_type = 10
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = meter_config_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 10)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.meter_config.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("meter_config_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[10] = meter_config_stats_reply
-
-class meter_config_stats_request(stats_request):
-    version = 5
-    type = 18
-    stats_type = 10
-
-    def __init__(self, xid=None, flags=None, meter_id=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if meter_id != None:
-            self.meter_id = meter_id
-        else:
-            self.meter_id = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.meter_id))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = meter_config_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 10)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.meter_id = reader.read("!L")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.meter_id != other.meter_id: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("meter_config_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("meter_id = ");
-                q.text("%#x" % self.meter_id)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[10] = meter_config_stats_request
-
-class meter_features_stats_reply(stats_reply):
-    version = 5
-    type = 19
-    stats_type = 11
-
-    def __init__(self, xid=None, flags=None, features=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if features != None:
-            self.features = features
-        else:
-            self.features = ofp.meter_features()
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(self.features.pack())
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = meter_features_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 11)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.features = ofp.meter_features.unpack(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.features != other.features: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("meter_features_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("features = ");
-                q.pp(self.features)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[11] = meter_features_stats_reply
-
-class meter_features_stats_request(stats_request):
-    version = 5
-    type = 18
-    stats_type = 11
-
-    def __init__(self, xid=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = meter_features_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 11)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("meter_features_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[11] = meter_features_stats_request
-
-class meter_mod(message):
-    version = 5
-    type = 29
-
-    def __init__(self, xid=None, command=None, flags=None, meter_id=None, bands=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if command != None:
-            self.command = command
-        else:
-            self.command = 0
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if meter_id != None:
-            self.meter_id = meter_id
-        else:
-            self.meter_id = 0
-        if bands != None:
-            self.bands = bands
-        else:
-            self.bands = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.command))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append(struct.pack("!L", self.meter_id))
-        packed.append(loxi.generic_util.pack_list(self.bands))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = meter_mod()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 29)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.command = reader.read("!H")[0]
-        obj.flags = reader.read("!H")[0]
-        obj.meter_id = reader.read("!L")[0]
-        obj.bands = loxi.generic_util.unpack_list(reader, ofp.meter_band.meter_band.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.command != other.command: return False
-        if self.flags != other.flags: return False
-        if self.meter_id != other.meter_id: return False
-        if self.bands != other.bands: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("meter_mod {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("command = ");
-                q.text("%#x" % self.command)
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("meter_id = ");
-                q.text("%#x" % self.meter_id)
-                q.text(","); q.breakable()
-                q.text("bands = ");
-                q.pp(self.bands)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[29] = meter_mod
-
-class meter_mod_failed_error_msg(error_msg):
-    version = 5
-    type = 1
-    err_type = 12
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = meter_mod_failed_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 12)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("meter_mod_failed_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[12] = meter_mod_failed_error_msg
-
-class meter_stats_reply(stats_reply):
-    version = 5
-    type = 19
-    stats_type = 9
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = meter_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 9)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.meter_stats.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("meter_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[9] = meter_stats_reply
-
-class meter_stats_request(stats_request):
-    version = 5
-    type = 18
-    stats_type = 9
-
-    def __init__(self, xid=None, flags=None, meter_id=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if meter_id != None:
-            self.meter_id = meter_id
-        else:
-            self.meter_id = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.meter_id))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = meter_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 9)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.meter_id = reader.read("!L")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.meter_id != other.meter_id: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("meter_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("meter_id = ");
-                q.text("%#x" % self.meter_id)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[9] = meter_stats_request
-
-class nicira_header(experimenter):
-    subtypes = {}
-
-    version = 5
-    type = 4
-    experimenter = 8992
-
-    def __init__(self, xid=None, subtype=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if subtype != None:
-            self.subtype = subtype
-        else:
-            self.subtype = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.subtype))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 12)
-        subclass = nicira_header.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = nicira_header()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 4)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 8992)
-        obj.subtype = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.subtype != other.subtype: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("nicira_header {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-            q.breakable()
-        q.text('}')
-
-experimenter.subtypes[8992] = nicira_header
-
-class packet_in(message):
-    version = 5
-    type = 10
-
-    def __init__(self, xid=None, buffer_id=None, total_len=None, reason=None, table_id=None, cookie=None, match=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if buffer_id != None:
-            self.buffer_id = buffer_id
-        else:
-            self.buffer_id = 0
-        if total_len != None:
-            self.total_len = total_len
-        else:
-            self.total_len = 0
-        if reason != None:
-            self.reason = reason
-        else:
-            self.reason = 0
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if cookie != None:
-            self.cookie = cookie
-        else:
-            self.cookie = 0
-        if match != None:
-            self.match = match
-        else:
-            self.match = ofp.match()
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.buffer_id))
-        packed.append(struct.pack("!H", self.total_len))
-        packed.append(struct.pack("!B", self.reason))
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append(struct.pack("!Q", self.cookie))
-        packed.append(self.match.pack())
-        packed.append('\x00' * 2)
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = packet_in()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 10)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.buffer_id = reader.read("!L")[0]
-        obj.total_len = reader.read("!H")[0]
-        obj.reason = reader.read("!B")[0]
-        obj.table_id = reader.read("!B")[0]
-        obj.cookie = reader.read("!Q")[0]
-        obj.match = ofp.match.unpack(reader)
-        reader.skip(2)
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.buffer_id != other.buffer_id: return False
-        if self.total_len != other.total_len: return False
-        if self.reason != other.reason: return False
-        if self.table_id != other.table_id: return False
-        if self.cookie != other.cookie: return False
-        if self.match != other.match: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("packet_in {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("buffer_id = ");
-                q.text("%#x" % self.buffer_id)
-                q.text(","); q.breakable()
-                q.text("total_len = ");
-                q.text("%#x" % self.total_len)
-                q.text(","); q.breakable()
-                q.text("reason = ");
-                q.text("%#x" % self.reason)
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("cookie = ");
-                q.text("%#x" % self.cookie)
-                q.text(","); q.breakable()
-                q.text("match = ");
-                q.pp(self.match)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[10] = packet_in
-
-class packet_out(message):
-    version = 5
-    type = 13
-
-    def __init__(self, xid=None, buffer_id=None, in_port=None, actions=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if buffer_id != None:
-            self.buffer_id = buffer_id
-        else:
-            self.buffer_id = 0
-        if in_port != None:
-            self.in_port = in_port
-        else:
-            self.in_port = 0
-        if actions != None:
-            self.actions = actions
-        else:
-            self.actions = []
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.buffer_id))
-        packed.append(util.pack_port_no(self.in_port))
-        packed.append(struct.pack("!H", 0)) # placeholder for actions_len at index 6
-        packed.append('\x00' * 6)
-        packed.append(loxi.generic_util.pack_list(self.actions))
-        packed[6] = struct.pack("!H", len(packed[-1]))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = packet_out()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 13)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.buffer_id = reader.read("!L")[0]
-        obj.in_port = util.unpack_port_no(reader)
-        _actions_len = reader.read("!H")[0]
-        reader.skip(6)
-        obj.actions = loxi.generic_util.unpack_list(reader.slice(_actions_len), ofp.action.action.unpack)
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.buffer_id != other.buffer_id: return False
-        if self.in_port != other.in_port: return False
-        if self.actions != other.actions: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("packet_out {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("buffer_id = ");
-                q.text("%#x" % self.buffer_id)
-                q.text(","); q.breakable()
-                q.text("in_port = ");
-                q.text(util.pretty_port(self.in_port))
-                q.text(","); q.breakable()
-                q.text("actions = ");
-                q.pp(self.actions)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[13] = packet_out
-
-class port_desc_stats_reply(stats_reply):
-    version = 5
-    type = 19
-    stats_type = 13
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = port_desc_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 13)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.port_desc.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port_desc_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[13] = port_desc_stats_reply
-
-class port_desc_stats_request(stats_request):
-    version = 5
-    type = 18
-    stats_type = 13
-
-    def __init__(self, xid=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = port_desc_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 13)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port_desc_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[13] = port_desc_stats_request
-
-class port_mod(message):
-    version = 5
-    type = 16
-
-    def __init__(self, xid=None, port_no=None, hw_addr=None, config=None, mask=None, properties=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if hw_addr != None:
-            self.hw_addr = hw_addr
-        else:
-            self.hw_addr = [0,0,0,0,0,0]
-        if config != None:
-            self.config = config
-        else:
-            self.config = 0
-        if mask != None:
-            self.mask = mask
-        else:
-            self.mask = 0
-        if properties != None:
-            self.properties = properties
-        else:
-            self.properties = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!6B", *self.hw_addr))
-        packed.append('\x00' * 2)
-        packed.append(struct.pack("!L", self.config))
-        packed.append(struct.pack("!L", self.mask))
-        packed.append(loxi.generic_util.pack_list(self.properties))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = port_mod()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 16)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.port_no = util.unpack_port_no(reader)
-        reader.skip(4)
-        obj.hw_addr = list(reader.read('!6B'))
-        reader.skip(2)
-        obj.config = reader.read("!L")[0]
-        obj.mask = reader.read("!L")[0]
-        obj.properties = loxi.generic_util.unpack_list(reader, ofp.port_mod_prop.port_mod_prop.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.port_no != other.port_no: return False
-        if self.hw_addr != other.hw_addr: return False
-        if self.config != other.config: return False
-        if self.mask != other.mask: return False
-        if self.properties != other.properties: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port_mod {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("hw_addr = ");
-                q.text(util.pretty_mac(self.hw_addr))
-                q.text(","); q.breakable()
-                q.text("config = ");
-                q.text("%#x" % self.config)
-                q.text(","); q.breakable()
-                q.text("mask = ");
-                q.text("%#x" % self.mask)
-                q.text(","); q.breakable()
-                q.text("properties = ");
-                q.pp(self.properties)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[16] = port_mod
-
-class port_mod_failed_error_msg(error_msg):
-    version = 5
-    type = 1
-    err_type = 7
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = port_mod_failed_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 7)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port_mod_failed_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[7] = port_mod_failed_error_msg
-
-class port_stats_reply(stats_reply):
-    version = 5
-    type = 19
-    stats_type = 4
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = port_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 4)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.port_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[4] = port_stats_reply
-
-class port_stats_request(stats_request):
-    version = 5
-    type = 18
-    stats_type = 4
-
-    def __init__(self, xid=None, flags=None, port_no=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = port_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 4)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.port_no = util.unpack_port_no(reader)
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.port_no != other.port_no: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[4] = port_stats_request
-
-class port_status(message):
-    version = 5
-    type = 12
-
-    def __init__(self, xid=None, reason=None, desc=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if reason != None:
-            self.reason = reason
-        else:
-            self.reason = 0
-        if desc != None:
-            self.desc = desc
-        else:
-            self.desc = ofp.port_desc()
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!B", self.reason))
-        packed.append('\x00' * 7)
-        packed.append(self.desc.pack())
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = port_status()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 12)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.reason = reader.read("!B")[0]
-        reader.skip(7)
-        obj.desc = ofp.port_desc.unpack(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.reason != other.reason: return False
-        if self.desc != other.desc: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port_status {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("reason = ");
-                q.text("%#x" % self.reason)
-                q.text(","); q.breakable()
-                q.text("desc = ");
-                q.pp(self.desc)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[12] = port_status
-
-class queue_desc_stats_reply(stats_reply):
-    version = 5
-    type = 19
-    stats_type = 15
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = queue_desc_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 15)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.queue_desc.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_desc_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[15] = queue_desc_stats_reply
-
-class queue_desc_stats_request(stats_request):
-    version = 5
-    type = 18
-    stats_type = 15
-
-    def __init__(self, xid=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = queue_desc_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 15)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_desc_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[15] = queue_desc_stats_request
-
-class queue_op_failed_error_msg(error_msg):
-    version = 5
-    type = 1
-    err_type = 9
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = queue_op_failed_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 9)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_op_failed_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[9] = queue_op_failed_error_msg
-
-class queue_stats_reply(stats_reply):
-    version = 5
-    type = 19
-    stats_type = 5
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = queue_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 5)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.queue_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[5] = queue_stats_reply
-
-class queue_stats_request(stats_request):
-    version = 5
-    type = 18
-    stats_type = 5
-
-    def __init__(self, xid=None, flags=None, port_no=None, queue_id=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if port_no != None:
-            self.port_no = port_no
-        else:
-            self.port_no = 0
-        if queue_id != None:
-            self.queue_id = queue_id
-        else:
-            self.queue_id = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(util.pack_port_no(self.port_no))
-        packed.append(struct.pack("!L", self.queue_id))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = queue_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 5)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.port_no = util.unpack_port_no(reader)
-        obj.queue_id = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.port_no != other.port_no: return False
-        if self.queue_id != other.queue_id: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("port_no = ");
-                q.text(util.pretty_port(self.port_no))
-                q.text(","); q.breakable()
-                q.text("queue_id = ");
-                q.text("%#x" % self.queue_id)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[5] = queue_stats_request
-
-class requestforward(message):
-    version = 5
-    type = 32
-
-    def __init__(self, xid=None, role=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if role != None:
-            self.role = role
-        else:
-            self.role = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.role))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = requestforward()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 32)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.role = reader.read("!L")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.role != other.role: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("requestforward {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("role = ");
-                q.text("%#x" % self.role)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[32] = requestforward
-
-class role_reply(message):
-    version = 5
-    type = 25
-
-    def __init__(self, xid=None, role=None, generation_id=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if role != None:
-            self.role = role
-        else:
-            self.role = 0
-        if generation_id != None:
-            self.generation_id = generation_id
-        else:
-            self.generation_id = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.role))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!Q", self.generation_id))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = role_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 25)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.role = reader.read("!L")[0]
-        reader.skip(4)
-        obj.generation_id = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.role != other.role: return False
-        if self.generation_id != other.generation_id: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("role_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("role = ");
-                q.text("%#x" % self.role)
-                q.text(","); q.breakable()
-                q.text("generation_id = ");
-                q.text("%#x" % self.generation_id)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[25] = role_reply
-
-class role_request(message):
-    version = 5
-    type = 24
-
-    def __init__(self, xid=None, role=None, generation_id=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if role != None:
-            self.role = role
-        else:
-            self.role = 0
-        if generation_id != None:
-            self.generation_id = generation_id
-        else:
-            self.generation_id = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.role))
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!Q", self.generation_id))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = role_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 24)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.role = reader.read("!L")[0]
-        reader.skip(4)
-        obj.generation_id = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.role != other.role: return False
-        if self.generation_id != other.generation_id: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("role_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("role = ");
-                q.text("%#x" % self.role)
-                q.text(","); q.breakable()
-                q.text("generation_id = ");
-                q.text("%#x" % self.generation_id)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[24] = role_request
-
-class role_request_failed_error_msg(error_msg):
-    version = 5
-    type = 1
-    err_type = 11
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = role_request_failed_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 11)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("role_request_failed_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[11] = role_request_failed_error_msg
-
-class role_status(message):
-    version = 5
-    type = 30
-
-    def __init__(self, xid=None, role=None, reason=None, generation_id=None, properties=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if role != None:
-            self.role = role
-        else:
-            self.role = 0
-        if reason != None:
-            self.reason = reason
-        else:
-            self.reason = 0
-        if generation_id != None:
-            self.generation_id = generation_id
-        else:
-            self.generation_id = 0
-        if properties != None:
-            self.properties = properties
-        else:
-            self.properties = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.role))
-        packed.append(struct.pack("!B", self.reason))
-        packed.append('\x00' * 3)
-        packed.append(struct.pack("!Q", self.generation_id))
-        packed.append(loxi.generic_util.pack_list(self.properties))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = role_status()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 30)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.role = reader.read("!L")[0]
-        obj.reason = reader.read("!B")[0]
-        reader.skip(3)
-        obj.generation_id = reader.read("!Q")[0]
-        obj.properties = loxi.generic_util.unpack_list(reader, ofp.role_prop.role_prop.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.role != other.role: return False
-        if self.reason != other.reason: return False
-        if self.generation_id != other.generation_id: return False
-        if self.properties != other.properties: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("role_status {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("role = ");
-                q.text("%#x" % self.role)
-                q.text(","); q.breakable()
-                q.text("reason = ");
-                q.text("%#x" % self.reason)
-                q.text(","); q.breakable()
-                q.text("generation_id = ");
-                q.text("%#x" % self.generation_id)
-                q.text(","); q.breakable()
-                q.text("properties = ");
-                q.pp(self.properties)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[30] = role_status
-
-class set_config(message):
-    version = 5
-    type = 9
-
-    def __init__(self, xid=None, flags=None, miss_send_len=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if miss_send_len != None:
-            self.miss_send_len = miss_send_len
-        else:
-            self.miss_send_len = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append(struct.pack("!H", self.miss_send_len))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = set_config()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 9)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.flags = reader.read("!H")[0]
-        obj.miss_send_len = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.miss_send_len != other.miss_send_len: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("set_config {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("miss_send_len = ");
-                q.text("%#x" % self.miss_send_len)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[9] = set_config
-
-class switch_config_failed_error_msg(error_msg):
-    version = 5
-    type = 1
-    err_type = 10
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = switch_config_failed_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 10)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("switch_config_failed_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[10] = switch_config_failed_error_msg
-
-class table_desc_stats_reply(stats_reply):
-    version = 5
-    type = 19
-    stats_type = 14
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_desc_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 14)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.table_desc.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_desc_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[14] = table_desc_stats_reply
-
-class table_desc_stats_request(stats_request):
-    version = 5
-    type = 18
-    stats_type = 14
-
-    def __init__(self, xid=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_desc_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 14)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_desc_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[14] = table_desc_stats_request
-
-class table_features_failed_error_msg(error_msg):
-    version = 5
-    type = 1
-    err_type = 13
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_features_failed_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 13)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_features_failed_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[13] = table_features_failed_error_msg
-
-class table_features_stats_reply(stats_reply):
-    version = 5
-    type = 19
-    stats_type = 12
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_features_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 12)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.table_features.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_features_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[12] = table_features_stats_reply
-
-class table_features_stats_request(stats_request):
-    version = 5
-    type = 18
-    stats_type = 12
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_features_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 12)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.table_features.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_features_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[12] = table_features_stats_request
-
-class table_mod(message):
-    version = 5
-    type = 17
-
-    def __init__(self, xid=None, table_id=None, config=None, properties=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if table_id != None:
-            self.table_id = table_id
-        else:
-            self.table_id = 0
-        if config != None:
-            self.config = config
-        else:
-            self.config = 0
-        if properties != None:
-            self.properties = properties
-        else:
-            self.properties = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!B", self.table_id))
-        packed.append('\x00' * 3)
-        packed.append(struct.pack("!L", self.config))
-        packed.append(loxi.generic_util.pack_list(self.properties))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_mod()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 17)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.table_id = reader.read("!B")[0]
-        reader.skip(3)
-        obj.config = reader.read("!L")[0]
-        obj.properties = loxi.generic_util.unpack_list(reader, ofp.table_mod_prop.table_mod_prop.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.table_id != other.table_id: return False
-        if self.config != other.config: return False
-        if self.properties != other.properties: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_mod {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("table_id = ");
-                q.text("%#x" % self.table_id)
-                q.text(","); q.breakable()
-                q.text("config = ");
-                q.text("%#x" % self.config)
-                q.text(","); q.breakable()
-                q.text("properties = ");
-                q.pp(self.properties)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[17] = table_mod
-
-class table_mod_failed_error_msg(error_msg):
-    version = 5
-    type = 1
-    err_type = 8
-
-    def __init__(self, xid=None, code=None, data=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if code != None:
-            self.code = code
-        else:
-            self.code = 0
-        if data != None:
-            self.data = data
-        else:
-            self.data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.err_type))
-        packed.append(struct.pack("!H", self.code))
-        packed.append(self.data)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_mod_failed_error_msg()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _err_type = reader.read("!H")[0]
-        assert(_err_type == 8)
-        obj.code = reader.read("!H")[0]
-        obj.data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.code != other.code: return False
-        if self.data != other.data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_mod_failed_error_msg {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("code = ");
-                q.text("%#x" % self.code)
-                q.text(","); q.breakable()
-                q.text("data = ");
-                q.pp(self.data)
-            q.breakable()
-        q.text('}')
-
-error_msg.subtypes[8] = table_mod_failed_error_msg
-
-class table_stats_reply(stats_reply):
-    version = 5
-    type = 19
-    stats_type = 3
-
-    def __init__(self, xid=None, flags=None, entries=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if entries != None:
-            self.entries = entries
-        else:
-            self.entries = []
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        packed.append(loxi.generic_util.pack_list(self.entries))
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_stats_reply()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 19)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 3)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        obj.entries = loxi.generic_util.unpack_list(reader, ofp.common.table_stats_entry.unpack)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        if self.entries != other.entries: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_stats_reply {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("entries = ");
-                q.pp(self.entries)
-            q.breakable()
-        q.text('}')
-
-stats_reply.subtypes[3] = table_stats_reply
-
-class table_stats_request(stats_request):
-    version = 5
-    type = 18
-    stats_type = 3
-
-    def __init__(self, xid=None, flags=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!H", self.stats_type))
-        packed.append(struct.pack("!H", self.flags))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_stats_request()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 18)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        _stats_type = reader.read("!H")[0]
-        assert(_stats_type == 3)
-        obj.flags = reader.read("!H")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.flags != other.flags: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_stats_request {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-            q.breakable()
-        q.text('}')
-
-stats_request.subtypes[3] = table_stats_request
-
-class table_status(message):
-    version = 5
-    type = 31
-
-    def __init__(self, xid=None, role=None, reason=None, table=None):
-        if xid != None:
-            self.xid = xid
-        else:
-            self.xid = None
-        if role != None:
-            self.role = role
-        else:
-            self.role = 0
-        if reason != None:
-            self.reason = reason
-        else:
-            self.reason = 0
-        if table != None:
-            self.table = table
-        else:
-            self.table = ofp.table_desc()
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!B", self.version))
-        packed.append(struct.pack("!B", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
-        packed.append(struct.pack("!L", self.xid))
-        packed.append(struct.pack("!L", self.role))
-        packed.append(struct.pack("!B", self.reason))
-        packed.append('\x00' * 7)
-        packed.append(self.table.pack())
-        length = sum([len(x) for x in packed])
-        packed[2] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = table_status()
-        _version = reader.read("!B")[0]
-        assert(_version == 5)
-        _type = reader.read("!B")[0]
-        assert(_type == 31)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.xid = reader.read("!L")[0]
-        obj.role = reader.read("!L")[0]
-        obj.reason = reader.read("!B")[0]
-        reader.skip(7)
-        obj.table = ofp.table_desc.unpack(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.xid != other.xid: return False
-        if self.role != other.role: return False
-        if self.reason != other.reason: return False
-        if self.table != other.table: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_status {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("xid = ");
-                if self.xid != None:
-                    q.text("%#x" % self.xid)
-                else:
-                    q.text('None')
-                q.text(","); q.breakable()
-                q.text("role = ");
-                q.text("%#x" % self.role)
-                q.text(","); q.breakable()
-                q.text("reason = ");
-                q.text("%#x" % self.reason)
-                q.text(","); q.breakable()
-                q.text("table = ");
-                q.pp(self.table)
-            q.breakable()
-        q.text('}')
-
-message.subtypes[31] = table_status
-
-
-def parse_header(buf):
-    if len(buf) < 8:
-        raise loxi.ProtocolError("too short to be an OpenFlow message")
-    return struct.unpack_from("!BBHL", buf)
-
-def parse_message(buf):
-    msg_ver, msg_type, msg_len, msg_xid = parse_header(buf)
-    if msg_ver != ofp.OFP_VERSION and msg_type != ofp.OFPT_HELLO:
-        raise loxi.ProtocolError("wrong OpenFlow version (expected %d, got %d)" % (ofp.OFP_VERSION, msg_ver))
-    if len(buf) != msg_len:
-        raise loxi.ProtocolError("incorrect message size")
-    return message.unpack(loxi.generic_util.OFReader(buf))
diff --git a/python/ofagent/loxi/of14/meter_band.py b/python/ofagent/loxi/of14/meter_band.py
deleted file mode 100644
index 21ca49e..0000000
--- a/python/ofagent/loxi/of14/meter_band.py
+++ /dev/null
@@ -1,272 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template module.py
-# Do not modify
-
-import struct
-import loxi
-import util
-import loxi.generic_util
-
-import sys
-ofp = sys.modules['loxi.of14']
-
-class meter_band(loxi.OFObject):
-    subtypes = {}
-
-
-    def __init__(self, type=None):
-        if type != None:
-            self.type = type
-        else:
-            self.type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 0)
-        subclass = meter_band.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = meter_band()
-        obj.type = reader.read("!H")[0]
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type != other.type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("meter_band {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-
-class drop(meter_band):
-    type = 1
-
-    def __init__(self, rate=None, burst_size=None):
-        if rate != None:
-            self.rate = rate
-        else:
-            self.rate = 0
-        if burst_size != None:
-            self.burst_size = burst_size
-        else:
-            self.burst_size = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.rate))
-        packed.append(struct.pack("!L", self.burst_size))
-        packed.append('\x00' * 4)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = drop()
-        _type = reader.read("!H")[0]
-        assert(_type == 1)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.rate = reader.read("!L")[0]
-        obj.burst_size = reader.read("!L")[0]
-        reader.skip(4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.rate != other.rate: return False
-        if self.burst_size != other.burst_size: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("drop {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("rate = ");
-                q.text("%#x" % self.rate)
-                q.text(","); q.breakable()
-                q.text("burst_size = ");
-                q.text("%#x" % self.burst_size)
-            q.breakable()
-        q.text('}')
-
-meter_band.subtypes[1] = drop
-
-class dscp_remark(meter_band):
-    type = 2
-
-    def __init__(self, rate=None, burst_size=None, prec_level=None):
-        if rate != None:
-            self.rate = rate
-        else:
-            self.rate = 0
-        if burst_size != None:
-            self.burst_size = burst_size
-        else:
-            self.burst_size = 0
-        if prec_level != None:
-            self.prec_level = prec_level
-        else:
-            self.prec_level = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.rate))
-        packed.append(struct.pack("!L", self.burst_size))
-        packed.append(struct.pack("!B", self.prec_level))
-        packed.append('\x00' * 3)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = dscp_remark()
-        _type = reader.read("!H")[0]
-        assert(_type == 2)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.rate = reader.read("!L")[0]
-        obj.burst_size = reader.read("!L")[0]
-        obj.prec_level = reader.read("!B")[0]
-        reader.skip(3)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.rate != other.rate: return False
-        if self.burst_size != other.burst_size: return False
-        if self.prec_level != other.prec_level: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("dscp_remark {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("rate = ");
-                q.text("%#x" % self.rate)
-                q.text(","); q.breakable()
-                q.text("burst_size = ");
-                q.text("%#x" % self.burst_size)
-                q.text(","); q.breakable()
-                q.text("prec_level = ");
-                q.text("%#x" % self.prec_level)
-            q.breakable()
-        q.text('}')
-
-meter_band.subtypes[2] = dscp_remark
-
-class experimenter(meter_band):
-    type = 65535
-
-    def __init__(self, rate=None, burst_size=None, experimenter=None):
-        if rate != None:
-            self.rate = rate
-        else:
-            self.rate = 0
-        if burst_size != None:
-            self.burst_size = burst_size
-        else:
-            self.burst_size = 0
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for len at index 1
-        packed.append(struct.pack("!L", self.rate))
-        packed.append(struct.pack("!L", self.burst_size))
-        packed.append(struct.pack("!L", self.experimenter))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = experimenter()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _len = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_len, 4)
-        obj.rate = reader.read("!L")[0]
-        obj.burst_size = reader.read("!L")[0]
-        obj.experimenter = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.rate != other.rate: return False
-        if self.burst_size != other.burst_size: return False
-        if self.experimenter != other.experimenter: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("experimenter {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("rate = ");
-                q.text("%#x" % self.rate)
-                q.text(","); q.breakable()
-                q.text("burst_size = ");
-                q.text("%#x" % self.burst_size)
-                q.text(","); q.breakable()
-                q.text("experimenter = ");
-                q.text("%#x" % self.experimenter)
-            q.breakable()
-        q.text('}')
-
-meter_band.subtypes[65535] = experimenter
-
-
diff --git a/python/ofagent/loxi/of14/oxm.py b/python/ofagent/loxi/of14/oxm.py
deleted file mode 100644
index d446ebe..0000000
--- a/python/ofagent/loxi/of14/oxm.py
+++ /dev/null
@@ -1,6143 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template module.py
-# Do not modify
-
-import struct
-import loxi
-import util
-import loxi.generic_util
-
-import sys
-ofp = sys.modules['loxi.of14']
-
-class oxm(loxi.OFObject):
-    subtypes = {}
-
-
-    def __init__(self, type_len=None):
-        if type_len != None:
-            self.type_len = type_len
-        else:
-            self.type_len = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 0)
-        subclass = oxm.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = oxm()
-        obj.type_len = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type_len != other.type_len: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("oxm {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-
-class arp_op(oxm):
-    type_len = 2147494402
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = arp_op()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147494402)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("arp_op {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147494402] = arp_op
-
-class arp_op_masked(oxm):
-    type_len = 2147494660
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        packed.append(struct.pack("!H", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = arp_op_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147494660)
-        obj.value = reader.read("!H")[0]
-        obj.value_mask = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("arp_op_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147494660] = arp_op_masked
-
-class arp_sha(oxm):
-    type_len = 2147495942
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!6B", *self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = arp_sha()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147495942)
-        obj.value = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("arp_sha {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147495942] = arp_sha
-
-class arp_sha_masked(oxm):
-    type_len = 2147496204
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!6B", *self.value))
-        packed.append(struct.pack("!6B", *self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = arp_sha_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147496204)
-        obj.value = list(reader.read('!6B'))
-        obj.value_mask = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("arp_sha_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text(util.pretty_mac(self.value_mask))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147496204] = arp_sha_masked
-
-class arp_spa(oxm):
-    type_len = 2147494916
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = arp_spa()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147494916)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("arp_spa {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147494916] = arp_spa
-
-class arp_spa_masked(oxm):
-    type_len = 2147495176
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = arp_spa_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147495176)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("arp_spa_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147495176] = arp_spa_masked
-
-class arp_tha(oxm):
-    type_len = 2147496454
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!6B", *self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = arp_tha()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147496454)
-        obj.value = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("arp_tha {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147496454] = arp_tha
-
-class arp_tha_masked(oxm):
-    type_len = 2147496716
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!6B", *self.value))
-        packed.append(struct.pack("!6B", *self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = arp_tha_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147496716)
-        obj.value = list(reader.read('!6B'))
-        obj.value_mask = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("arp_tha_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text(util.pretty_mac(self.value_mask))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147496716] = arp_tha_masked
-
-class arp_tpa(oxm):
-    type_len = 2147495428
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = arp_tpa()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147495428)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("arp_tpa {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147495428] = arp_tpa
-
-class arp_tpa_masked(oxm):
-    type_len = 2147495688
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = arp_tpa_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147495688)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("arp_tpa_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147495688] = arp_tpa_masked
-
-class bsn_egr_port_group_id(oxm):
-    type_len = 200196
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_egr_port_group_id()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 200196)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_egr_port_group_id {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[200196] = bsn_egr_port_group_id
-
-class bsn_egr_port_group_id_masked(oxm):
-    type_len = 200456
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_egr_port_group_id_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 200456)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_egr_port_group_id_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[200456] = bsn_egr_port_group_id_masked
-
-class bsn_in_ports_128(oxm):
-    type_len = 196624
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = set()
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(util.pack_bitmap_128(self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_in_ports_128()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 196624)
-        obj.value = util.unpack_bitmap_128(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_in_ports_128 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.pp(self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[196624] = bsn_in_ports_128
-
-class bsn_in_ports_128_masked(oxm):
-    type_len = 196896
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = set()
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = set()
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(util.pack_bitmap_128(self.value))
-        packed.append(util.pack_bitmap_128(self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_in_ports_128_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 196896)
-        obj.value = util.unpack_bitmap_128(reader)
-        obj.value_mask = util.unpack_bitmap_128(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_in_ports_128_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.pp(self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.pp(self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[196896] = bsn_in_ports_128_masked
-
-class bsn_in_ports_512(oxm):
-    type_len = 206400
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = set()
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(util.pack_bitmap_512(self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_in_ports_512()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 206400)
-        obj.value = util.unpack_bitmap_512(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_in_ports_512 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.pp(self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[206400] = bsn_in_ports_512
-
-class bsn_in_ports_512_masked(oxm):
-    type_len = 206720
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = set()
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = set()
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(util.pack_bitmap_512(self.value))
-        packed.append(util.pack_bitmap_512(self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_in_ports_512_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 206720)
-        obj.value = util.unpack_bitmap_512(reader)
-        obj.value_mask = util.unpack_bitmap_512(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_in_ports_512_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.pp(self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.pp(self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[206720] = bsn_in_ports_512_masked
-
-class bsn_ingress_port_group_id(oxm):
-    type_len = 206852
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_ingress_port_group_id()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 206852)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_ingress_port_group_id {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[206852] = bsn_ingress_port_group_id
-
-class bsn_ingress_port_group_id_masked(oxm):
-    type_len = 207112
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_ingress_port_group_id_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 207112)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_ingress_port_group_id_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[207112] = bsn_ingress_port_group_id_masked
-
-class bsn_inner_eth_dst(oxm):
-    type_len = 207878
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!6B", *self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_inner_eth_dst()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 207878)
-        obj.value = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_inner_eth_dst {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[207878] = bsn_inner_eth_dst
-
-class bsn_inner_eth_dst_masked(oxm):
-    type_len = 208140
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!6B", *self.value))
-        packed.append(struct.pack("!6B", *self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_inner_eth_dst_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 208140)
-        obj.value = list(reader.read('!6B'))
-        obj.value_mask = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_inner_eth_dst_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text(util.pretty_mac(self.value_mask))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[208140] = bsn_inner_eth_dst_masked
-
-class bsn_inner_eth_src(oxm):
-    type_len = 208390
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!6B", *self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_inner_eth_src()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 208390)
-        obj.value = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_inner_eth_src {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[208390] = bsn_inner_eth_src
-
-class bsn_inner_eth_src_masked(oxm):
-    type_len = 208652
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!6B", *self.value))
-        packed.append(struct.pack("!6B", *self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_inner_eth_src_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 208652)
-        obj.value = list(reader.read('!6B'))
-        obj.value_mask = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_inner_eth_src_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text(util.pretty_mac(self.value_mask))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[208652] = bsn_inner_eth_src_masked
-
-class bsn_inner_vlan_vid(oxm):
-    type_len = 208898
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_inner_vlan_vid()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 208898)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_inner_vlan_vid {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[208898] = bsn_inner_vlan_vid
-
-class bsn_inner_vlan_vid_masked(oxm):
-    type_len = 209156
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        packed.append(struct.pack("!H", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_inner_vlan_vid_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 209156)
-        obj.value = reader.read("!H")[0]
-        obj.value_mask = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_inner_vlan_vid_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[209156] = bsn_inner_vlan_vid_masked
-
-class bsn_l2_cache_hit(oxm):
-    type_len = 205825
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_l2_cache_hit()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 205825)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_l2_cache_hit {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[205825] = bsn_l2_cache_hit
-
-class bsn_l2_cache_hit_masked(oxm):
-    type_len = 206082
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        packed.append(struct.pack("!B", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_l2_cache_hit_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 206082)
-        obj.value = reader.read("!B")[0]
-        obj.value_mask = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_l2_cache_hit_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[206082] = bsn_l2_cache_hit_masked
-
-class bsn_l3_interface_class_id(oxm):
-    type_len = 198660
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_l3_interface_class_id()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 198660)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_l3_interface_class_id {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[198660] = bsn_l3_interface_class_id
-
-class bsn_l3_interface_class_id_masked(oxm):
-    type_len = 198920
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_l3_interface_class_id_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 198920)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_l3_interface_class_id_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[198920] = bsn_l3_interface_class_id_masked
-
-class bsn_l3_src_class_id(oxm):
-    type_len = 199172
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_l3_src_class_id()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 199172)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_l3_src_class_id {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[199172] = bsn_l3_src_class_id
-
-class bsn_l3_src_class_id_masked(oxm):
-    type_len = 199432
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_l3_src_class_id_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 199432)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_l3_src_class_id_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[199432] = bsn_l3_src_class_id_masked
-
-class bsn_lag_id(oxm):
-    type_len = 197124
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_lag_id()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 197124)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_lag_id {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[197124] = bsn_lag_id
-
-class bsn_lag_id_masked(oxm):
-    type_len = 197384
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_lag_id_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 197384)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_lag_id_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[197384] = bsn_lag_id_masked
-
-class bsn_tcp_flags(oxm):
-    type_len = 204802
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_tcp_flags()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 204802)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_tcp_flags {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[204802] = bsn_tcp_flags
-
-class bsn_tcp_flags_masked(oxm):
-    type_len = 205060
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        packed.append(struct.pack("!H", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_tcp_flags_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 205060)
-        obj.value = reader.read("!H")[0]
-        obj.value_mask = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_tcp_flags_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[205060] = bsn_tcp_flags_masked
-
-class bsn_udf0(oxm):
-    type_len = 200708
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf0()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 200708)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf0 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[200708] = bsn_udf0
-
-class bsn_udf0_masked(oxm):
-    type_len = 200968
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf0_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 200968)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf0_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[200968] = bsn_udf0_masked
-
-class bsn_udf1(oxm):
-    type_len = 201220
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf1()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 201220)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf1 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[201220] = bsn_udf1
-
-class bsn_udf1_masked(oxm):
-    type_len = 201480
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf1_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 201480)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf1_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[201480] = bsn_udf1_masked
-
-class bsn_udf2(oxm):
-    type_len = 201732
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf2()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 201732)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf2 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[201732] = bsn_udf2
-
-class bsn_udf2_masked(oxm):
-    type_len = 201992
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf2_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 201992)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf2_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[201992] = bsn_udf2_masked
-
-class bsn_udf3(oxm):
-    type_len = 202244
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf3()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 202244)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf3 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[202244] = bsn_udf3
-
-class bsn_udf3_masked(oxm):
-    type_len = 202504
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf3_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 202504)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf3_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[202504] = bsn_udf3_masked
-
-class bsn_udf4(oxm):
-    type_len = 202756
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf4()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 202756)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf4 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[202756] = bsn_udf4
-
-class bsn_udf4_masked(oxm):
-    type_len = 203016
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf4_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 203016)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf4_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[203016] = bsn_udf4_masked
-
-class bsn_udf5(oxm):
-    type_len = 203268
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf5()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 203268)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf5 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[203268] = bsn_udf5
-
-class bsn_udf5_masked(oxm):
-    type_len = 203528
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf5_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 203528)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf5_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[203528] = bsn_udf5_masked
-
-class bsn_udf6(oxm):
-    type_len = 203780
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf6()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 203780)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf6 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[203780] = bsn_udf6
-
-class bsn_udf6_masked(oxm):
-    type_len = 204040
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf6_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 204040)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf6_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[204040] = bsn_udf6_masked
-
-class bsn_udf7(oxm):
-    type_len = 204292
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf7()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 204292)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf7 {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[204292] = bsn_udf7
-
-class bsn_udf7_masked(oxm):
-    type_len = 204552
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_udf7_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 204552)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_udf7_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[204552] = bsn_udf7_masked
-
-class bsn_vfi(oxm):
-    type_len = 209410
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_vfi()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 209410)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vfi {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[209410] = bsn_vfi
-
-class bsn_vfi_masked(oxm):
-    type_len = 209668
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        packed.append(struct.pack("!H", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_vfi_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 209668)
-        obj.value = reader.read("!H")[0]
-        obj.value_mask = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vfi_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[209668] = bsn_vfi_masked
-
-class bsn_vlan_xlate_port_group_id(oxm):
-    type_len = 205316
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_vlan_xlate_port_group_id()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 205316)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vlan_xlate_port_group_id {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[205316] = bsn_vlan_xlate_port_group_id
-
-class bsn_vlan_xlate_port_group_id_masked(oxm):
-    type_len = 205576
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_vlan_xlate_port_group_id_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 205576)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vlan_xlate_port_group_id_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[205576] = bsn_vlan_xlate_port_group_id_masked
-
-class bsn_vrf(oxm):
-    type_len = 197636
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_vrf()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 197636)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vrf {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[197636] = bsn_vrf
-
-class bsn_vrf_masked(oxm):
-    type_len = 197896
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_vrf_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 197896)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vrf_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[197896] = bsn_vrf_masked
-
-class bsn_vxlan_network_id(oxm):
-    type_len = 207364
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_vxlan_network_id()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 207364)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vxlan_network_id {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[207364] = bsn_vxlan_network_id
-
-class bsn_vxlan_network_id_masked(oxm):
-    type_len = 207624
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_vxlan_network_id_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 207624)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_vxlan_network_id_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[207624] = bsn_vxlan_network_id_masked
-
-class eth_dst(oxm):
-    type_len = 2147485190
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!6B", *self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = eth_dst()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147485190)
-        obj.value = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("eth_dst {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147485190] = eth_dst
-
-class eth_dst_masked(oxm):
-    type_len = 2147485452
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!6B", *self.value))
-        packed.append(struct.pack("!6B", *self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = eth_dst_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147485452)
-        obj.value = list(reader.read('!6B'))
-        obj.value_mask = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("eth_dst_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text(util.pretty_mac(self.value_mask))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147485452] = eth_dst_masked
-
-class eth_src(oxm):
-    type_len = 2147485702
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!6B", *self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = eth_src()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147485702)
-        obj.value = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("eth_src {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147485702] = eth_src
-
-class eth_src_masked(oxm):
-    type_len = 2147485964
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!6B", *self.value))
-        packed.append(struct.pack("!6B", *self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = eth_src_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147485964)
-        obj.value = list(reader.read('!6B'))
-        obj.value_mask = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("eth_src_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text(util.pretty_mac(self.value_mask))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147485964] = eth_src_masked
-
-class eth_type(oxm):
-    type_len = 2147486210
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = eth_type()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147486210)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("eth_type {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147486210] = eth_type
-
-class eth_type_masked(oxm):
-    type_len = 2147486468
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        packed.append(struct.pack("!H", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = eth_type_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147486468)
-        obj.value = reader.read("!H")[0]
-        obj.value_mask = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("eth_type_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147486468] = eth_type_masked
-
-class icmpv4_code(oxm):
-    type_len = 2147493889
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = icmpv4_code()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147493889)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("icmpv4_code {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147493889] = icmpv4_code
-
-class icmpv4_code_masked(oxm):
-    type_len = 2147494146
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        packed.append(struct.pack("!B", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = icmpv4_code_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147494146)
-        obj.value = reader.read("!B")[0]
-        obj.value_mask = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("icmpv4_code_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147494146] = icmpv4_code_masked
-
-class icmpv4_type(oxm):
-    type_len = 2147493377
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = icmpv4_type()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147493377)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("icmpv4_type {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147493377] = icmpv4_type
-
-class icmpv4_type_masked(oxm):
-    type_len = 2147493634
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        packed.append(struct.pack("!B", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = icmpv4_type_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147493634)
-        obj.value = reader.read("!B")[0]
-        obj.value_mask = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("icmpv4_type_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147493634] = icmpv4_type_masked
-
-class icmpv6_code(oxm):
-    type_len = 2147499009
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = icmpv6_code()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147499009)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("icmpv6_code {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147499009] = icmpv6_code
-
-class icmpv6_code_masked(oxm):
-    type_len = 2147499266
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        packed.append(struct.pack("!B", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = icmpv6_code_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147499266)
-        obj.value = reader.read("!B")[0]
-        obj.value_mask = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("icmpv6_code_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147499266] = icmpv6_code_masked
-
-class icmpv6_type(oxm):
-    type_len = 2147498497
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = icmpv6_type()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147498497)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("icmpv6_type {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147498497] = icmpv6_type
-
-class icmpv6_type_masked(oxm):
-    type_len = 2147498754
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        packed.append(struct.pack("!B", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = icmpv6_type_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147498754)
-        obj.value = reader.read("!B")[0]
-        obj.value_mask = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("icmpv6_type_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147498754] = icmpv6_type_masked
-
-class in_phy_port(oxm):
-    type_len = 2147484164
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(util.pack_port_no(self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = in_phy_port()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147484164)
-        obj.value = util.unpack_port_no(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("in_phy_port {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_port(self.value))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147484164] = in_phy_port
-
-class in_phy_port_masked(oxm):
-    type_len = 2147484424
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(util.pack_port_no(self.value))
-        packed.append(util.pack_port_no(self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = in_phy_port_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147484424)
-        obj.value = util.unpack_port_no(reader)
-        obj.value_mask = util.unpack_port_no(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("in_phy_port_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_port(self.value))
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text(util.pretty_port(self.value_mask))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147484424] = in_phy_port_masked
-
-class in_port(oxm):
-    type_len = 2147483652
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(util.pack_port_no(self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = in_port()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147483652)
-        obj.value = util.unpack_port_no(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("in_port {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_port(self.value))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147483652] = in_port
-
-class in_port_masked(oxm):
-    type_len = 2147483912
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(util.pack_port_no(self.value))
-        packed.append(util.pack_port_no(self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = in_port_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147483912)
-        obj.value = util.unpack_port_no(reader)
-        obj.value_mask = util.unpack_port_no(reader)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("in_port_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_port(self.value))
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text(util.pretty_port(self.value_mask))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147483912] = in_port_masked
-
-class ip_dscp(oxm):
-    type_len = 2147487745
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ip_dscp()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147487745)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ip_dscp {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147487745] = ip_dscp
-
-class ip_dscp_masked(oxm):
-    type_len = 2147488002
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        packed.append(struct.pack("!B", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ip_dscp_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147488002)
-        obj.value = reader.read("!B")[0]
-        obj.value_mask = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ip_dscp_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147488002] = ip_dscp_masked
-
-class ip_ecn(oxm):
-    type_len = 2147488257
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ip_ecn()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147488257)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ip_ecn {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147488257] = ip_ecn
-
-class ip_ecn_masked(oxm):
-    type_len = 2147488514
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        packed.append(struct.pack("!B", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ip_ecn_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147488514)
-        obj.value = reader.read("!B")[0]
-        obj.value_mask = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ip_ecn_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147488514] = ip_ecn_masked
-
-class ip_proto(oxm):
-    type_len = 2147488769
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ip_proto()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147488769)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ip_proto {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147488769] = ip_proto
-
-class ip_proto_masked(oxm):
-    type_len = 2147489026
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        packed.append(struct.pack("!B", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ip_proto_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147489026)
-        obj.value = reader.read("!B")[0]
-        obj.value_mask = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ip_proto_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147489026] = ip_proto_masked
-
-class ipv4_dst(oxm):
-    type_len = 2147489796
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv4_dst()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147489796)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv4_dst {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_ipv4(self.value))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147489796] = ipv4_dst
-
-class ipv4_dst_masked(oxm):
-    type_len = 2147490056
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv4_dst_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147490056)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv4_dst_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_ipv4(self.value))
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text(util.pretty_ipv4(self.value_mask))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147490056] = ipv4_dst_masked
-
-class ipv4_src(oxm):
-    type_len = 2147489284
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv4_src()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147489284)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv4_src {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_ipv4(self.value))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147489284] = ipv4_src
-
-class ipv4_src_masked(oxm):
-    type_len = 2147489544
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv4_src_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147489544)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv4_src_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_ipv4(self.value))
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text(util.pretty_ipv4(self.value_mask))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147489544] = ipv4_src_masked
-
-class ipv6_dst(oxm):
-    type_len = 2147497488
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!16s", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv6_dst()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147497488)
-        obj.value = reader.read('!16s')[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv6_dst {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.pp(self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147497488] = ipv6_dst
-
-class ipv6_dst_masked(oxm):
-    type_len = 2147497760
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!16s", self.value))
-        packed.append(struct.pack("!16s", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv6_dst_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147497760)
-        obj.value = reader.read('!16s')[0]
-        obj.value_mask = reader.read('!16s')[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv6_dst_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.pp(self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.pp(self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147497760] = ipv6_dst_masked
-
-class ipv6_exthdr(oxm):
-    type_len = 2147503618
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv6_exthdr()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147503618)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv6_exthdr {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147503618] = ipv6_exthdr
-
-class ipv6_exthdr_masked(oxm):
-    type_len = 2147503876
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        packed.append(struct.pack("!H", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv6_exthdr_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147503876)
-        obj.value = reader.read("!H")[0]
-        obj.value_mask = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv6_exthdr_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147503876] = ipv6_exthdr_masked
-
-class ipv6_flabel(oxm):
-    type_len = 2147497988
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv6_flabel()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147497988)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv6_flabel {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147497988] = ipv6_flabel
-
-class ipv6_flabel_masked(oxm):
-    type_len = 2147498248
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv6_flabel_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147498248)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv6_flabel_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147498248] = ipv6_flabel_masked
-
-class ipv6_nd_sll(oxm):
-    type_len = 2147500038
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!6B", *self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv6_nd_sll()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147500038)
-        obj.value = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv6_nd_sll {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147500038] = ipv6_nd_sll
-
-class ipv6_nd_sll_masked(oxm):
-    type_len = 2147500300
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!6B", *self.value))
-        packed.append(struct.pack("!6B", *self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv6_nd_sll_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147500300)
-        obj.value = list(reader.read('!6B'))
-        obj.value_mask = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv6_nd_sll_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text(util.pretty_mac(self.value_mask))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147500300] = ipv6_nd_sll_masked
-
-class ipv6_nd_target(oxm):
-    type_len = 2147499536
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!16s", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv6_nd_target()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147499536)
-        obj.value = reader.read('!16s')[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv6_nd_target {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.pp(self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147499536] = ipv6_nd_target
-
-class ipv6_nd_target_masked(oxm):
-    type_len = 2147499808
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!16s", self.value))
-        packed.append(struct.pack("!16s", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv6_nd_target_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147499808)
-        obj.value = reader.read('!16s')[0]
-        obj.value_mask = reader.read('!16s')[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv6_nd_target_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.pp(self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.pp(self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147499808] = ipv6_nd_target_masked
-
-class ipv6_nd_tll(oxm):
-    type_len = 2147500550
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!6B", *self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv6_nd_tll()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147500550)
-        obj.value = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv6_nd_tll {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147500550] = ipv6_nd_tll
-
-class ipv6_nd_tll_masked(oxm):
-    type_len = 2147500812
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = [0,0,0,0,0,0]
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = [0,0,0,0,0,0]
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!6B", *self.value))
-        packed.append(struct.pack("!6B", *self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv6_nd_tll_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147500812)
-        obj.value = list(reader.read('!6B'))
-        obj.value_mask = list(reader.read('!6B'))
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv6_nd_tll_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_mac(self.value))
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text(util.pretty_mac(self.value_mask))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147500812] = ipv6_nd_tll_masked
-
-class ipv6_src(oxm):
-    type_len = 2147496976
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!16s", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv6_src()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147496976)
-        obj.value = reader.read('!16s')[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv6_src {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.pp(self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147496976] = ipv6_src
-
-class ipv6_src_masked(oxm):
-    type_len = 2147497248
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!16s", self.value))
-        packed.append(struct.pack("!16s", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ipv6_src_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147497248)
-        obj.value = reader.read('!16s')[0]
-        obj.value_mask = reader.read('!16s')[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ipv6_src_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.pp(self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.pp(self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147497248] = ipv6_src_masked
-
-class metadata(oxm):
-    type_len = 2147484680
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!Q", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = metadata()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147484680)
-        obj.value = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("metadata {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147484680] = metadata
-
-class metadata_masked(oxm):
-    type_len = 2147484944
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!Q", self.value))
-        packed.append(struct.pack("!Q", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = metadata_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147484944)
-        obj.value = reader.read("!Q")[0]
-        obj.value_mask = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("metadata_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147484944] = metadata_masked
-
-class mpls_bos(oxm):
-    type_len = 2147502081
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = mpls_bos()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147502081)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("mpls_bos {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147502081] = mpls_bos
-
-class mpls_bos_masked(oxm):
-    type_len = 2147502338
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        packed.append(struct.pack("!B", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = mpls_bos_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147502338)
-        obj.value = reader.read("!B")[0]
-        obj.value_mask = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("mpls_bos_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147502338] = mpls_bos_masked
-
-class mpls_label(oxm):
-    type_len = 2147501060
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = mpls_label()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147501060)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("mpls_label {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147501060] = mpls_label
-
-class mpls_label_masked(oxm):
-    type_len = 2147501320
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = mpls_label_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147501320)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("mpls_label_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147501320] = mpls_label_masked
-
-class mpls_tc(oxm):
-    type_len = 2147501569
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = mpls_tc()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147501569)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("mpls_tc {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147501569] = mpls_tc
-
-class mpls_tc_masked(oxm):
-    type_len = 2147501826
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        packed.append(struct.pack("!B", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = mpls_tc_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147501826)
-        obj.value = reader.read("!B")[0]
-        obj.value_mask = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("mpls_tc_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147501826] = mpls_tc_masked
-
-class pbb_uca(oxm):
-    type_len = 2147504641
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = pbb_uca()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147504641)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("pbb_uca {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147504641] = pbb_uca
-
-class pbb_uca_masked(oxm):
-    type_len = 2147504898
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        packed.append(struct.pack("!B", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = pbb_uca_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147504898)
-        obj.value = reader.read("!B")[0]
-        obj.value_mask = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("pbb_uca_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147504898] = pbb_uca_masked
-
-class sctp_dst(oxm):
-    type_len = 2147492866
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = sctp_dst()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147492866)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("sctp_dst {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147492866] = sctp_dst
-
-class sctp_dst_masked(oxm):
-    type_len = 2147493124
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        packed.append(struct.pack("!H", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = sctp_dst_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147493124)
-        obj.value = reader.read("!H")[0]
-        obj.value_mask = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("sctp_dst_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147493124] = sctp_dst_masked
-
-class sctp_src(oxm):
-    type_len = 2147492354
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = sctp_src()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147492354)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("sctp_src {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147492354] = sctp_src
-
-class sctp_src_masked(oxm):
-    type_len = 2147492612
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        packed.append(struct.pack("!H", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = sctp_src_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147492612)
-        obj.value = reader.read("!H")[0]
-        obj.value_mask = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("sctp_src_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147492612] = sctp_src_masked
-
-class tcp_dst(oxm):
-    type_len = 2147490818
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = tcp_dst()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147490818)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("tcp_dst {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147490818] = tcp_dst
-
-class tcp_dst_masked(oxm):
-    type_len = 2147491076
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        packed.append(struct.pack("!H", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = tcp_dst_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147491076)
-        obj.value = reader.read("!H")[0]
-        obj.value_mask = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("tcp_dst_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147491076] = tcp_dst_masked
-
-class tcp_src(oxm):
-    type_len = 2147490306
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = tcp_src()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147490306)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("tcp_src {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147490306] = tcp_src
-
-class tcp_src_masked(oxm):
-    type_len = 2147490564
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        packed.append(struct.pack("!H", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = tcp_src_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147490564)
-        obj.value = reader.read("!H")[0]
-        obj.value_mask = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("tcp_src_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147490564] = tcp_src_masked
-
-class tunnel_id(oxm):
-    type_len = 2147503112
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!Q", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = tunnel_id()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147503112)
-        obj.value = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("tunnel_id {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147503112] = tunnel_id
-
-class tunnel_id_masked(oxm):
-    type_len = 2147503376
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!Q", self.value))
-        packed.append(struct.pack("!Q", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = tunnel_id_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147503376)
-        obj.value = reader.read("!Q")[0]
-        obj.value_mask = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("tunnel_id_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147503376] = tunnel_id_masked
-
-class tunnel_ipv4_dst(oxm):
-    type_len = 81924
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = tunnel_ipv4_dst()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 81924)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("tunnel_ipv4_dst {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_ipv4(self.value))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[81924] = tunnel_ipv4_dst
-
-class tunnel_ipv4_dst_masked(oxm):
-    type_len = 82184
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = tunnel_ipv4_dst_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 82184)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("tunnel_ipv4_dst_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_ipv4(self.value))
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text(util.pretty_ipv4(self.value_mask))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[82184] = tunnel_ipv4_dst_masked
-
-class tunnel_ipv4_src(oxm):
-    type_len = 81412
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = tunnel_ipv4_src()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 81412)
-        obj.value = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("tunnel_ipv4_src {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_ipv4(self.value))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[81412] = tunnel_ipv4_src
-
-class tunnel_ipv4_src_masked(oxm):
-    type_len = 81672
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!L", self.value))
-        packed.append(struct.pack("!L", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = tunnel_ipv4_src_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 81672)
-        obj.value = reader.read("!L")[0]
-        obj.value_mask = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("tunnel_ipv4_src_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text(util.pretty_ipv4(self.value))
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text(util.pretty_ipv4(self.value_mask))
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[81672] = tunnel_ipv4_src_masked
-
-class udp_dst(oxm):
-    type_len = 2147491842
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = udp_dst()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147491842)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("udp_dst {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147491842] = udp_dst
-
-class udp_dst_masked(oxm):
-    type_len = 2147492100
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        packed.append(struct.pack("!H", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = udp_dst_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147492100)
-        obj.value = reader.read("!H")[0]
-        obj.value_mask = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("udp_dst_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147492100] = udp_dst_masked
-
-class udp_src(oxm):
-    type_len = 2147491330
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = udp_src()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147491330)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("udp_src {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147491330] = udp_src
-
-class udp_src_masked(oxm):
-    type_len = 2147491588
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        packed.append(struct.pack("!H", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = udp_src_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147491588)
-        obj.value = reader.read("!H")[0]
-        obj.value_mask = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("udp_src_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147491588] = udp_src_masked
-
-class vlan_pcp(oxm):
-    type_len = 2147487233
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = vlan_pcp()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147487233)
-        obj.value = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("vlan_pcp {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147487233] = vlan_pcp
-
-class vlan_pcp_masked(oxm):
-    type_len = 2147487490
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!B", self.value))
-        packed.append(struct.pack("!B", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = vlan_pcp_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147487490)
-        obj.value = reader.read("!B")[0]
-        obj.value_mask = reader.read("!B")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("vlan_pcp_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147487490] = vlan_pcp_masked
-
-class vlan_vid(oxm):
-    type_len = 2147486722
-
-    def __init__(self, value=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = vlan_vid()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147486722)
-        obj.value = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("vlan_vid {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147486722] = vlan_vid
-
-class vlan_vid_masked(oxm):
-    type_len = 2147486980
-
-    def __init__(self, value=None, value_mask=None):
-        if value != None:
-            self.value = value
-        else:
-            self.value = 0
-        if value_mask != None:
-            self.value_mask = value_mask
-        else:
-            self.value_mask = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!L", self.type_len))
-        packed.append(struct.pack("!H", self.value))
-        packed.append(struct.pack("!H", self.value_mask))
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = vlan_vid_masked()
-        _type_len = reader.read("!L")[0]
-        assert(_type_len == 2147486980)
-        obj.value = reader.read("!H")[0]
-        obj.value_mask = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.value != other.value: return False
-        if self.value_mask != other.value_mask: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("vlan_vid_masked {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("value = ");
-                q.text("%#x" % self.value)
-                q.text(","); q.breakable()
-                q.text("value_mask = ");
-                q.text("%#x" % self.value_mask)
-            q.breakable()
-        q.text('}')
-
-oxm.subtypes[2147486980] = vlan_vid_masked
-
-
diff --git a/python/ofagent/loxi/of14/port_desc_prop.py b/python/ofagent/loxi/of14/port_desc_prop.py
deleted file mode 100644
index 333f2cd..0000000
--- a/python/ofagent/loxi/of14/port_desc_prop.py
+++ /dev/null
@@ -1,514 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template module.py
-# Do not modify
-
-import struct
-import loxi
-import util
-import loxi.generic_util
-
-import sys
-ofp = sys.modules['loxi.of14']
-
-class port_desc_prop(loxi.OFObject):
-    subtypes = {}
-
-
-    def __init__(self, type=None):
-        if type != None:
-            self.type = type
-        else:
-            self.type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 0)
-        subclass = port_desc_prop.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = port_desc_prop()
-        obj.type = reader.read("!H")[0]
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type != other.type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port_desc_prop {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-
-class experimenter(port_desc_prop):
-    subtypes = {}
-
-    type = 65535
-
-    def __init__(self, experimenter=None):
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 4)
-        subclass = experimenter.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = experimenter()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.experimenter = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.experimenter != other.experimenter: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("experimenter {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-port_desc_prop.subtypes[65535] = experimenter
-
-class bsn(experimenter):
-    subtypes = {}
-
-    type = 65535
-    experimenter = 6035143
-
-    def __init__(self, exp_type=None):
-        if exp_type != None:
-            self.exp_type = exp_type
-        else:
-            self.exp_type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.exp_type))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 8)
-        subclass = bsn.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = bsn()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        obj.exp_type = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.exp_type != other.exp_type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-experimenter.subtypes[6035143] = bsn
-
-class bsn_generation_id(bsn):
-    type = 65535
-    experimenter = 6035143
-    exp_type = 1
-
-    def __init__(self, generation_id=None):
-        if generation_id != None:
-            self.generation_id = generation_id
-        else:
-            self.generation_id = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.exp_type))
-        packed.append(struct.pack("!Q", self.generation_id))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_generation_id()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _exp_type = reader.read("!L")[0]
-        assert(_exp_type == 1)
-        obj.generation_id = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.generation_id != other.generation_id: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_generation_id {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("generation_id = ");
-                q.text("%#x" % self.generation_id)
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[1] = bsn_generation_id
-
-class bsn_uplink(bsn):
-    type = 65535
-    experimenter = 6035143
-    exp_type = 0
-
-    def __init__(self):
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.exp_type))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = bsn_uplink()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        _experimenter = reader.read("!L")[0]
-        assert(_experimenter == 6035143)
-        _exp_type = reader.read("!L")[0]
-        assert(_exp_type == 0)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("bsn_uplink {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-bsn.subtypes[0] = bsn_uplink
-
-class ethernet(port_desc_prop):
-    type = 0
-
-    def __init__(self, curr=None, advertised=None, supported=None, peer=None, curr_speed=None, max_speed=None):
-        if curr != None:
-            self.curr = curr
-        else:
-            self.curr = 0
-        if advertised != None:
-            self.advertised = advertised
-        else:
-            self.advertised = 0
-        if supported != None:
-            self.supported = supported
-        else:
-            self.supported = 0
-        if peer != None:
-            self.peer = peer
-        else:
-            self.peer = 0
-        if curr_speed != None:
-            self.curr_speed = curr_speed
-        else:
-            self.curr_speed = 0
-        if max_speed != None:
-            self.max_speed = max_speed
-        else:
-            self.max_speed = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.curr))
-        packed.append(struct.pack("!L", self.advertised))
-        packed.append(struct.pack("!L", self.supported))
-        packed.append(struct.pack("!L", self.peer))
-        packed.append(struct.pack("!L", self.curr_speed))
-        packed.append(struct.pack("!L", self.max_speed))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ethernet()
-        _type = reader.read("!H")[0]
-        assert(_type == 0)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        reader.skip(4)
-        obj.curr = reader.read("!L")[0]
-        obj.advertised = reader.read("!L")[0]
-        obj.supported = reader.read("!L")[0]
-        obj.peer = reader.read("!L")[0]
-        obj.curr_speed = reader.read("!L")[0]
-        obj.max_speed = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.curr != other.curr: return False
-        if self.advertised != other.advertised: return False
-        if self.supported != other.supported: return False
-        if self.peer != other.peer: return False
-        if self.curr_speed != other.curr_speed: return False
-        if self.max_speed != other.max_speed: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ethernet {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("curr = ");
-                q.text("%#x" % self.curr)
-                q.text(","); q.breakable()
-                q.text("advertised = ");
-                q.text("%#x" % self.advertised)
-                q.text(","); q.breakable()
-                q.text("supported = ");
-                q.text("%#x" % self.supported)
-                q.text(","); q.breakable()
-                q.text("peer = ");
-                q.text("%#x" % self.peer)
-                q.text(","); q.breakable()
-                q.text("curr_speed = ");
-                q.text("%#x" % self.curr_speed)
-                q.text(","); q.breakable()
-                q.text("max_speed = ");
-                q.text("%#x" % self.max_speed)
-            q.breakable()
-        q.text('}')
-
-port_desc_prop.subtypes[0] = ethernet
-
-class optical(port_desc_prop):
-    type = 1
-
-    def __init__(self, supported=None, tx_min_freq_lmda=None, tx_max_freq_lmda=None, tx_grid_freq_lmda=None, rx_min_freq_lmda=None, rx_max_freq_lmda=None, rx_grid_freq_lmda=None, tx_pwr_min=None, tx_pwr_max=None):
-        if supported != None:
-            self.supported = supported
-        else:
-            self.supported = 0
-        if tx_min_freq_lmda != None:
-            self.tx_min_freq_lmda = tx_min_freq_lmda
-        else:
-            self.tx_min_freq_lmda = 0
-        if tx_max_freq_lmda != None:
-            self.tx_max_freq_lmda = tx_max_freq_lmda
-        else:
-            self.tx_max_freq_lmda = 0
-        if tx_grid_freq_lmda != None:
-            self.tx_grid_freq_lmda = tx_grid_freq_lmda
-        else:
-            self.tx_grid_freq_lmda = 0
-        if rx_min_freq_lmda != None:
-            self.rx_min_freq_lmda = rx_min_freq_lmda
-        else:
-            self.rx_min_freq_lmda = 0
-        if rx_max_freq_lmda != None:
-            self.rx_max_freq_lmda = rx_max_freq_lmda
-        else:
-            self.rx_max_freq_lmda = 0
-        if rx_grid_freq_lmda != None:
-            self.rx_grid_freq_lmda = rx_grid_freq_lmda
-        else:
-            self.rx_grid_freq_lmda = 0
-        if tx_pwr_min != None:
-            self.tx_pwr_min = tx_pwr_min
-        else:
-            self.tx_pwr_min = 0
-        if tx_pwr_max != None:
-            self.tx_pwr_max = tx_pwr_max
-        else:
-            self.tx_pwr_max = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.supported))
-        packed.append(struct.pack("!L", self.tx_min_freq_lmda))
-        packed.append(struct.pack("!L", self.tx_max_freq_lmda))
-        packed.append(struct.pack("!L", self.tx_grid_freq_lmda))
-        packed.append(struct.pack("!L", self.rx_min_freq_lmda))
-        packed.append(struct.pack("!L", self.rx_max_freq_lmda))
-        packed.append(struct.pack("!L", self.rx_grid_freq_lmda))
-        packed.append(struct.pack("!L", self.tx_pwr_min))
-        packed.append(struct.pack("!L", self.tx_pwr_max))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = optical()
-        _type = reader.read("!H")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        reader.skip(4)
-        obj.supported = reader.read("!L")[0]
-        obj.tx_min_freq_lmda = reader.read("!L")[0]
-        obj.tx_max_freq_lmda = reader.read("!L")[0]
-        obj.tx_grid_freq_lmda = reader.read("!L")[0]
-        obj.rx_min_freq_lmda = reader.read("!L")[0]
-        obj.rx_max_freq_lmda = reader.read("!L")[0]
-        obj.rx_grid_freq_lmda = reader.read("!L")[0]
-        obj.tx_pwr_min = reader.read("!L")[0]
-        obj.tx_pwr_max = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.supported != other.supported: return False
-        if self.tx_min_freq_lmda != other.tx_min_freq_lmda: return False
-        if self.tx_max_freq_lmda != other.tx_max_freq_lmda: return False
-        if self.tx_grid_freq_lmda != other.tx_grid_freq_lmda: return False
-        if self.rx_min_freq_lmda != other.rx_min_freq_lmda: return False
-        if self.rx_max_freq_lmda != other.rx_max_freq_lmda: return False
-        if self.rx_grid_freq_lmda != other.rx_grid_freq_lmda: return False
-        if self.tx_pwr_min != other.tx_pwr_min: return False
-        if self.tx_pwr_max != other.tx_pwr_max: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("optical {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("supported = ");
-                q.text("%#x" % self.supported)
-                q.text(","); q.breakable()
-                q.text("tx_min_freq_lmda = ");
-                q.text("%#x" % self.tx_min_freq_lmda)
-                q.text(","); q.breakable()
-                q.text("tx_max_freq_lmda = ");
-                q.text("%#x" % self.tx_max_freq_lmda)
-                q.text(","); q.breakable()
-                q.text("tx_grid_freq_lmda = ");
-                q.text("%#x" % self.tx_grid_freq_lmda)
-                q.text(","); q.breakable()
-                q.text("rx_min_freq_lmda = ");
-                q.text("%#x" % self.rx_min_freq_lmda)
-                q.text(","); q.breakable()
-                q.text("rx_max_freq_lmda = ");
-                q.text("%#x" % self.rx_max_freq_lmda)
-                q.text(","); q.breakable()
-                q.text("rx_grid_freq_lmda = ");
-                q.text("%#x" % self.rx_grid_freq_lmda)
-                q.text(","); q.breakable()
-                q.text("tx_pwr_min = ");
-                q.text("%#x" % self.tx_pwr_min)
-                q.text(","); q.breakable()
-                q.text("tx_pwr_max = ");
-                q.text("%#x" % self.tx_pwr_max)
-            q.breakable()
-        q.text('}')
-
-port_desc_prop.subtypes[1] = optical
-
-
diff --git a/python/ofagent/loxi/of14/port_mod_prop.py b/python/ofagent/loxi/of14/port_mod_prop.py
deleted file mode 100644
index 0c6f647..0000000
--- a/python/ofagent/loxi/of14/port_mod_prop.py
+++ /dev/null
@@ -1,272 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template module.py
-# Do not modify
-
-import struct
-import loxi
-import util
-import loxi.generic_util
-
-import sys
-ofp = sys.modules['loxi.of14']
-
-class port_mod_prop(loxi.OFObject):
-    subtypes = {}
-
-
-    def __init__(self, type=None):
-        if type != None:
-            self.type = type
-        else:
-            self.type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 0)
-        subclass = port_mod_prop.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = port_mod_prop()
-        obj.type = reader.read("!H")[0]
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type != other.type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port_mod_prop {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-
-class ethernet(port_mod_prop):
-    type = 0
-
-    def __init__(self, advertise=None):
-        if advertise != None:
-            self.advertise = advertise
-        else:
-            self.advertise = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.advertise))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ethernet()
-        _type = reader.read("!H")[0]
-        assert(_type == 0)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.advertise = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.advertise != other.advertise: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ethernet {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("advertise = ");
-                q.text("%#x" % self.advertise)
-            q.breakable()
-        q.text('}')
-
-port_mod_prop.subtypes[0] = ethernet
-
-class experimenter(port_mod_prop):
-    subtypes = {}
-
-    type = 65535
-
-    def __init__(self, experimenter=None, exp_type=None):
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        if exp_type != None:
-            self.exp_type = exp_type
-        else:
-            self.exp_type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.exp_type))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 4)
-        subclass = experimenter.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = experimenter()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.experimenter = reader.read("!L")[0]
-        obj.exp_type = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.experimenter != other.experimenter: return False
-        if self.exp_type != other.exp_type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("experimenter {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("exp_type = ");
-                q.text("%#x" % self.exp_type)
-            q.breakable()
-        q.text('}')
-
-port_mod_prop.subtypes[65535] = experimenter
-
-class optical(port_mod_prop):
-    type = 1
-
-    def __init__(self, configure=None, freq_ldma=None, fl_offset=None, grid_span=None, tx_pwr=None):
-        if configure != None:
-            self.configure = configure
-        else:
-            self.configure = 0
-        if freq_ldma != None:
-            self.freq_ldma = freq_ldma
-        else:
-            self.freq_ldma = 0
-        if fl_offset != None:
-            self.fl_offset = fl_offset
-        else:
-            self.fl_offset = 0
-        if grid_span != None:
-            self.grid_span = grid_span
-        else:
-            self.grid_span = 0
-        if tx_pwr != None:
-            self.tx_pwr = tx_pwr
-        else:
-            self.tx_pwr = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.configure))
-        packed.append(struct.pack("!L", self.freq_ldma))
-        packed.append(struct.pack("!L", self.fl_offset))
-        packed.append(struct.pack("!L", self.grid_span))
-        packed.append(struct.pack("!L", self.tx_pwr))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = optical()
-        _type = reader.read("!H")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.configure = reader.read("!L")[0]
-        obj.freq_ldma = reader.read("!L")[0]
-        obj.fl_offset = reader.read("!L")[0]
-        obj.grid_span = reader.read("!L")[0]
-        obj.tx_pwr = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.configure != other.configure: return False
-        if self.freq_ldma != other.freq_ldma: return False
-        if self.fl_offset != other.fl_offset: return False
-        if self.grid_span != other.grid_span: return False
-        if self.tx_pwr != other.tx_pwr: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("optical {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("configure = ");
-                q.text("%#x" % self.configure)
-                q.text(","); q.breakable()
-                q.text("freq_ldma = ");
-                q.text("%#x" % self.freq_ldma)
-                q.text(","); q.breakable()
-                q.text("fl_offset = ");
-                q.text("%#x" % self.fl_offset)
-                q.text(","); q.breakable()
-                q.text("grid_span = ");
-                q.text("%#x" % self.grid_span)
-                q.text(","); q.breakable()
-                q.text("tx_pwr = ");
-                q.text("%#x" % self.tx_pwr)
-            q.breakable()
-        q.text('}')
-
-port_mod_prop.subtypes[1] = optical
-
-
diff --git a/python/ofagent/loxi/of14/port_stats_prop.py b/python/ofagent/loxi/of14/port_stats_prop.py
deleted file mode 100644
index 10460e2..0000000
--- a/python/ofagent/loxi/of14/port_stats_prop.py
+++ /dev/null
@@ -1,376 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template module.py
-# Do not modify
-
-import struct
-import loxi
-import util
-import loxi.generic_util
-
-import sys
-ofp = sys.modules['loxi.of14']
-
-class port_stats_prop(loxi.OFObject):
-    subtypes = {}
-
-
-    def __init__(self, type=None):
-        if type != None:
-            self.type = type
-        else:
-            self.type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 0)
-        subclass = port_stats_prop.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = port_stats_prop()
-        obj.type = reader.read("!H")[0]
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type != other.type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("port_stats_prop {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-
-class ethernet(port_stats_prop):
-    type = 0
-
-    def __init__(self, rx_frame_err=None, rx_over_err=None, rx_crc_err=None, collisions=None):
-        if rx_frame_err != None:
-            self.rx_frame_err = rx_frame_err
-        else:
-            self.rx_frame_err = 0
-        if rx_over_err != None:
-            self.rx_over_err = rx_over_err
-        else:
-            self.rx_over_err = 0
-        if rx_crc_err != None:
-            self.rx_crc_err = rx_crc_err
-        else:
-            self.rx_crc_err = 0
-        if collisions != None:
-            self.collisions = collisions
-        else:
-            self.collisions = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!Q", self.rx_frame_err))
-        packed.append(struct.pack("!Q", self.rx_over_err))
-        packed.append(struct.pack("!Q", self.rx_crc_err))
-        packed.append(struct.pack("!Q", self.collisions))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = ethernet()
-        _type = reader.read("!H")[0]
-        assert(_type == 0)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        reader.skip(4)
-        obj.rx_frame_err = reader.read("!Q")[0]
-        obj.rx_over_err = reader.read("!Q")[0]
-        obj.rx_crc_err = reader.read("!Q")[0]
-        obj.collisions = reader.read("!Q")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.rx_frame_err != other.rx_frame_err: return False
-        if self.rx_over_err != other.rx_over_err: return False
-        if self.rx_crc_err != other.rx_crc_err: return False
-        if self.collisions != other.collisions: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("ethernet {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("rx_frame_err = ");
-                q.text("%#x" % self.rx_frame_err)
-                q.text(","); q.breakable()
-                q.text("rx_over_err = ");
-                q.text("%#x" % self.rx_over_err)
-                q.text(","); q.breakable()
-                q.text("rx_crc_err = ");
-                q.text("%#x" % self.rx_crc_err)
-                q.text(","); q.breakable()
-                q.text("collisions = ");
-                q.text("%#x" % self.collisions)
-            q.breakable()
-        q.text('}')
-
-port_stats_prop.subtypes[0] = ethernet
-
-class experimenter(port_stats_prop):
-    subtypes = {}
-
-    type = 65535
-
-    def __init__(self, experimenter=None, exp_type=None, experimenter_data=None):
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        if exp_type != None:
-            self.exp_type = exp_type
-        else:
-            self.exp_type = 0
-        if experimenter_data != None:
-            self.experimenter_data = experimenter_data
-        else:
-            self.experimenter_data = ''
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.exp_type))
-        packed.append(self.experimenter_data)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 4)
-        subclass = experimenter.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = experimenter()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.experimenter = reader.read("!L")[0]
-        obj.exp_type = reader.read("!L")[0]
-        obj.experimenter_data = str(reader.read_all())
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.experimenter != other.experimenter: return False
-        if self.exp_type != other.exp_type: return False
-        if self.experimenter_data != other.experimenter_data: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("experimenter {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("exp_type = ");
-                q.text("%#x" % self.exp_type)
-                q.text(","); q.breakable()
-                q.text("experimenter_data = ");
-                q.pp(self.experimenter_data)
-            q.breakable()
-        q.text('}')
-
-port_stats_prop.subtypes[65535] = experimenter
-
-class optical(port_stats_prop):
-    type = 1
-
-    def __init__(self, flags=None, tx_freq_lmda=None, tx_offset=None, tx_grid_span=None, rx_freq_lmda=None, rx_offset=None, rx_grid_span=None, tx_pwr=None, rx_pwr=None, bias_current=None, temperature=None):
-        if flags != None:
-            self.flags = flags
-        else:
-            self.flags = 0
-        if tx_freq_lmda != None:
-            self.tx_freq_lmda = tx_freq_lmda
-        else:
-            self.tx_freq_lmda = 0
-        if tx_offset != None:
-            self.tx_offset = tx_offset
-        else:
-            self.tx_offset = 0
-        if tx_grid_span != None:
-            self.tx_grid_span = tx_grid_span
-        else:
-            self.tx_grid_span = 0
-        if rx_freq_lmda != None:
-            self.rx_freq_lmda = rx_freq_lmda
-        else:
-            self.rx_freq_lmda = 0
-        if rx_offset != None:
-            self.rx_offset = rx_offset
-        else:
-            self.rx_offset = 0
-        if rx_grid_span != None:
-            self.rx_grid_span = rx_grid_span
-        else:
-            self.rx_grid_span = 0
-        if tx_pwr != None:
-            self.tx_pwr = tx_pwr
-        else:
-            self.tx_pwr = 0
-        if rx_pwr != None:
-            self.rx_pwr = rx_pwr
-        else:
-            self.rx_pwr = 0
-        if bias_current != None:
-            self.bias_current = bias_current
-        else:
-            self.bias_current = 0
-        if temperature != None:
-            self.temperature = temperature
-        else:
-            self.temperature = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append('\x00' * 4)
-        packed.append(struct.pack("!L", self.flags))
-        packed.append(struct.pack("!L", self.tx_freq_lmda))
-        packed.append(struct.pack("!L", self.tx_offset))
-        packed.append(struct.pack("!L", self.tx_grid_span))
-        packed.append(struct.pack("!L", self.rx_freq_lmda))
-        packed.append(struct.pack("!L", self.rx_offset))
-        packed.append(struct.pack("!L", self.rx_grid_span))
-        packed.append(struct.pack("!H", self.tx_pwr))
-        packed.append(struct.pack("!H", self.rx_pwr))
-        packed.append(struct.pack("!H", self.bias_current))
-        packed.append(struct.pack("!H", self.temperature))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = optical()
-        _type = reader.read("!H")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        reader.skip(4)
-        obj.flags = reader.read("!L")[0]
-        obj.tx_freq_lmda = reader.read("!L")[0]
-        obj.tx_offset = reader.read("!L")[0]
-        obj.tx_grid_span = reader.read("!L")[0]
-        obj.rx_freq_lmda = reader.read("!L")[0]
-        obj.rx_offset = reader.read("!L")[0]
-        obj.rx_grid_span = reader.read("!L")[0]
-        obj.tx_pwr = reader.read("!H")[0]
-        obj.rx_pwr = reader.read("!H")[0]
-        obj.bias_current = reader.read("!H")[0]
-        obj.temperature = reader.read("!H")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.flags != other.flags: return False
-        if self.tx_freq_lmda != other.tx_freq_lmda: return False
-        if self.tx_offset != other.tx_offset: return False
-        if self.tx_grid_span != other.tx_grid_span: return False
-        if self.rx_freq_lmda != other.rx_freq_lmda: return False
-        if self.rx_offset != other.rx_offset: return False
-        if self.rx_grid_span != other.rx_grid_span: return False
-        if self.tx_pwr != other.tx_pwr: return False
-        if self.rx_pwr != other.rx_pwr: return False
-        if self.bias_current != other.bias_current: return False
-        if self.temperature != other.temperature: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("optical {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("flags = ");
-                q.text("%#x" % self.flags)
-                q.text(","); q.breakable()
-                q.text("tx_freq_lmda = ");
-                q.text("%#x" % self.tx_freq_lmda)
-                q.text(","); q.breakable()
-                q.text("tx_offset = ");
-                q.text("%#x" % self.tx_offset)
-                q.text(","); q.breakable()
-                q.text("tx_grid_span = ");
-                q.text("%#x" % self.tx_grid_span)
-                q.text(","); q.breakable()
-                q.text("rx_freq_lmda = ");
-                q.text("%#x" % self.rx_freq_lmda)
-                q.text(","); q.breakable()
-                q.text("rx_offset = ");
-                q.text("%#x" % self.rx_offset)
-                q.text(","); q.breakable()
-                q.text("rx_grid_span = ");
-                q.text("%#x" % self.rx_grid_span)
-                q.text(","); q.breakable()
-                q.text("tx_pwr = ");
-                q.text("%#x" % self.tx_pwr)
-                q.text(","); q.breakable()
-                q.text("rx_pwr = ");
-                q.text("%#x" % self.rx_pwr)
-                q.text(","); q.breakable()
-                q.text("bias_current = ");
-                q.text("%#x" % self.bias_current)
-                q.text(","); q.breakable()
-                q.text("temperature = ");
-                q.text("%#x" % self.temperature)
-            q.breakable()
-        q.text('}')
-
-port_stats_prop.subtypes[1] = optical
-
-
diff --git a/python/ofagent/loxi/of14/queue_desc_prop.py b/python/ofagent/loxi/of14/queue_desc_prop.py
deleted file mode 100644
index 0bceb50..0000000
--- a/python/ofagent/loxi/of14/queue_desc_prop.py
+++ /dev/null
@@ -1,236 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template module.py
-# Do not modify
-
-import struct
-import loxi
-import util
-import loxi.generic_util
-
-import sys
-ofp = sys.modules['loxi.of14']
-
-class queue_desc_prop(loxi.OFObject):
-    subtypes = {}
-
-
-    def __init__(self, type=None):
-        if type != None:
-            self.type = type
-        else:
-            self.type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 0)
-        subclass = queue_desc_prop.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = queue_desc_prop()
-        obj.type = reader.read("!H")[0]
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type != other.type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_desc_prop {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-
-class experimenter(queue_desc_prop):
-    subtypes = {}
-
-    type = 65535
-
-    def __init__(self, experimenter=None, exp_type=None):
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        if exp_type != None:
-            self.exp_type = exp_type
-        else:
-            self.exp_type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.exp_type))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 4)
-        subclass = experimenter.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = experimenter()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.experimenter = reader.read("!L")[0]
-        obj.exp_type = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.experimenter != other.experimenter: return False
-        if self.exp_type != other.exp_type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("experimenter {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("exp_type = ");
-                q.text("%#x" % self.exp_type)
-            q.breakable()
-        q.text('}')
-
-queue_desc_prop.subtypes[65535] = experimenter
-
-class max_rate(queue_desc_prop):
-    type = 2
-
-    def __init__(self, rate=None):
-        if rate != None:
-            self.rate = rate
-        else:
-            self.rate = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.rate))
-        packed.append('\x00' * 2)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = max_rate()
-        _type = reader.read("!H")[0]
-        assert(_type == 2)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.rate = reader.read("!H")[0]
-        reader.skip(2)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.rate != other.rate: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("max_rate {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("rate = ");
-                q.text("%#x" % self.rate)
-            q.breakable()
-        q.text('}')
-
-queue_desc_prop.subtypes[2] = max_rate
-
-class min_rate(queue_desc_prop):
-    type = 1
-
-    def __init__(self, rate=None):
-        if rate != None:
-            self.rate = rate
-        else:
-            self.rate = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!H", self.rate))
-        packed.append('\x00' * 2)
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        obj = min_rate()
-        _type = reader.read("!H")[0]
-        assert(_type == 1)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.rate = reader.read("!H")[0]
-        reader.skip(2)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.rate != other.rate: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("min_rate {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("rate = ");
-                q.text("%#x" % self.rate)
-            q.breakable()
-        q.text('}')
-
-queue_desc_prop.subtypes[1] = min_rate
-
-
diff --git a/python/ofagent/loxi/of14/queue_stats_prop.py b/python/ofagent/loxi/of14/queue_stats_prop.py
deleted file mode 100644
index 0a4bd67..0000000
--- a/python/ofagent/loxi/of14/queue_stats_prop.py
+++ /dev/null
@@ -1,138 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template module.py
-# Do not modify
-
-import struct
-import loxi
-import util
-import loxi.generic_util
-
-import sys
-ofp = sys.modules['loxi.of14']
-
-class queue_stats_prop(loxi.OFObject):
-    subtypes = {}
-
-
-    def __init__(self, type=None):
-        if type != None:
-            self.type = type
-        else:
-            self.type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 0)
-        subclass = queue_stats_prop.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = queue_stats_prop()
-        obj.type = reader.read("!H")[0]
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type != other.type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("queue_stats_prop {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-
-class experimenter(queue_stats_prop):
-    subtypes = {}
-
-    type = 65535
-
-    def __init__(self, experimenter=None, exp_type=None):
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        if exp_type != None:
-            self.exp_type = exp_type
-        else:
-            self.exp_type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.exp_type))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 4)
-        subclass = experimenter.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = experimenter()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.experimenter = reader.read("!L")[0]
-        obj.exp_type = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.experimenter != other.experimenter: return False
-        if self.exp_type != other.exp_type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("experimenter {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("exp_type = ");
-                q.text("%#x" % self.exp_type)
-            q.breakable()
-        q.text('}')
-
-queue_stats_prop.subtypes[65535] = experimenter
-
-
diff --git a/python/ofagent/loxi/of14/role_prop.py b/python/ofagent/loxi/of14/role_prop.py
deleted file mode 100644
index de27245..0000000
--- a/python/ofagent/loxi/of14/role_prop.py
+++ /dev/null
@@ -1,138 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template module.py
-# Do not modify
-
-import struct
-import loxi
-import util
-import loxi.generic_util
-
-import sys
-ofp = sys.modules['loxi.of14']
-
-class role_prop(loxi.OFObject):
-    subtypes = {}
-
-
-    def __init__(self, type=None):
-        if type != None:
-            self.type = type
-        else:
-            self.type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 0)
-        subclass = role_prop.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = role_prop()
-        obj.type = reader.read("!H")[0]
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type != other.type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("role_prop {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-
-class experimenter(role_prop):
-    subtypes = {}
-
-    type = 65535
-
-    def __init__(self, experimenter=None, exp_type=None):
-        if experimenter != None:
-            self.experimenter = experimenter
-        else:
-            self.experimenter = 0
-        if exp_type != None:
-            self.exp_type = exp_type
-        else:
-            self.exp_type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        packed.append(struct.pack("!L", self.experimenter))
-        packed.append(struct.pack("!L", self.exp_type))
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!L', 4)
-        subclass = experimenter.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = experimenter()
-        _type = reader.read("!H")[0]
-        assert(_type == 65535)
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        obj.experimenter = reader.read("!L")[0]
-        obj.exp_type = reader.read("!L")[0]
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.experimenter != other.experimenter: return False
-        if self.exp_type != other.exp_type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("experimenter {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-                q.text("exp_type = ");
-                q.text("%#x" % self.exp_type)
-            q.breakable()
-        q.text('}')
-
-role_prop.subtypes[65535] = experimenter
-
-
diff --git a/python/ofagent/loxi/of14/table_mod_prop.py b/python/ofagent/loxi/of14/table_mod_prop.py
deleted file mode 100644
index fe002e3..0000000
--- a/python/ofagent/loxi/of14/table_mod_prop.py
+++ /dev/null
@@ -1,77 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-
-# Automatically generated by LOXI from template module.py
-# Do not modify
-
-import struct
-import loxi
-import util
-import loxi.generic_util
-
-import sys
-ofp = sys.modules['loxi.of14']
-
-class table_mod_prop(loxi.OFObject):
-    subtypes = {}
-
-
-    def __init__(self, type=None):
-        if type != None:
-            self.type = type
-        else:
-            self.type = 0
-        return
-
-    def pack(self):
-        packed = []
-        packed.append(struct.pack("!H", self.type))
-        packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
-        length = sum([len(x) for x in packed])
-        packed[1] = struct.pack("!H", length)
-        return ''.join(packed)
-
-    @staticmethod
-    def unpack(reader):
-        subtype, = reader.peek('!H', 0)
-        subclass = table_mod_prop.subtypes.get(subtype)
-        if subclass:
-            return subclass.unpack(reader)
-
-        obj = table_mod_prop()
-        obj.type = reader.read("!H")[0]
-        _length = reader.read("!H")[0]
-        orig_reader = reader
-        reader = orig_reader.slice(_length, 4)
-        return obj
-
-    def __eq__(self, other):
-        if type(self) != type(other): return False
-        if self.type != other.type: return False
-        return True
-
-    def pretty_print(self, q):
-        q.text("table_mod_prop {")
-        with q.group():
-            with q.indent(2):
-                q.breakable()
-            q.breakable()
-        q.text('}')
-
-
-
diff --git a/python/ofagent/loxi/of14/util.py b/python/ofagent/loxi/of14/util.py
deleted file mode 100644
index 1c01310..0000000
--- a/python/ofagent/loxi/of14/util.py
+++ /dev/null
@@ -1,136 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
-# Copyright (c) 2011, 2012 Open Networking Foundation
-# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
-# See the file LICENSE.pyloxi which should have been included in the source distribution
-# Automatically generated by LOXI from template util.py
-# Do not modify
-
-import struct
-import loxi
-import const
-import common
-import action
-import instruction
-import oxm
-import action_id
-import instruction_id
-import meter_band
-
-def pretty_mac(mac):
-    return ':'.join(["%02x" % x for x in mac])
-
-def pretty_ipv4(v):
-    return "%d.%d.%d.%d" % ((v >> 24) & 0xFF, (v >> 16) & 0xFF, (v >> 8) & 0xFF, v & 0xFF)
-
-def pretty_flags(v, flag_names):
-    set_flags = []
-    for flag_name in flag_names:
-        flag_value = getattr(const, flag_name)
-        if v & flag_value == flag_value:
-            set_flags.append(flag_name)
-        elif v & flag_value:
-            set_flags.append('%s&%#x' % (flag_name, v & flag_value))
-        v &= ~flag_value
-    if v:
-        set_flags.append("%#x" % v)
-    return '|'.join(set_flags) or '0'
-
-
-def pretty_port(v):
-    named_ports = [(k,v2) for (k,v2) in const.__dict__.iteritems() if k.startswith('OFPP_')]
-    for (k, v2) in named_ports:
-        if v == v2:
-            return k
-    return v
-
-def pack_port_no(value):
-    return struct.pack("!L", value)
-
-def unpack_port_no(reader):
-    return reader.read("!L")[0]
-
-def pack_fm_cmd(value):
-    return struct.pack("!B", value)
-
-def unpack_fm_cmd(reader):
-    return reader.read("!B")[0]
-
-def init_wc_bmap():
-    return 0
-
-def pack_wc_bmap(value):
-    return struct.pack("!Q", value)
-
-def unpack_wc_bmap(reader):
-    return reader.read("!Q")[0]
-
-def init_match_bmap():
-    return 0
-
-def pack_match_bmap(value):
-    return struct.pack("!Q", value)
-
-def unpack_match_bmap(reader):
-    return reader.read("!Q")[0]
-
-MASK64 = (1 << 64) - 1
-
-def pack_bitmap_128(value):
-    x = 0l
-    for y in value:
-        x |= 1 << y
-    return struct.pack("!QQ", (x >> 64) & MASK64, x & MASK64)
-
-def unpack_bitmap_128(reader):
-    hi, lo = reader.read("!QQ")
-    x = (hi << 64) | lo
-    i = 0
-    value = set()
-    while x != 0:
-        if x & 1 == 1:
-            value.add(i)
-        i += 1
-        x >>= 1
-    return value
-
-def pack_bitmap_512(value):
-    words = [0] * 8
-    for v in value:
-        assert v < 512
-        words[7-v/64] |= 1 << (v % 64)
-    return struct.pack("!8Q", *words)
-
-def unpack_bitmap_512(reader):
-    words = reader.read("!8Q")
-    x = 0l
-    for word in words:
-        x <<= 64
-        x |= word
-    i = 0
-    value = set()
-    while x != 0:
-        if x & 1 == 1:
-            value.add(i)
-        i += 1
-        x >>= 1
-    return value
-
-def pack_checksum_128(value):
-    return struct.pack("!QQ", (value >> 64) & MASK64, value & MASK64)
-
-def unpack_checksum_128(reader):
-    hi, lo = reader.read("!QQ")
-    return (hi << 64) | lo
diff --git a/python/ofagent/loxi/pp.py b/python/ofagent/loxi/pp.py
deleted file mode 100644
index 3a3fc97..0000000
--- a/python/ofagent/loxi/pp.py
+++ /dev/null
@@ -1,263 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# Copyright 2013, Big Switch Networks, Inc.
-
-"""
-pp - port of Ruby's PP library
-Also based on Lindig, C., & GbR, G. D. (2000). Strictly Pretty.
-
-Example usage:
->>> import pp.pp as pp
->>> print pp([[1, 2], [3, 4]], maxwidth=15)
-[
-  [ 1, 2 ],
-  [ 3, 4 ]
-]
-"""
-import unittest
-from contextlib import contextmanager
-
-def pp(obj, maxwidth=79):
-    """
-    Pretty-print the given object.
-    """
-    ctx = PrettyPrinter(maxwidth=maxwidth)
-    ctx.pp(obj)
-    return str(ctx)
-
-
-## Pretty-printers for builtin classes
-
-def pretty_print_list(pp, obj):
-    with pp.group():
-        pp.text('[')
-        with pp.indent(2):
-            for v in obj:
-                if not pp.first(): pp.text(',')
-                pp.breakable()
-                pp.pp(v)
-        pp.breakable()
-        pp.text(']')
-
-def pretty_print_dict(pp, obj):
-    with pp.group():
-        pp.text('{')
-        with pp.indent(2):
-            for (k, v) in sorted(obj.items()):
-                if not pp.first(): pp.text(',')
-                pp.breakable()
-                pp.pp(k)
-                pp.text(': ')
-                pp.pp(v)
-        pp.breakable()
-        pp.text('}')
-
-pretty_printers = {
-    list: pretty_print_list,
-    dict: pretty_print_dict,
-}
-
-
-## Implementation
-
-class PrettyPrinter(object):
-    def __init__(self, maxwidth):
-        self.maxwidth = maxwidth
-        self.cur_indent = 0
-        self.root_group = Group()
-        self.group_stack = [self.root_group]
-
-    def current_group(self):
-        return self.group_stack[-1]
-
-    def text(self, s):
-        self.current_group().append(str(s))
-
-    def breakable(self, sep=' '):
-        self.current_group().append(Breakable(sep, self.cur_indent))
-
-    def first(self):
-        return self.current_group().first()
-
-    @contextmanager
-    def indent(self, n):
-        self.cur_indent += n
-        yield
-        self.cur_indent -= n
-
-    @contextmanager
-    def group(self):
-        self.group_stack.append(Group())
-        yield
-        new_group = self.group_stack.pop()
-        self.current_group().append(new_group)
-
-    def pp(self, obj):
-        if hasattr(obj, "pretty_print"):
-            obj.pretty_print(self)
-        elif type(obj) in pretty_printers:
-            pretty_printers[type(obj)](self, obj)
-        else:
-            self.text(repr(obj))
-
-    def __str__(self):
-        return self.root_group.render(0, self.maxwidth)
-
-class Group(object):
-    __slots__ = ["fragments", "length", "_first"]
-
-    def __init__(self):
-        self.fragments = []
-        self.length = 0
-        self._first = True
-
-    def append(self, x):
-        self.fragments.append(x)
-        self.length += len(x)
-
-    def first(self):
-        if self._first:
-            self._first = False
-            return True
-        return False
-
-    def __len__(self):
-        return self.length
-
-    def render(self, curwidth, maxwidth):
-        dobreak = len(self) > (maxwidth - curwidth)
-
-        a = []
-        for x in self.fragments:
-            if isinstance(x, Breakable):
-                if dobreak:
-                    a.append('\n')
-                    a.append(' ' * x.indent)
-                    curwidth = 0
-                else:
-                    a.append(x.sep)
-            elif isinstance(x, Group):
-                a.append(x.render(curwidth, maxwidth))
-            else:
-                a.append(x)
-            curwidth += len(a[-1])
-        return ''.join(a)
-
-class Breakable(object):
-    __slots__ = ["sep", "indent"]
-
-    def __init__(self, sep, indent):
-        self.sep = sep
-        self.indent = indent
-
-    def __len__(self):
-        return len(self.sep)
-
-
-## Tests
-
-class TestPP(unittest.TestCase):
-    def test_scalars(self):
-        self.assertEquals(pp(1), "1")
-        self.assertEquals(pp("foo"), "'foo'")
-
-    def test_hash(self):
-        expected = """{ 1: 'a', 'b': 2 }"""
-        self.assertEquals(pp(eval(expected)), expected)
-        expected = """\
-{
-  1: 'a',
-  'b': 2
-}"""
-        self.assertEquals(pp(eval(expected), maxwidth=0), expected)
-
-    def test_array(self):
-        expected = """[ 1, 'a', 2 ]"""
-        self.assertEquals(pp(eval(expected)), expected)
-        expected = """\
-[
-  1,
-  'a',
-  2
-]"""
-        self.assertEquals(pp(eval(expected), maxwidth=0), expected)
-
-    def test_nested(self):
-        expected = """[ [ 1, 2 ], [ 3, 4 ] ]"""
-        self.assertEquals(pp(eval(expected)), expected)
-        expected = """\
-[
-  [
-    1,
-    2
-  ],
-  [
-    3,
-    4
-  ]
-]"""
-        self.assertEquals(pp(eval(expected), maxwidth=0), expected)
-
-    def test_breaking(self):
-        expected = """\
-[
-  [ 1, 2 ],
-  'abcdefghijklmnopqrstuvwxyz'
-]"""
-        self.assertEquals(pp(eval(expected), maxwidth=24), expected)
-        expected = """\
-[
-  [ 'abcd', 2 ],
-  [ '0123456789' ],
-  [
-    '0123456789',
-    'abcdefghij'
-  ],
-  [ 'abcdefghijklmnop' ],
-  [
-    'abcdefghijklmnopq'
-  ],
-  { 'k': 'v' },
-  {
-    1: [ 2, [ 3, 4 ] ],
-    'foo': 'abcdefghijklmnop'
-  }
-]"""
-        self.assertEquals(pp(eval(expected), maxwidth=24), expected)
-        expected = """\
-[
-  [ 1, 2 ],
-  [ 3, 4 ]
-]"""
-        self.assertEquals(pp(eval(expected), maxwidth=15), expected)
-
-    # This is an edge case where our simpler algorithm breaks down.
-    @unittest.expectedFailure
-    def test_greedy_breaking(self):
-        expected = """\
-abc def
-ghijklmnopqrstuvwxyz\
-"""
-        pp = PrettyPrinter(maxwidth=8)
-        pp.text("abc")
-        with pp.group():
-            pp.breakable()
-        pp.text("def")
-        with pp.group():
-            pp.breakable()
-        pp.text("ghijklmnopqrstuvwxyz")
-        self.assertEquals(str(pp), expected)
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/python/ofagent/main.py b/python/ofagent/main.py
deleted file mode 100755
index ec2ad0f..0000000
--- a/python/ofagent/main.py
+++ /dev/null
@@ -1,307 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright 2017 the original author or authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-import argparse
-import os
-
-import yaml
-import SocketServer
-
-from probe import Probe
-from twisted.internet import reactor
-from twisted.internet.defer import inlineCallbacks
-
-from pyvoltha.common.structlog_setup import setup_logging
-from pyvoltha.common.utils.dockerhelpers import get_my_containers_name
-from pyvoltha.common.utils.nethelpers import get_my_primary_local_ipv4
-from connection_mgr import ConnectionManager
-
-defs = dict(
-    config=os.environ.get('CONFIG', './ofagent.yml'),
-    consul=os.environ.get('CONSUL', 'localhost:8500'),
-    controller=os.environ.get('CONTROLLER', 'localhost:6653'),
-    probe=os.environ.get('PROBE', ':8080'),
-    external_host_address=os.environ.get('EXTERNAL_HOST_ADDRESS',
-                                         get_my_primary_local_ipv4()),
-    grpc_endpoint=os.environ.get('GRPC_ENDPOINT', 'localhost:50055'),
-    grpc_timeout=os.environ.get('GRPC_TIMEOUT', '10'),
-    core_binding_key=os.environ.get('CORE_BINDING_KEY', 'voltha_backend_name'),
-    core_transaction_key=os.environ.get('CORE_TRANSACTION_KEY', 'voltha_serial_number'),
-    instance_id=os.environ.get('INSTANCE_ID', os.environ.get('HOSTNAME', '1')),
-    internal_host_address=os.environ.get('INTERNAL_HOST_ADDRESS',
-                                         get_my_primary_local_ipv4()),
-    work_dir=os.environ.get('WORK_DIR', '/tmp/ofagent'),
-    key_file=os.environ.get('KEY_FILE', '/ofagent/pki/voltha.key'),
-    cert_file=os.environ.get('CERT_FILE', '/ofagent/pki/voltha.crt')
-)
-
-
-def parse_args():
-
-    parser = argparse.ArgumentParser()
-
-    _help = ('Path to ofagent.yml config file (default: %s). '
-             'If relative, it is relative to main.py of ofagent.'
-             % defs['config'])
-    parser.add_argument('-c', '--config',
-                        dest='config',
-                        action='store',
-                        default=defs['config'],
-                        help=_help)
-
-    _help = '<hostname>:<port> to consul agent (default: %s)' % defs['consul']
-    parser.add_argument(
-        '-C', '--consul', dest='consul', action='store',
-        default=defs['consul'],
-        help=_help)
-
-    _help = '<hostname1>:<port1> <hostname2>:<port2> <hostname3>:<port3> ... <hostnamen>:<portn>   to openflow controller (default: %s)' % \
-            defs['controller']
-    parser.add_argument(
-        '-O', '--controller',nargs = '*', dest='controller', action='store',
-        default=defs['controller'],
-        help=_help)
-
-    _help = '<hostname>:<port> for liveness and readiness probes (default: %s)' % defs['probe']
-    parser.add_argument(
-        '-P', '--probe', dest='probe', action='store',
-        default=defs['probe'],
-        help=_help)
-
-    _help = ('<hostname> or <ip> at which ofagent is reachable from outside '
-             'the cluster (default: %s)' % defs['external_host_address'])
-    parser.add_argument('-E', '--external-host-address',
-                        dest='external_host_address',
-                        action='store',
-                        default=defs['external_host_address'],
-                        help=_help)
-
-    _help = ('gRPC end-point to connect to. It can either be a direct '
-             'definition in the form of <hostname>:<port>, or it can be an '
-             'indirect definition in the form of @<service-name> where '
-             '<service-name> is the name of the grpc service as registered '
-             'in consul (example: @voltha-grpc). (default: %s)'
-             % defs['grpc_endpoint'])
-    parser.add_argument('-G', '--grpc-endpoint',
-                        dest='grpc_endpoint',
-                        action='store',
-                        default=defs['grpc_endpoint'],
-                        help=_help)
-
-    _help = 'gRPC timeout in seconds (default: %s)' % defs['grpc_timeout']
-    parser.add_argument('-T', '--grpc-timeout',
-                        dest='grpc_timeout',
-                        action='store',
-                        default=defs['grpc_timeout'],
-                        help=_help)
-
-    _help = ('The name of the meta-key whose value is the rw-core group '
-             'to which the ofagent\'s gRPC client is bound. '
-             '(default: %s)' % defs['core_binding_key'])
-    parser.add_argument('-B', '--core-binding-key',
-                        dest='core_binding_key',
-                        action='store',
-                        default=defs['core_binding_key'],
-                        help=_help)
-
-    _help = ('The name of the meta-key whose value is the transaction ID '
-             'used by the OFAgent to send requests to the Voltha RW Core. '
-             '(default: %s)' % defs['core_transaction_key'])
-    parser.add_argument('-ctk', '--core_transaction_key',
-                        dest='core_transaction_key',
-                        action='store',
-                        default=defs['core_transaction_key'],
-                        help=_help)
-
-    _help = ('<hostname> or <ip> at which ofagent is reachable from inside '
-             'the cluster (default: %s)' % defs['internal_host_address'])
-    parser.add_argument('-H', '--internal-host-address',
-                        dest='internal_host_address',
-                        action='store',
-                        default=defs['internal_host_address'],
-                        help=_help)
-
-    _help = ('unique string id of this ofagent instance (default: %s)'
-             % defs['instance_id'])
-    parser.add_argument('-i', '--instance-id',
-                        dest='instance_id',
-                        action='store',
-                        default=defs['instance_id'],
-                        help=_help)
-
-    _help = 'omit startup banner log lines'
-    parser.add_argument('-n', '--no-banner',
-                        dest='no_banner',
-                        action='store_true',
-                        default=False,
-                        help=_help)
-
-    _help = "suppress debug and info logs"
-    parser.add_argument('-q', '--quiet',
-                        dest='quiet',
-                        action='count',
-                        help=_help)
-
-    _help = 'enable verbose logging'
-    parser.add_argument('-v', '--verbose',
-                        dest='verbose',
-                        action='count',
-                        help=_help)
-
-    _help = ('work dir to compile and assemble generated files (default=%s)'
-             % defs['work_dir'])
-    parser.add_argument('-w', '--work-dir',
-                        dest='work_dir',
-                        action='store',
-                        default=defs['work_dir'],
-                        help=_help)
-
-    _help = ('use docker container name as ofagent instance id'
-             ' (overrides -i/--instance-id option)')
-    parser.add_argument('--instance-id-is-container-name',
-                        dest='instance_id_is_container_name',
-                        action='store_true',
-                        default=False,
-                        help=_help)
-
-    _help = ('Specify this option to enable TLS security between ofagent \
-              and onos.')
-    parser.add_argument('-t', '--enable-tls',
-                        dest='enable_tls',
-                        action='store_true',
-                        help=_help)
-
-    _help = ('key file to be used for tls security (default=%s)'
-             % defs['key_file'])
-    parser.add_argument('-k', '--key-file',
-                        dest='key_file',
-                        action='store',
-                        default=defs['key_file'],
-                        help=_help)
-
-    _help = ('certificate file to be used for tls security (default=%s)'
-             % defs['cert_file'])
-    parser.add_argument('-r', '--cert-file',
-                        dest='cert_file',
-                        action='store',
-                        default=defs['cert_file'],
-                        help=_help)
-
-    args = parser.parse_args()
-
-    # post-processing
-
-    if args.instance_id_is_container_name:
-        args.instance_id = get_my_containers_name()
-
-    return args
-
-
-def load_config(args):
-    path = args.config
-    if path.startswith('.'):
-        dir = os.path.dirname(os.path.abspath(__file__))
-        path = os.path.join(dir, path)
-    path = os.path.abspath(path)
-    with open(path) as fd:
-        config = yaml.load(fd)
-    return config
-
-banner = r'''
-  ___  _____ _                    _
- / _ \|  ___/ \   __ _  ___ _ __ | |_
-| | | | |_ / _ \ / _` |/ _ \ '_ \| __|
-| |_| |  _/ ___ \ (_| |  __/ | | | |_
- \___/|_|/_/   \_\__, |\___|_| |_|\__|
-                 |___/
-'''
-
-def print_banner(log):
-    for line in banner.strip('\n').splitlines():
-        log.info(line)
-    log.info('(to stop: press Ctrl-C)')
-
-
-class Main(object):
-
-    def __init__(self):
-
-        self.args = args = parse_args()
-        self.config = load_config(args)
-        self.grpc_timeout = int(self.args.grpc_timeout)
-
-        verbosity_adjust = (args.verbose or 0) - (args.quiet or 0)
-        self.log = setup_logging(self.config.get('logging', {}),
-                                 args.instance_id,
-                                 verbosity_adjust=verbosity_adjust)
-
-        # components
-        self.connection_manager = None
-
-        self.exiting = False
-
-        if not args.no_banner:
-            print_banner(self.log)
-
-        self.startup_components()
-
-    def start(self):
-        self.start_reactor()  # will not return except Keyboard interrupt
-
-    @inlineCallbacks
-    def startup_components(self):
-        self.log.info('starting-internal-components')
-        args = self.args
-        self.connection_manager = yield ConnectionManager(
-            args.consul,
-            args.grpc_endpoint,
-            self.grpc_timeout,
-            args.core_binding_key,
-            args.core_transaction_key,
-            args.controller,
-            args.instance_id,
-            args.enable_tls,
-            args.key_file,
-            args.cert_file).start()
-        Probe.connection_manager = self.connection_manager
-        self.log.info('started-internal-services')
-
-    @inlineCallbacks
-    def shutdown_components(self):
-        """Execute before the reactor is shut down"""
-        self.log.info('exiting-on-keyboard-interrupt')
-        self.exiting = True
-        if self.connection_manager is not None:
-            yield self.connection_manager.stop()
-
-    def start_reactor(self):
-        reactor.callWhenRunning(
-            lambda: self.log.info('twisted-reactor-started'))
-
-        reactor.addSystemEventTrigger('before', 'shutdown',
-                                      self.shutdown_components)
-        reactor.callInThread(self.start_probe)
-        reactor.run()
-
-    def start_probe(self):
-        args = self.args
-        host = args.probe.split(':')[0]
-        port = args.probe.split(':')[1]
-        server = SocketServer.TCPServer((host, int(port)), Probe)
-        server.serve_forever()
-
-if __name__ == '__main__':
-    Main().start()
diff --git a/python/ofagent/of_connection.py b/python/ofagent/of_connection.py
deleted file mode 100755
index a941111..0000000
--- a/python/ofagent/of_connection.py
+++ /dev/null
@@ -1,126 +0,0 @@
-#
-# Copyright 2017 the original author or authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-import structlog
-from hexdump import hexdump
-from twisted.internet import protocol
-
-import loxi.of14
-from pyvoltha.common.utils.message_queue import MessageQueue
-
-log = structlog.get_logger()
-
-
-class OpenFlowConnection(protocol.Protocol):
-
-    def __init__(self, agent):
-        self.agent = agent  # the protocol will call agent.enter_disconnected()
-                            # and agent.enter_connected() methods to indicate
-                            # when state change is necessary
-        self.next_xid = 1
-        self.read_buffer = None
-        self.rx = MessageQueue()
-
-    def connectionLost(self, reason):
-        self.agent.enter_disconnected('connection-lost', reason)
-
-    def connectionMade(self):
-        self.agent.enter_connected()
-
-    def dataReceived(self, data):
-        log.debug('data-received', len=len(data),
-                  received=hexdump(data, result='return'))
-
-        assert len(data)  # connection close shall be handled by the protocol
-        buf = self.read_buffer
-        if buf:
-            buf += data
-        else:
-            buf = data
-
-        offset = 0
-        while offset < len(buf):
-            if offset + 8 > len(buf):
-                break  # not enough data for the OpenFlow header
-
-            # parse the header to get type
-            _version, _type, _len, _xid = \
-                loxi.of14.message.parse_header(buf[offset:])
-
-            ofp = loxi.protocol(_version)
-
-            if (offset + _len) > len(buf):
-                break  # not enough data to cover whole message
-
-            rawmsg = buf[offset : offset + _len]
-            offset += _len
-
-            msg = ofp.message.parse_message(rawmsg)
-            if not msg:
-                log.warn('could-not-parse',
-                         data=hexdump(rawmsg, result='return'))
-            log.debug('received-msg', module=type(msg).__module__,
-                  name=type(msg).__name__, xid=msg.xid, len=len(buf))
-            self.rx.put(msg)
-
-        if offset == len(buf):
-            self.read_buffer = None
-        else:
-            self.read_buffer = buf[offset:]
-            log.debug('remaining', len=len(self.read_buffer))
-
-    def send_raw(self, buf):
-        """
-        Send raw bytes on the socket
-        :param buf: bytes buffer
-        :return: None
-        """
-        assert self.connected
-        log.debug('sending-raw', len=len(buf))
-        self.transport.write(buf)
-
-    def send(self, msg):
-        """
-        Send a message
-        :param msg: An OpenFlow protocol message
-        :return: None
-        """
-        assert self.connected
-
-        if msg.xid is None:
-            msg.xid = self._gen_xid()
-        buf = msg.pack()
-        log.debug('sending', module=type(msg).__module__,
-                  name=type(msg).__name__, xid=msg.xid, len=len(buf))
-        self.transport.write(buf)
-        log.debug('data-sent', sent=hexdump(buf, result='return'))
-
-    def recv(self, predicate):
-        assert self.connected
-        return self.rx.get(predicate)
-
-    def recv_any(self):
-        return self.recv(lambda _: True)
-
-    def recv_xid(self, xid):
-        return self.recv(lambda msg: msg.xid == xid)
-
-    def recv_class(self, klass):
-        return self.recv(lambda msg: isinstance(msg, klass))
-
-    def _gen_xid(self):
-        xid = self.next_xid
-        self.next_xid += 1
-        return xid
diff --git a/python/ofagent/of_protocol_handler.py b/python/ofagent/of_protocol_handler.py
deleted file mode 100755
index f8f817c..0000000
--- a/python/ofagent/of_protocol_handler.py
+++ /dev/null
@@ -1,380 +0,0 @@
-#
-# Copyright 2017 the original author or authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-import structlog
-from twisted.internet.defer import inlineCallbacks, returnValue
-
-import loxi.of13 as ofp
-from converter import to_loxi, pb2dict, to_grpc
-from binascii import hexlify
-
-log = structlog.get_logger()
-
-
-class OpenFlowProtocolError(Exception): pass
-
-
-class OpenFlowProtocolHandler(object):
-
-    ofp_version = [4]  # OFAgent supported versions
-
-    MAX_METER_IDS = 4294967295
-    MAX_METER_BANDS = 255
-    MAX_METER_COLORS = 255
-
-    def __init__(self, datapath_id, device_id, agent, cxn):
-        """
-        The upper half of the OpenFlow protocol, focusing on message
-        exchanges.
-        :param agent: Reference to the Agent() instance, can be used to
-          indicate critical errors to break the connection.
-        :param cxn: The lower level message serdes part of the OF protocol.
-        """
-        self.datapath_id = datapath_id
-        self.device_id = device_id
-        self.agent = agent
-        self.cxn = cxn
-        self.role = None
-
-    @inlineCallbacks
-    def start(self):
-        """A new call is made after a fresh reconnect"""
-
-        log.debug('starting')
-
-        try:
-            support = False
-            # send initial hello message
-            self.cxn.send(ofp.message.hello(elements=[ofp.common.hello_elem_versionbitmap(
-                bitmaps = [ofp.common.hello_elem_bitmap(self.ofp_version)])]))
-            # expect to receive a hello message
-            msg = yield self.cxn.recv_class(ofp.message.hello)
-            # supports only ofp_versions till 31 and single bitmap.
-            if msg:
-                support = ofp.util.verify_version_support(msg,self.ofp_version)
-                if not support:
-                    self.cxn.send(ofp.message.hello_failed_error_msg(
-                        xid=msg.xid, code=ofp.OFPHFC_INCOMPATIBLE,
-                        data='i support only 1.3'))
-                    log.error('peer-do-not-support-OpenFlow-version',self.ofp_version)
-
-            while support:
-                req = yield self.cxn.recv_any()
-                handler = self.main_handlers.get(req.type, None)
-                if handler:
-                    handler(self, req)
-                else:
-                    log.error('cannot-handle',
-                              request=req, xid=req.xid, type=req.type)
-
-        except Exception, e:
-            log.exception('exception', e=e)
-
-        log.info('started')
-        returnValue(self)
-
-    def stop(self):
-        log.debug('stopping')
-        pass  # nothing to do yet
-        log.info('stopped')
-
-    def handle_echo_request(self, req):
-        self.cxn.send(ofp.message.echo_reply(xid=req.xid))
-
-    @inlineCallbacks
-    def handle_feature_request(self, req):
-        rpc = self.agent.connection_manager.get_rpc_client()
-        if rpc is not None:
-            device_info = yield rpc.get_device_info(self.device_id)
-            kw = pb2dict(device_info.switch_features)
-            self.cxn.send(ofp.message.features_reply(
-                xid=req.xid,
-                datapath_id=self.datapath_id,
-                **kw))
-
-    def handle_stats_request(self, req):
-        handler = self.stats_handlers.get(req.stats_type, None)
-        if handler:
-            handler(self, req)
-        else:
-            raise OpenFlowProtocolError(
-                'Cannot handle stats request type "{}"'.format(req.stats_type))
-
-    def handle_barrier_request(self, req):
-        # not really doing barrier yet, but we respond
-        # see https://jira.opencord.org/browse/CORD-823
-        self.cxn.send(ofp.message.barrier_reply(xid=req.xid))
-
-    def handle_experimenter_request(self, req):
-        raise NotImplementedError()
-
-    def handle_flow_mod_request(self, req):
-        log.debug('flow mod request')
-        rpc = self.agent.connection_manager.get_rpc_client()
-        if rpc is not None:
-            if self.role == ofp.OFPCR_ROLE_MASTER or self.role == ofp.OFPCR_ROLE_EQUAL:
-               try:
-                  grpc_req = to_grpc(req)
-               except Exception, e:
-                  log.exception('failed-to-convert', e=e)
-               else:
-                  return rpc.update_flow_table(self.device_id, grpc_req)
-
-            elif self.role == ofp.OFPCR_ROLE_SLAVE:
-               self.cxn.send(ofp.message.bad_request_error_msg(code=ofp.OFPBRC_IS_SLAVE))
-
-
-    def handle_meter_mod_request(self, req):
-        log.info('Received  handle_meter_mod_request', request=req)
-        rpc = self.agent.connection_manager.get_rpc_client()
-        if rpc is not None:
-            if self.role == ofp.OFPCR_ROLE_MASTER or self.role == ofp.OFPCR_ROLE_EQUAL:
-                try:
-                    grpc_req = to_grpc(req)
-                except Exception, e:
-                    log.exception('failed-to-convert-meter-mod-request', e=e)
-                else:
-                    return rpc.update_meter_mod_table(self.device_id, grpc_req)
-
-            elif self.role == ofp.OFPCR_ROLE_SLAVE:
-                self.cxn.send(ofp.message.bad_request_error_msg(code=ofp.OFPBRC_IS_SLAVE))
-
-    @inlineCallbacks
-    def handle_meter_stats_request(self, req):
-        log.info('Received  handle_meter_stats_request', request=req)
-        rpc = self.agent.connection_manager.get_rpc_client()
-        if rpc is not None:
-            try:
-                meters = yield rpc.list_meters(self.device_id)
-                self.cxn.send(ofp.message.meter_stats_reply(
-                    xid=req.xid, entries=[to_loxi(m.stats) for m in meters]))
-            except Exception, e:
-                log.exception("failed-meter-stats-request", req=req, e=e)
-
-    def handle_get_async_request(self, req):
-        raise NotImplementedError()
-
-    def handle_get_config_request(self, req):
-        self.cxn.send(ofp.message.get_config_reply(
-            xid=req.xid,
-            miss_send_len=ofp.OFPCML_NO_BUFFER
-        ))
-
-    @inlineCallbacks
-    def handle_group_mod_request(self, req):
-        rpc = self.agent.connection_manager.get_rpc_client()
-        if rpc is not None:
-            if self.role == ofp.OFPCR_ROLE_MASTER or self.role == ofp.OFPCR_ROLE_EQUAL:
-               yield rpc.update_group_table(self.device_id, to_grpc(req))
-            elif self.role == ofp.OFPCR_ROLE_SLAVE:
-               self.cxn.send(ofp.message.bad_request_error_msg(code=ofp.OFPBRC_IS_SLAVE))
-
-    def handle_role_request(self, req):
-        if req.role == ofp.OFPCR_ROLE_MASTER or req.role == ofp.OFPCR_ROLE_SLAVE:
-            if self.agent.generation_is_defined and (
-                    ((req.generation_id - self.agent.cached_generation_id) & 0xffffffffffffffff) if abs(
-                    req.generation_id - self.agent.cached_generation_id) > 0x7fffffffffffffff else (
-                    req.generation_id - self.agent.cached_generation_id)) < 0:
-                self.cxn.send(ofp.message.bad_request_error_msg(code=ofp.OFPRRFC_STALE))
-            else:
-                self.agent.generation_is_defined = True
-                self.agent.cached_generation_id = req.generation_id
-                self.role = req.role
-                self.cxn.send(ofp.message.role_reply(
-                 xid=req.xid, role=req.role, generation_id=req.generation_id))
-        elif req.role == ofp.OFPCR_ROLE_EQUAL:
-            self.role = req.role
-            self.cxn.send(ofp.message.role_reply(
-             xid=req.xid, role=req.role))
-
-    def handle_packet_out_request(self, req):
-        rpc = self.agent.connection_manager.get_rpc_client()
-        if rpc is not None:
-            if self.role == ofp.OFPCR_ROLE_MASTER or self.role == ofp.OFPCR_ROLE_EQUAL:
-               rpc.send_packet_out(self.device_id, to_grpc(req))
-
-            elif self.role == ofp.OFPCR_ROLE_SLAVE:
-               self.cxn.send(ofp.message.bad_request_error_msg(code=ofp.OFPBRC_IS_SLAVE))
-
-    def handle_set_config_request(self, req):
-        # Handle set config appropriately
-        # https://jira.opencord.org/browse/CORD-826
-        pass
-
-    @inlineCallbacks
-    def handle_port_mod_request(self, req):
-        rpc = self.agent.connection_manager.get_rpc_client()
-        if rpc is not None:
-            if self.role == ofp.OFPCR_ROLE_MASTER or self.role == ofp.OFPCR_ROLE_EQUAL:
-                port = yield rpc.get_port(self.device_id, str(req.port_no))
-
-                if port.ofp_port.config & ofp.OFPPC_PORT_DOWN != \
-                        req.config & ofp.OFPPC_PORT_DOWN:
-                    if req.config & ofp.OFPPC_PORT_DOWN:
-                        rpc.disable_port(self.device_id, port.id)
-                    else:
-                        rpc.enable_port(self.device_id, port.id)
-
-            elif self.role == ofp.OFPCR_ROLE_SLAVE:
-                self.cxn.send(ofp.message.bad_request_error_msg(code=ofp.OFPBRC_IS_SLAVE))
-
-    def handle_table_mod_request(self, req):
-        raise NotImplementedError()
-
-    def handle_queue_get_config_request(self, req):
-        raise NotImplementedError()
-
-    def handle_set_async_request(self, req):
-        raise NotImplementedError()
-
-    def handle_aggregate_request(self, req):
-        raise NotImplementedError
-
-    @inlineCallbacks
-    def handle_device_description_request(self, req):
-        rpc = self.agent.connection_manager.get_rpc_client()
-        if rpc is not None:
-            device_info = yield rpc.get_device_info(self.device_id)
-            kw = pb2dict(device_info.desc)
-            self.cxn.send(ofp.message.desc_stats_reply(xid=req.xid, **kw))
-
-    def handle_experimenter_stats_request(self, req):
-        raise NotImplementedError()
-
-    @inlineCallbacks
-    def handle_flow_stats_request(self, req):
-        rpc = self.agent.connection_manager.get_rpc_client()
-        if rpc is not None:
-            try:
-                flow_stats = yield rpc.list_flows(self.device_id)
-                self.cxn.send(ofp.message.flow_stats_reply(
-                    xid=req.xid, entries=[to_loxi(f) for f in flow_stats]))
-            except Exception, e:
-                log.exception('failed-flow-stats-request', req=req)
-
-    @inlineCallbacks
-    def handle_group_stats_request(self, req):
-        rpc = self.agent.connection_manager.get_rpc_client()
-        if rpc is not None:
-            group_stats = yield rpc.list_groups(self.device_id)
-            self.cxn.send(ofp.message.group_stats_reply(
-                xid=req.xid, entries=[to_loxi(g.stats) for g  in group_stats]))
-
-    @inlineCallbacks
-    def handle_group_descriptor_request(self, req):
-        rpc = self.agent.connection_manager.get_rpc_client()
-        if rpc is not None:
-            group_stats = yield rpc.list_groups(self.device_id)
-            self.cxn.send(ofp.message.group_desc_stats_reply(
-                xid=req.xid, entries=[to_loxi(g.desc) for g  in group_stats]))
-
-    def handle_group_features_request(self, req):
-        raise NotImplementedError()
-
-    def handle_meter_config_request(self, req):
-        raise NotImplementedError()
-
-    def handle_meter_features_request(self, req):
-        feature = ofp.meter_features(max_meter=OpenFlowProtocolHandler.MAX_METER_IDS,
-                                     band_types=ofp.OFPMBT_DROP,
-                                     capabilities=ofp.OFPMF_KBPS,
-                                     max_bands=OpenFlowProtocolHandler.MAX_METER_BANDS,
-                                     max_color=OpenFlowProtocolHandler.MAX_METER_COLORS)
-        self.cxn.send(ofp.message.meter_features_stats_reply(xid=req.xid, flags=None,
-                                                             features=feature))
-
-    @inlineCallbacks
-    def handle_port_stats_request(self, req):
-        rpc = self.agent.connection_manager.get_rpc_client()
-        if rpc is not None:
-            try:
-                ports = yield rpc.list_ports(self.device_id)
-                port_stats = [to_loxi(p.ofp_port_stats) for p in ports]
-                of_message = ofp.message.port_stats_reply(
-                    xid=req.xid,entries=port_stats)
-                self.cxn.send(of_message)
-            except:
-                log.exception('failed-port_stats-request', req=req)
-
-    @inlineCallbacks
-    def handle_port_desc_request(self, req):
-        rpc = self.agent.connection_manager.get_rpc_client()
-        if rpc is not None:
-            port_list = yield rpc.get_port_list(self.device_id)
-            try:
-                self.cxn.send(ofp.message.port_desc_stats_reply(
-                    xid=req.xid,
-                    #flags=None,
-                    entries=[to_loxi(port.ofp_port) for port in port_list]
-                ))
-            except Exception as err:
-                log.exception('failed-port-desc-reply', err=err)
-
-    def handle_queue_stats_request(self, req):
-        raise NotImplementedError()
-
-    def handle_table_stats_request(self, req):
-        table_stats = []  # see https://jira.opencord.org/browse/CORD-825
-        self.cxn.send(ofp.message.table_stats_reply(
-            xid=req.xid, entries=table_stats))
-
-    def handle_table_features_request(self, req):
-        raise NotImplementedError()
-
-    stats_handlers = {
-        ofp.OFPST_AGGREGATE: handle_aggregate_request,
-        ofp.OFPST_DESC: handle_device_description_request,
-        ofp.OFPST_EXPERIMENTER: handle_experimenter_stats_request,
-        ofp.OFPST_FLOW: handle_flow_stats_request,
-        ofp.OFPST_GROUP: handle_group_stats_request,
-        ofp.OFPST_GROUP_DESC: handle_group_descriptor_request,
-        ofp.OFPST_GROUP_FEATURES: handle_group_features_request,
-        ofp.OFPST_METER: handle_meter_stats_request,
-        ofp.OFPST_METER_CONFIG: handle_meter_config_request,
-        ofp.OFPST_METER_FEATURES: handle_meter_features_request,
-        ofp.OFPST_PORT: handle_port_stats_request,
-        ofp.OFPST_PORT_DESC: handle_port_desc_request,
-        ofp.OFPST_QUEUE: handle_queue_stats_request,
-        ofp.OFPST_TABLE: handle_table_stats_request,
-        ofp.OFPST_TABLE_FEATURES: handle_table_features_request
-    }
-
-    main_handlers = {
-        ofp.OFPT_BARRIER_REQUEST: handle_barrier_request,
-        ofp.OFPT_ECHO_REQUEST: handle_echo_request,
-        ofp.OFPT_FEATURES_REQUEST: handle_feature_request,
-        ofp.OFPT_EXPERIMENTER: handle_experimenter_request,
-        ofp.OFPT_FLOW_MOD: handle_flow_mod_request,
-        ofp.OFPT_GET_ASYNC_REQUEST: handle_get_async_request,
-        ofp.OFPT_GET_CONFIG_REQUEST: handle_get_config_request,
-        ofp.OFPT_GROUP_MOD: handle_group_mod_request,
-        ofp.OFPT_METER_MOD: handle_meter_mod_request,
-        ofp.OFPT_PACKET_OUT: handle_packet_out_request,
-        ofp.OFPT_PORT_MOD: handle_port_mod_request,
-        ofp.OFPT_QUEUE_GET_CONFIG_REQUEST: handle_queue_get_config_request,
-        ofp.OFPT_ROLE_REQUEST: handle_role_request,
-        ofp.OFPT_SET_ASYNC: handle_set_async_request,
-        ofp.OFPT_SET_CONFIG: handle_set_config_request,
-        ofp.OFPT_STATS_REQUEST: handle_stats_request,
-        ofp.OFPT_TABLE_MOD: handle_table_mod_request,
-    }
-
-    def forward_packet_in(self, ofp_packet_in):
-        if self.role == ofp.OFPCR_ROLE_MASTER or self.role == ofp.OFPCR_ROLE_EQUAL:
-           log.info('sending-packet-in', ofp_packet_in=ofp_packet_in, packet=hexlify(ofp_packet_in.data))
-           self.cxn.send(to_loxi(ofp_packet_in))
-
-    def forward_port_status(self, ofp_port_status):
-        self.cxn.send(to_loxi(ofp_port_status))
diff --git a/python/ofagent/ofagent.yml b/python/ofagent/ofagent.yml
deleted file mode 100644
index a0e2cdd..0000000
--- a/python/ofagent/ofagent.yml
+++ /dev/null
@@ -1,50 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-logging:
-    version: 1
-
-    formatters:
-      brief:
-        format: '%(message)s'
-      default:
-        format: '%(asctime)s.%(msecs)03d %(levelname)-8s %(module)s.%(funcName)s %(message)s'
-        datefmt: '%Y%m%dT%H%M%S'
-
-    handlers:
-        console:
-            class : logging.StreamHandler
-            level: DEBUG
-            formatter: default
-            stream: ext://sys.stdout
-        localRotatingFile:
-            class: logging.handlers.RotatingFileHandler
-            filename: ofagent.log
-            formatter: default
-            maxBytes: 2097152
-            backupCount: 10
-            level: DEBUG
-        null:
-            class: logging.NullHandler
-
-    loggers:
-        amqp:
-            handlers: [null]
-            propagate: False
-        conf:
-            propagate: False
-        '': # root logger
-            handlers: [console, localRotatingFile]
-            level: INFO # this can be bumped up/down by -q and -v command line
-                        # options
-            propagate: False
diff --git a/python/ofagent/probe.py b/python/ofagent/probe.py
deleted file mode 100644
index 1d2358e..0000000
--- a/python/ofagent/probe.py
+++ /dev/null
@@ -1,48 +0,0 @@
-#
-# Copyright 2017 the original author or authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-from SimpleHTTPServer import SimpleHTTPRequestHandler
-from structlog import get_logger
-log = get_logger()
-
-class Probe(SimpleHTTPRequestHandler):
-
-    connection_manager = None
-
-    def do_GET(self):
-
-        if self.path == '/healthz':
-            self.health_probe()
-
-        elif self.path == '/readz':
-            self.ready_probe()
-
-    def health_probe(self):
-
-        if Probe.connection_manager is None or Probe.connection_manager.liveness_probe():
-            self.send_response(200)
-            self.end_headers()
-        else :
-            self.send_response(418)
-            self.end_headers()
-
-    def ready_probe(self):
-
-        if Probe.connection_manager is not None and Probe.connection_manager.readiness_probe():
-            self.send_response(200)
-            self.end_headers()
-        else :
-            self.send_response(418)
-            self.end_headers()
diff --git a/python/ofagent/protos/Makefile b/python/ofagent/protos/Makefile
deleted file mode 100644
index c6f5d8c..0000000
--- a/python/ofagent/protos/Makefile
+++ /dev/null
@@ -1,43 +0,0 @@
-#
-# Copyright 2017 the original author or authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-# Makefile to build all protobuf and gRPC related artifacts
-
-ifeq ($(VOLTHA_BASE)_set,_set)
-  $(error To get started, please source the env.sh file from Voltha top level directory)
-endif
-
-# This makefile is used only to copy relevant *_pb2.py files from Voltha
-# to allow ofagent to function properly.
-
-
-TARGET_PROTO_DIR := $(VOLTHA_BASE)/ofagent/protos
-SOURCE_PROTO_DIR := $(VOLTHA_BASE)/voltha/protos
-TARGET_GOOGLE_API_DIR := $(TARGET_PROTO_DIR)/third_party/google/api
-SOURCE_GOOGLE_API_DIR := $(SOURCE_PROTO_DIR)/third_party/google/api
-
-build: copyfiles
-
-copyfiles:
-	rsync -av --include '*/' --exclude='third_party/__init__.py' --include '*.py' --exclude='*' $(SOURCE_PROTO_DIR)/ $(TARGET_PROTO_DIR)
-	rsync -av --include '*/' --exclude='third_party/__init__.py' --include '*.py' --include '*.desc' --include '*.proto' --exclude='*' $(SOURCE_GOOGLE_API_DIR)/ $(TARGET_GOOGLE_API_DIR)
-
-clean:
-	rm -f $(TARGET_PROTO_DIR)/*_pb2*.py
-	rm -f $(TARGET_GOOGLE_API_DIR)/*_pb2*.py
-	rm -f $(TARGET_GOOGLE_API_DIR)/*_pb2*.pyc
-	rm -f $(TARGET_GOOGLE_API_DIR)/*.proto
-	rm -f $(TARGET_GOOGLE_API_DIR)/*.desc
diff --git a/python/ofagent/protos/README b/python/ofagent/protos/README
deleted file mode 100644
index 65c5e93..0000000
--- a/python/ofagent/protos/README
+++ /dev/null
@@ -1 +0,0 @@
-Protoc-generated *.py files are populated here from Voltha via make
diff --git a/python/ofagent/protos/__init__.py b/python/ofagent/protos/__init__.py
deleted file mode 100755
index b0fb0b2..0000000
--- a/python/ofagent/protos/__init__.py
+++ /dev/null
@@ -1,13 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
diff --git a/python/ofagent/protos/third_party/__init__.py b/python/ofagent/protos/third_party/__init__.py
deleted file mode 100644
index 818c1b1..0000000
--- a/python/ofagent/protos/third_party/__init__.py
+++ /dev/null
@@ -1,50 +0,0 @@
-#
-# Copyright 2017 the original author or authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-"""
-This helps loading http_pb2 and annotations_pb2.
-Without this, the Python importer will not be able to process the lines:
-from google.api import http_pb2 or
-from google.api import annotations_pb2
-(Without importing these, the protobuf loader will not recognize http options
-in the protobuf definitions.)
-"""
-
-from importlib import import_module
-import os
-import sys
-
-
-class GoogleApiImporter(object):
-
-    def find_module(self, full_name, path=None):
-        if full_name == 'google.api':
-            self.path = [os.path.dirname(__file__)]
-            return self
-
-    def load_module(self, name):
-        if name in sys.modules:
-            return sys.modules[name]
-        full_name = 'ofagent.protos.third_party.' + name
-        import_module(full_name)
-        module = sys.modules[full_name]
-        sys.modules[name] = module
-        return module
-
-
-sys.meta_path.append(GoogleApiImporter())
-from google.api import http_pb2, annotations_pb2
-_ = http_pb2, annotations_pb2
diff --git a/python/ofagent/protos/third_party/google/__init__.py b/python/ofagent/protos/third_party/google/__init__.py
deleted file mode 100644
index b0fb0b2..0000000
--- a/python/ofagent/protos/third_party/google/__init__.py
+++ /dev/null
@@ -1,13 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
diff --git a/python/ofagent/protos/third_party/google/api/__init__.py b/python/ofagent/protos/third_party/google/api/__init__.py
deleted file mode 100644
index b0fb0b2..0000000
--- a/python/ofagent/protos/third_party/google/api/__init__.py
+++ /dev/null
@@ -1,13 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
diff --git a/python/ofagent/protos/third_party/google/api/annotations.proto b/python/ofagent/protos/third_party/google/api/annotations.proto
deleted file mode 100644
index cbd18b8..0000000
--- a/python/ofagent/protos/third_party/google/api/annotations.proto
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright (c) 2015, Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-syntax = "proto3";
-
-package google.api;
-
-import "google/api/http.proto";
-import "google/protobuf/descriptor.proto";
-
-option java_multiple_files = true;
-option java_outer_classname = "AnnotationsProto";
-option java_package = "com.google.api";
-
-extend google.protobuf.MethodOptions {
-  // See `HttpRule`.
-  HttpRule http = 72295728;
-}
diff --git a/python/ofagent/protos/third_party/google/api/http.proto b/python/ofagent/protos/third_party/google/api/http.proto
deleted file mode 100644
index ce07aa1..0000000
--- a/python/ofagent/protos/third_party/google/api/http.proto
+++ /dev/null
@@ -1,127 +0,0 @@
-// Copyright (c) 2015, Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-syntax = "proto3";
-
-package google.api;
-
-option java_multiple_files = true;
-option java_outer_classname = "HttpProto";
-option java_package = "com.google.api";
-
-
-// `HttpRule` defines the mapping of an RPC method to one or more HTTP REST API
-// methods. The mapping determines what portions of the request message are
-// populated from the path, query parameters, or body of the HTTP request.  The
-// mapping is typically specified as an `google.api.http` annotation, see
-// "google/api/annotations.proto" for details.
-//
-// The mapping consists of a mandatory field specifying a path template and an
-// optional `body` field specifying what data is represented in the HTTP request
-// body. The field name for the path indicates the HTTP method. Example:
-//
-// ```
-// package google.storage.v2;
-//
-// import "google/api/annotations.proto";
-//
-// service Storage {
-//   rpc CreateObject(CreateObjectRequest) returns (Object) {
-//     option (google.api.http) {
-//       post: "/v2/{bucket_name=buckets/*}/objects"
-//       body: "object"
-//     };
-//   };
-// }
-// ```
-//
-// Here `bucket_name` and `object` bind to fields of the request message
-// `CreateObjectRequest`.
-//
-// The rules for mapping HTTP path, query parameters, and body fields
-// to the request message are as follows:
-//
-// 1. The `body` field specifies either `*` or a field path, or is
-//    omitted. If omitted, it assumes there is no HTTP body.
-// 2. Leaf fields (recursive expansion of nested messages in the
-//    request) can be classified into three types:
-//     (a) Matched in the URL template.
-//     (b) Covered by body (if body is `*`, everything except (a) fields;
-//         else everything under the body field)
-//     (c) All other fields.
-// 3. URL query parameters found in the HTTP request are mapped to (c) fields.
-// 4. Any body sent with an HTTP request can contain only (b) fields.
-//
-// The syntax of the path template is as follows:
-//
-//     Template = "/" Segments [ Verb ] ;
-//     Segments = Segment { "/" Segment } ;
-//     Segment  = "*" | "**" | LITERAL | Variable ;
-//     Variable = "{" FieldPath [ "=" Segments ] "}" ;
-//     FieldPath = IDENT { "." IDENT } ;
-//     Verb     = ":" LITERAL ;
-//
-// `*` matches a single path component, `**` zero or more path components, and
-// `LITERAL` a constant.  A `Variable` can match an entire path as specified
-// again by a template; this nested template must not contain further variables.
-// If no template is given with a variable, it matches a single path component.
-// The notation `{var}` is henceforth equivalent to `{var=*}`.
-//
-// Use CustomHttpPattern to specify any HTTP method that is not included in the
-// pattern field, such as HEAD, or "*" to leave the HTTP method unspecified for
-// a given URL path rule. The wild-card rule is useful for services that provide
-// content to Web (HTML) clients.
-message HttpRule {
-
-  // Determines the URL pattern is matched by this rules. This pattern can be
-  // used with any of the {get|put|post|delete|patch} methods. A custom method
-  // can be defined using the 'custom' field.
-  oneof pattern {
-    // Used for listing and getting information about resources.
-    string get = 2;
-
-    // Used for updating a resource.
-    string put = 3;
-
-    // Used for creating a resource.
-    string post = 4;
-
-    // Used for deleting a resource.
-    string delete = 5;
-
-    // Used for updating a resource.
-    string patch = 6;
-
-    // Custom pattern is used for defining custom verbs.
-    CustomHttpPattern custom = 8;
-  }
-
-  // The name of the request field whose value is mapped to the HTTP body, or
-  // `*` for mapping all fields not captured by the path pattern to the HTTP
-  // body.
-  string body = 7;
-
-  // Additional HTTP bindings for the selector. Nested bindings must not
-  // specify a selector and must not contain additional bindings.
-  repeated HttpRule additional_bindings = 11;
-}
-
-// A custom pattern is used for defining custom HTTP verb.
-message CustomHttpPattern {
-  // The name of this custom HTTP verb.
-  string kind = 1;
-
-  // The path matched by this custom verb.
-  string path = 2;
-}
diff --git a/python/ofagent/utils.py b/python/ofagent/utils.py
deleted file mode 100755
index 7e72bef..0000000
--- a/python/ofagent/utils.py
+++ /dev/null
@@ -1,31 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""
-Common utility functions
-"""
-
-from loxi.pp import PrettyPrinter
-
-
-def pp(obj):
-    pp = PrettyPrinter(maxwidth=80)
-    pp.pp(obj)
-    return str(pp)
-
-def mac_str_to_tuple(mac):
-    """
-    Convert 'xx:xx:xx:xx:xx:xx' MAC address string to a tuple of integers.
-    Example: mac_str_to_tuple('00:01:02:03:04:05') == (0, 1, 2, 3, 4, 5)
-    """
-    return tuple(int(d, 16) for d in mac.split(':'))
\ No newline at end of file
diff --git a/python/pki/Makefile b/python/pki/Makefile
deleted file mode 100644
index d3d9a18..0000000
--- a/python/pki/Makefile
+++ /dev/null
@@ -1,97 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# VOLTHA pki makefile
-# Configuration is also given in voltha.cnf
-
-SHELL = bash -eu -o pipefail
-
-# parameters
-
-KEY_SIZE ?= 2048
-EXPIRATION_DAYS ?= 366
-
-
-# utility/validation targets
-
-help:
-	@echo "Usually you want to run 'make voltha.crt'"
-
-validate:
-	 openssl verify -verbose -purpose sslserver -CAfile voltha-CA.pem voltha.crt
-
-printca: voltha-CA.pem
-	openssl x509 -in voltha-CA.pem -text -noout
-
-printkey: voltha.key
-	openssl rsa -in voltha.key -check
-
-printcsr: voltha.csr
-	openssl req -in voltha.csr -text -noout -verify
-
-printcrt: voltha.crt
-	openssl x509 -in voltha.crt -text -noout
-
-clean:
-	rm -rf root_ca voltha-CA.pem voltha.key voltha.csr voltha.crt
-
-# CA creation
-
-root_ca:
-	mkdir -p root_ca/private root_ca/newcerts
-	chmod 700 root_ca/private
-	echo 1000 > root_ca/serial
-	touch root_ca/index.txt
-
-root_ca/private/ca_root_phrase: root_ca
-	@echo "TestingVOLTHARootCAPassPhrase" > root_ca/private/ca_root_phrase
-
-root_ca/private/ca_key.pem: root_ca root_ca/private/ca_root_phrase
-	@echo "## Creating CA private key"
-	openssl genrsa -aes256 \
-	  -passout file:root_ca/private/ca_root_phrase \
-	  -out root_ca/private/ca_key.pem $(KEY_SIZE)
-
-voltha-CA.pem: voltha.cnf root_ca/private/ca_key.pem
-	@echo "## Creating self-signed CA public key: voltha-CA.pem"
-	openssl req -config voltha.cnf \
-	  -new -x509 -days $(EXPIRATION_DAYS) -sha256 \
-	  -extensions v3_ca \
-	  -key root_ca/private/ca_key.pem \
-	  -passin file:root_ca/private/ca_root_phrase \
-	  -subj "/C=US/ST=California/L=Menlo Park/O=ONF/OU=Testing Only/CN=VOLTHA Test Root CA" \
-	  -out voltha-CA.pem
-
-# server cert creation
-
-voltha.key:
-	@echo "## Creating server private key: voltha.key"
-	openssl genrsa -out voltha.key $(KEY_SIZE)
-
-voltha.csr: voltha.cnf voltha.key
-	@echo "## Creating signing request voltha.csr from voltha.key"
-	openssl req -config voltha.cnf \
-	  -new -sha256 -key voltha.key \
-	  -subj "/C=US/ST=California/L=Menlo Park/O=ONF/OU=Testing Only/CN=VOLTHA Server" \
-	  -out voltha.csr
-
-voltha.crt: voltha-CA.pem voltha.cnf voltha.key voltha.csr
-	@echo "## Signing voltha.csr to create signed public key: voltha.crt"
-	openssl ca -config voltha.cnf \
-	  -batch -days $(EXPIRATION_DAYS) -md sha256 \
-	  -passin file:root_ca/private/ca_root_phrase \
-	  -extensions server_cert \
-	  -in voltha.csr \
-	  -out voltha.crt
-
diff --git a/python/pki/voltha-CA.pem b/python/pki/voltha-CA.pem
deleted file mode 100644
index a71091b..0000000
--- a/python/pki/voltha-CA.pem
+++ /dev/null
@@ -1,23 +0,0 @@
------BEGIN CERTIFICATE-----
-MIID2jCCAsKgAwIBAgIJAPp3/HUhTzcGMA0GCSqGSIb3DQEBCwUAMHoxCzAJBgNV
-BAYTAlVTMRMwEQYDVQQIDApDYWxpZm9ybmlhMRMwEQYDVQQHDApNZW5sbyBQYXJr
-MQwwCgYDVQQKDANPTkYxFTATBgNVBAsMDFRlc3RpbmcgT25seTEcMBoGA1UEAwwT
-Vk9MVEhBIFRlc3QgUm9vdCBDQTAeFw0xODA3MTAxODQwMDVaFw0xOTA3MTExODQw
-MDVaMHoxCzAJBgNVBAYTAlVTMRMwEQYDVQQIDApDYWxpZm9ybmlhMRMwEQYDVQQH
-DApNZW5sbyBQYXJrMQwwCgYDVQQKDANPTkYxFTATBgNVBAsMDFRlc3RpbmcgT25s
-eTEcMBoGA1UEAwwTVk9MVEhBIFRlc3QgUm9vdCBDQTCCASIwDQYJKoZIhvcNAQEB
-BQADggEPADCCAQoCggEBAMEawmybBpHIWVLGm9gqnfg4IpNNczCAeOB2w5UqsqIR
-mHMSa/f+wjDRztHhp+6FQfqN1ycWmrUAPyfYn63laRPM2VlnNOa0g8iS0uif2AaY
-3ms7PbjDNug2jtj/P7PNikHrd6cW/lWEXPhgGSWscNtlFvAjVwTs9pO6nELtw6XW
-wEgF40XB8UnwatD3J61G0TfcDlJMg0qMiTsnQzgrb6hUSI7IRSUKypFRii5lXts1
-Zt3VYz2yViMDat18ICz+oiVE3EL6YfTebM27m9UhhQn4BnBxwU18zcACz1SHGOPg
-+hGFbO5NsXnVabvyNNuHabb4lDCYwcL8xGaPeqtm3jsCAwEAAaNjMGEwHQYDVR0O
-BBYEFBbNGGwDeW6Zmz9tF/QhGiExBmpnMB8GA1UdIwQYMBaAFBbNGGwDeW6Zmz9t
-F/QhGiExBmpnMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgGGMA0GCSqG
-SIb3DQEBCwUAA4IBAQByQh5RKK5j01jjeBkCV0eonlMMWMKDIemKQLN6zlU3wvTV
-7++F1FT3IOhM3Oe/kS3JF7mG/jIhQuiycbIvmth/eUdPNJpePTHSilYVHLPXVMl2
-YUfkMyj5aRZCzSdzPfWEkJu/PceyBJP7vjnpOYOraqf6lU6sXBuTLVWRZADEQ9b4
-0oKa59pzOxFdtdDU5Pfnj/Vzaxsw8bpt/JINQb6VIqd71TASAdsuoQZXdYy7rvkl
-29M1gv2bTLxU7jE+5jIgfPtOde6cJeeuSNhKqaFJxTrbZFj4ZgQ4zXsr6QzO/hbV
-kLN8QechIcnf6F4tOTWEiPhs3yIE/947tFT3ZLcx
------END CERTIFICATE-----
diff --git a/python/pki/voltha.cnf b/python/pki/voltha.cnf
deleted file mode 100644
index 7552010..0000000
--- a/python/pki/voltha.cnf
+++ /dev/null
@@ -1,89 +0,0 @@
-# Copyright 2017-present Open Networking Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-[ ca ]
-default_ca  = CA_default
-
-[ CA_default ]
-dir               = ./root_ca
-certs             = $dir/certs
-crl_dir           = $dir/crl
-new_certs_dir     = $dir/newcerts
-database          = $dir/index.txt
-serial            = $dir/serial
-
-private_key       = $dir/private/ca_key.pem
-certificate       = voltha-CA.pem
-
-# Make new requests easier to sign - allow two subjects with same name
-# (Or revoke the old certificate first.)
-unique_subject    = no
-preserve          = no
-
-# for CA that signs client certs
-policy            = policy_loose
-
-[ policy_loose ]
-# Allow the to sign more types of certs
-countryName             = optional
-stateOrProvinceName     = optional
-localityName            = optional
-organizationName        = optional
-organizationalUnitName  = optional
-commonName              = supplied
-emailAddress            = optional
-
-[ req ]
-default_bits         = 2048
-default_days         = 366
-default_md           = sha256
-distinguished_name   = req_distinguished_name
-string_mask          = utf8only
-x509_extensions      = v3_ca
-
-[ req_distinguished_name ]
-# See <https://en.wikipedia.org/wiki/Certificate_signing_request>.
-countryName                     = Country Name (2 letter code)
-stateOrProvinceName             = State or Province Name
-localityName                    = Locality Name
-0.organizationName              = Organization Name
-organizationalUnitName          = Organizational Unit Name
-commonName                      = Common Name
-emailAddress                    = Email Address
-
-# Defaults DN
-countryName_default             = US
-stateOrProvinceName_default     = California
-localityName_default            = Menlo Park
-0.organizationName_default      = ONF
-organizationalUnitName_default  = Testing Only
-commonName                      = VOLTHA Testing
-emailAddress_default            = do-not-reply@opencord.org
-
-[ v3_ca ]
-# Extensions for a typical CA (`man x509v3_config`).
-subjectKeyIdentifier = hash
-authorityKeyIdentifier = keyid:always,issuer
-basicConstraints = critical, CA:TRUE
-keyUsage = critical, digitalSignature, cRLSign, keyCertSign
-
-[ server_cert ]
-# Extensions for server certificates (`man x509v3_config`).
-subjectKeyIdentifier = hash
-authorityKeyIdentifier = keyid,issuer:always
-basicConstraints = CA:FALSE
-keyUsage = critical, digitalSignature, keyEncipherment
-extendedKeyUsage = serverAuth
-subjectAltName = 'DNS:voltha.dns'
-
diff --git a/python/pki/voltha.crt b/python/pki/voltha.crt
deleted file mode 100644
index efeef03..0000000
--- a/python/pki/voltha.crt
+++ /dev/null
@@ -1,92 +0,0 @@
-Certificate:
-    Data:
-        Version: 3 (0x2)
-        Serial Number: 4096 (0x1000)
-    Signature Algorithm: sha256WithRSAEncryption
-        Issuer: C=US, ST=California, L=Menlo Park, O=ONF, OU=Testing Only, CN=VOLTHA Test Root CA
-        Validity
-            Not Before: Jul 10 18:40:05 2018 GMT
-            Not After : Jul 11 18:40:05 2019 GMT
-        Subject: C=US, ST=California, L=Menlo Park, O=ONF, OU=Testing Only, CN=VOLTHA Server
-        Subject Public Key Info:
-            Public Key Algorithm: rsaEncryption
-                Public-Key: (2048 bit)
-                Modulus:
-                    00:c6:90:b9:38:0e:d5:38:bd:20:54:8f:82:56:2b:
-                    54:da:16:6f:a2:84:63:99:f8:4b:8c:24:be:c6:17:
-                    ee:ce:b1:e4:27:4c:4f:e0:7b:b9:1c:0c:a7:9d:45:
-                    37:39:1d:b0:41:fb:96:49:f4:02:1c:66:87:3a:87:
-                    e6:59:fc:9d:4d:fb:73:74:50:8a:39:25:5c:7e:8f:
-                    b4:de:3e:d5:10:5e:91:53:da:6a:3e:57:db:18:d8:
-                    da:c6:33:90:ee:0a:6d:4d:e2:e9:cb:1b:21:c8:59:
-                    3e:e6:b2:bd:ee:d2:95:70:f7:0e:98:4e:bc:04:6b:
-                    5b:4f:63:0b:25:d8:0e:4f:10:f8:30:92:19:a8:1b:
-                    a1:3a:be:51:73:24:bc:0f:f0:4c:26:8f:df:2a:a8:
-                    cc:d8:38:7e:ad:d0:f5:cc:e9:e9:76:d8:3e:ff:55:
-                    94:23:69:74:8f:d2:00:51:c5:d6:56:61:09:0f:5e:
-                    70:4c:5f:5e:d6:a4:47:58:ff:73:40:c5:5e:e0:14:
-                    73:6c:8b:4d:54:e2:fc:d7:94:60:64:9b:db:2a:d6:
-                    38:a0:d3:ae:2e:47:d3:74:3c:0f:c0:fe:c6:af:af:
-                    a0:08:1f:20:a8:3a:a7:74:58:af:94:35:66:4b:7c:
-                    97:26:1b:03:23:0f:3d:0a:9d:ea:9b:06:d4:96:ca:
-                    5c:4d
-                Exponent: 65537 (0x10001)
-        X509v3 extensions:
-            X509v3 Subject Key Identifier: 
-                F9:71:CB:9B:DC:B0:AB:C3:70:04:1B:9E:63:D0:21:01:CE:35:FF:19
-            X509v3 Authority Key Identifier: 
-                keyid:16:CD:18:6C:03:79:6E:99:9B:3F:6D:17:F4:21:1A:21:31:06:6A:67
-                DirName:/C=US/ST=California/L=Menlo Park/O=ONF/OU=Testing Only/CN=VOLTHA Test Root CA
-                serial:FA:77:FC:75:21:4F:37:06
-
-            X509v3 Basic Constraints: 
-                CA:FALSE
-            X509v3 Key Usage: critical
-                Digital Signature, Key Encipherment
-            X509v3 Extended Key Usage: 
-                TLS Web Server Authentication
-            X509v3 Subject Alternative Name: 
-                DNS:voltha.dns
-    Signature Algorithm: sha256WithRSAEncryption
-         12:3e:b8:73:d1:ab:77:ec:7a:b0:d8:8e:94:8e:3c:fd:ff:b0:
-         25:bf:e8:51:d7:b9:ae:55:03:28:cb:a2:9b:fb:86:9c:35:55:
-         2b:c8:0c:c6:a9:b4:41:a3:12:d3:26:c9:33:93:4a:a1:7c:ad:
-         06:eb:d5:d0:a4:63:e1:ad:7f:76:d7:7b:2b:44:ab:43:2b:26:
-         84:a2:d6:5d:68:fc:bb:1b:15:3e:63:32:34:e8:1a:a4:d9:81:
-         4b:28:17:e8:f7:1d:3a:d5:cb:37:87:77:04:3f:96:6d:17:e6:
-         1e:90:0e:a8:6c:01:58:84:d4:1a:b4:9f:51:79:9c:03:23:1b:
-         b6:97:0c:28:a4:af:67:0b:da:b2:fa:6e:41:49:00:8a:36:11:
-         f8:80:50:61:03:c3:b5:df:f7:e5:ea:4b:9c:3f:68:68:e0:f8:
-         78:f1:1d:ff:0b:23:45:2a:d6:19:a8:f6:b9:19:25:e0:46:ce:
-         8b:56:ca:e5:da:2a:35:65:b8:e2:8d:6d:46:1e:9f:f3:4b:4d:
-         7a:c0:f5:48:71:42:f6:95:f9:e5:c9:61:8f:7a:96:63:88:64:
-         68:55:3e:d6:c6:c0:e2:cd:c9:03:93:87:4e:6f:c4:b4:fb:c3:
-         c4:ec:93:ad:88:28:17:fc:77:b8:a2:99:f6:26:ca:6f:36:2d:
-         26:4f:d3:44
------BEGIN CERTIFICATE-----
-MIIEhTCCA22gAwIBAgICEAAwDQYJKoZIhvcNAQELBQAwejELMAkGA1UEBhMCVVMx
-EzARBgNVBAgMCkNhbGlmb3JuaWExEzARBgNVBAcMCk1lbmxvIFBhcmsxDDAKBgNV
-BAoMA09ORjEVMBMGA1UECwwMVGVzdGluZyBPbmx5MRwwGgYDVQQDDBNWT0xUSEEg
-VGVzdCBSb290IENBMB4XDTE4MDcxMDE4NDAwNVoXDTE5MDcxMTE4NDAwNVowdDEL
-MAkGA1UEBhMCVVMxEzARBgNVBAgMCkNhbGlmb3JuaWExEzARBgNVBAcMCk1lbmxv
-IFBhcmsxDDAKBgNVBAoMA09ORjEVMBMGA1UECwwMVGVzdGluZyBPbmx5MRYwFAYD
-VQQDDA1WT0xUSEEgU2VydmVyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC
-AQEAxpC5OA7VOL0gVI+CVitU2hZvooRjmfhLjCS+xhfuzrHkJ0xP4Hu5HAynnUU3
-OR2wQfuWSfQCHGaHOofmWfydTftzdFCKOSVcfo+03j7VEF6RU9pqPlfbGNjaxjOQ
-7gptTeLpyxshyFk+5rK97tKVcPcOmE68BGtbT2MLJdgOTxD4MJIZqBuhOr5RcyS8
-D/BMJo/fKqjM2Dh+rdD1zOnpdtg+/1WUI2l0j9IAUcXWVmEJD15wTF9e1qRHWP9z
-QMVe4BRzbItNVOL815RgZJvbKtY4oNOuLkfTdDwPwP7Gr6+gCB8gqDqndFivlDVm
-S3yXJhsDIw89Cp3qmwbUlspcTQIDAQABo4IBGTCCARUwHQYDVR0OBBYEFPlxy5vc
-sKvDcAQbnmPQIQHONf8ZMIGsBgNVHSMEgaQwgaGAFBbNGGwDeW6Zmz9tF/QhGiEx
-BmpnoX6kfDB6MQswCQYDVQQGEwJVUzETMBEGA1UECAwKQ2FsaWZvcm5pYTETMBEG
-A1UEBwwKTWVubG8gUGFyazEMMAoGA1UECgwDT05GMRUwEwYDVQQLDAxUZXN0aW5n
-IE9ubHkxHDAaBgNVBAMME1ZPTFRIQSBUZXN0IFJvb3QgQ0GCCQD6d/x1IU83BjAJ
-BgNVHRMEAjAAMA4GA1UdDwEB/wQEAwIFoDATBgNVHSUEDDAKBggrBgEFBQcDATAV
-BgNVHREEDjAMggp2b2x0aGEuZG5zMA0GCSqGSIb3DQEBCwUAA4IBAQASPrhz0at3
-7Hqw2I6Ujjz9/7Alv+hR17muVQMoy6Kb+4acNVUryAzGqbRBoxLTJskzk0qhfK0G
-69XQpGPhrX9213srRKtDKyaEotZdaPy7GxU+YzI06Bqk2YFLKBfo9x061cs3h3cE
-P5ZtF+YekA6obAFYhNQatJ9ReZwDIxu2lwwopK9nC9qy+m5BSQCKNhH4gFBhA8O1
-3/fl6kucP2ho4Ph48R3/CyNFKtYZqPa5GSXgRs6LVsrl2io1ZbjijW1GHp/zS016
-wPVIcUL2lfnlyWGPepZjiGRoVT7WxsDizckDk4dOb8S0+8PE7JOtiCgX/He4opn2
-JspvNi0mT9NE
------END CERTIFICATE-----
diff --git a/python/pki/voltha.key b/python/pki/voltha.key
deleted file mode 100644
index 614efa1..0000000
--- a/python/pki/voltha.key
+++ /dev/null
@@ -1,27 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-MIIEpgIBAAKCAQEAxpC5OA7VOL0gVI+CVitU2hZvooRjmfhLjCS+xhfuzrHkJ0xP
-4Hu5HAynnUU3OR2wQfuWSfQCHGaHOofmWfydTftzdFCKOSVcfo+03j7VEF6RU9pq
-PlfbGNjaxjOQ7gptTeLpyxshyFk+5rK97tKVcPcOmE68BGtbT2MLJdgOTxD4MJIZ
-qBuhOr5RcyS8D/BMJo/fKqjM2Dh+rdD1zOnpdtg+/1WUI2l0j9IAUcXWVmEJD15w
-TF9e1qRHWP9zQMVe4BRzbItNVOL815RgZJvbKtY4oNOuLkfTdDwPwP7Gr6+gCB8g
-qDqndFivlDVmS3yXJhsDIw89Cp3qmwbUlspcTQIDAQABAoIBAQCjM4YYbhCP7too
-xj8A5eJ60V/1ukxG2430ZKssE7WiyxFTv2QThH0Tcc898wq9dgpNYSQYKmalwxs4
-X0RUB82er6IoIp5I880+9Ixa8leaea+GtQkHrpwUov/FUdK343gNQQiZd/ZfPgL2
-CEkVhp1vWI/1XRkppLdK24PpGdhA4KXOKJTXrNCf4p7oJz+rEQrGuWrmHcoQV6Kc
-TrBMFvRRTaL6C2f+Nww8HMtpJjCCgMYNkHLH4sL2SbPiORwBJdXq+ajYfxqL6Swx
-DGUJqBJs8m1DDIAFDiDGhDiwLDBA/as8Ii1+wpayPfa5ulUvh3EkTyku9SXbJxJg
-7SBrzwVhAoGBAOno5coqNebro27vEKLnZX/Ttw1DWfklNuvF1e+O2nlttDL0K27p
-fMK2SAcIPz0RDFpt0kNuzMTkblvXseKZgnnYdVeDM0jIjfSDYyi6aI62UiTIb+m1
-mHljCBXu/V9kxNgcvt7R4rPStVtzvAI+I4kNxibh5O2XYw1MwsPdIDV1AoGBANlR
-UuZA1SKLgUMV5dFuJ7w31QY93AHq+XYbBbXM85IyQr4u05S6tgEQ0kI4odGP9boU
-GP5qoy3hem2c/K8QbZeGYD83zhsguEkq+FBavtqxCCIFJDvtCu+Hg8uQ4YGxTtdx
-Q9G6XBbL/reJ9o5ptRTm6FO/ya5Q1x5g7okV8bh5AoGBAI+g9MjolmSPOLG7limR
-kN+m7vXz72FvGoQ33J/Wxgxd8pJ/H9RhBrzBFQVMaRhkSYOVf9DsTkxwP9uhXJdZ
-z6Zl5dewtmLw00nbC55MqDtJdLMlaKLHYTLYPnTJZUeYJs7VB9bmZiApODdJn554
-7XUQwiXJ+7pwhN/7zHRcaZSpAoGBALhgghguu2YCvFnhk0m7zuSm7grMowPRi3ND
-+/VB/Ql1sSDQc9zFCLQgxHNAvzIglNgaQxZf/TBpFEk5nz0ckA62CKS6QRjNCu2x
-ElqCk1jSSFcsy5A4TkXpUM1+j4VMnNq3E1Y2aflBfEvWNqSfVO519nlPx9ooZks0
-7EzMnHfpAoGBAOWg98M+I/FqziskKlB9QWTnFww/lGTTAGgOBHic0BJElzxiTVrx
-ZtnUCwlPi0fWSdrkWRcNYIMtfcDVA2Ifb9xhDHZLzfxznylhKiKrBSqAnQXjpkF7
-GGJLwMEzAjeb45HxydWoHWa0OaB1T9ZngAJs7mxFWYiPpS9ToO62L/IT
------END RSA PRIVATE KEY-----
diff --git a/python/requirements.txt b/python/requirements.txt
deleted file mode 100644
index 9a0ca56..0000000
--- a/python/requirements.txt
+++ /dev/null
@@ -1,2 +0,0 @@
-voltha-protos==1.0.0
-pyvoltha==0.2.2