diff --git a/libasn1fix/asn1fix_param.c b/libasn1fix/asn1fix_param.c
index a4d9690..bbd7cf4 100644
--- a/libasn1fix/asn1fix_param.c
+++ b/libasn1fix/asn1fix_param.c
@@ -1,306 +1,217 @@
 #include "asn1fix_internal.h"
 
-static int asn1f_parametrize(arg_t *arg, asn1p_expr_t *ex, asn1p_expr_t *ptype);
-static int asn1f_param_process_recursive(arg_t *arg, asn1p_expr_t *expr, asn1p_expr_t *ptype, asn1p_expr_t *actargs);
-static int asn1f_param_process_constraints(arg_t *arg, asn1p_expr_t *expr, asn1p_expr_t *ptype, asn1p_expr_t *actargs);
+typedef struct resolver_arg {
+	asn1p_expr_t	  *(*resolver)(asn1p_expr_t *, void *arg);
+	arg_t		  *arg;
+	asn1p_expr_t	  *original_expr;
+	asn1p_paramlist_t *lhs_params;
+	asn1p_expr_t	  *rhs_pspecs;
+} resolver_arg_t;
 
-static asn1p_expr_t *_referenced_argument(asn1p_ref_t *ref, asn1p_expr_t *ptype, asn1p_expr_t *actargs);
-static int _process_constraints(arg_t *arg, asn1p_constraint_t *ct, asn1p_expr_t *ptype, asn1p_expr_t *actargs);
+static asn1p_expr_t *resolve_expr(asn1p_expr_t *, void *resolver_arg);
+static int compare_specializations(arg_t *, asn1p_expr_t *a, asn1p_expr_t *b);
+static asn1p_expr_t *find_target_specialization_byref(resolver_arg_t *rarg, asn1p_ref_t *ref);
+static asn1p_expr_t *find_target_specialization_bystr(resolver_arg_t *rarg, char *str);
 
-int
-asn1f_fix_parametrized_assignment(arg_t *arg) {
-	asn1p_expr_t *expr = arg->expr;
-	asn1p_expr_t *ptype;
-
-	assert(expr->expr_type == A1TC_PARAMETRIZED);
-	assert(expr->reference);
-
-	DEBUG("(\"%s\" ::= \"%s\" { %s }) for line %d",
-		expr->Identifier,
-		asn1f_printable_reference(expr->reference),
-		asn1f_printable_value(expr->value),
-		expr->_lineno);
-
-	/*
-	 * Find the corresponding parametrized type definition.
-	 */
-	DEBUG("Looking for parametrized type definition \"%s\"",
-		asn1f_printable_reference(expr->reference));
-	ptype = asn1f_lookup_symbol(arg, expr->module, expr->reference);
-	if(ptype == NULL) {
-		DEBUG("%s: missing parametrized type declaration",
-			asn1f_printable_reference(expr->reference));
-		return -1;
-	}
-
-	/*
-	 * Check that the number of arguments which are expected by
-	 * the parametrized type declaration is consistent with the
-	 * number of arguments supplied by the parametrized assignment.
-	 */
-	if(asn1f_count_children(expr) != ptype->params->params_count) {
-		FATAL("Number of actual arguments %d in %s at line %d "
-			"is not equal to number of expected arguments "
-			"%d in %s at line %d",
-			asn1f_count_children(expr),
-			asn1f_printable_reference(expr->reference),
-			expr->_lineno,
-			ptype->params->params_count,
-			ptype->Identifier,
-			ptype->_lineno
-		);
-		return -1;
-	}
-
-	/*
-	 * Perform an expansion of a parametrized assignment.
-	 */
-	return asn1f_parametrize(arg, expr, ptype);
-}
-
-#define	SUBSTITUTE(to, from)	do {				\
-	asn1p_expr_t tmp, *__v;					\
-	if((to)->tag.tag_class					\
-	&& (from)->tag.tag_class) {				\
-		FATAL("Layered tagging in parametrization "	\
-		"is not yet supported, "			\
-		"contact asn1c author for assistance "		\
-		"with line %d", (to)->_lineno);			\
-		return -1;					\
-	}							\
-	/* This code shall not be invoked too early */		\
-	assert((to)->combined_constraints == NULL);		\
-	assert((from)->combined_constraints == NULL);		\
-	/* Copy stuff, and merge some parameters */		\
-	tmp = *(to);						\
-	*(to) = *(from);					\
-	TQ_MOVE(&(to)->members, &(from)->members);		\
-	*(from) = tmp;						\
-	(to)->next = tmp.next;					\
-	(to)->parent_expr = tmp.parent_expr;			\
-	assert((to)->marker.flags == EM_NOMARK);		\
-	(to)->marker = tmp.marker;				\
-	if(tmp.tag.tag_class)					\
-		(to)->tag = tmp.tag;				\
-	if(tmp.constraints) {					\
-		if((to)->constraints) {				\
-			asn1p_constraint_t *ct;			\
-			ct = asn1p_constraint_new(		\
-				(to)->constraints->_lineno);	\
-			ct->type = ACT_CA_SET;			\
-			asn1p_constraint_insert(ct,		\
-				(to)->constraints);		\
-			asn1p_constraint_insert(ct,		\
-				tmp.constraints);		\
-			(to)->constraints = ct;			\
-		} else {					\
-			(to)->constraints = tmp.constraints;	\
-		}						\
-	}							\
-	(from)->constraints = 0;				\
-	(from)->marker.default_value = 0;			\
-	memset(&((from)->next), 0, sizeof((from)->next));	\
-	memset(&((from)->members), 0, sizeof((from)->members));	\
-	asn1p_expr_free(from);					\
-	TQ_FOR(__v, &((to)->members), next) {			\
-		assert(__v->parent_expr == (from));		\
-		__v->parent_expr = (to);			\
-	}							\
-} while(0)
-
-static int
-asn1f_parametrize(arg_t *arg, asn1p_expr_t *expr, asn1p_expr_t *ptype) {
-	asn1p_expr_t *nex;
+asn1p_expr_t *
+asn1f_parameterization_fork(arg_t *arg, asn1p_expr_t *expr, asn1p_expr_t *rhs_pspecs) {
+	resolver_arg_t rarg;	/* resolver argument */
+	asn1p_expr_t *exc;	/* expr clone */
+	asn1p_expr_t *rpc;	/* rhs_pspecs clone */
+	asn1p_expr_t *target;
 	void *p;
-	int ret;
+	struct asn1p_pspec_s *pspec;
+	int npspecs;
+	int i;
 
-	DEBUG("asn1f_parametrize(%s <= %s)",
-		expr->Identifier, ptype->Identifier);
+	assert(rhs_pspecs);
+	assert(expr->lhs_params);
+	assert(expr->parent_expr == 0);
+
+	DEBUG("Forking parameterization at %d for %s (%d alr)",
+		rhs_pspecs->_lineno, expr->Identifier,
+		expr->specializations.pspecs_count);
 
 	/*
-	 * The algorithm goes like that:
-	 * 1. Replace the expression's type with parametrized type.
-	 * 2. For every child in the parametrized type, import it
-	 * as a child of the expression, replacing all occurences of
-	 * symbols which are defined as parametrized type arguments
-	 * with the actual values.
-	 * 3. Don't forget to parametrize the subtype constraints.
+	 * Find if this exact specialization has been used already.
 	 */
-
-	nex = asn1p_expr_clone(ptype, 0);
-	if(nex == NULL) return -1;
-
-	/*
-	 * Cleanup the new expression so there is no ptype-related
-	 * stuff hanging around.
-	 */
-	if(expr->Identifier) {
-		p = strdup(expr->Identifier);
-		if(p) {
-			free(nex->Identifier);
-			nex->Identifier = p;
-		} else {
-			asn1p_expr_free(nex);
-			return -1;
+	for(npspecs = 0;
+		npspecs < expr->specializations.pspecs_count;
+			npspecs++) {
+		if(compare_specializations(arg, rhs_pspecs,
+			expr->specializations.pspec[npspecs].rhs_pspecs) == 0) {
+			DEBUG("Reused parameterization for %s",
+				expr->Identifier);
+			return expr->specializations.pspec[npspecs].my_clone;
 		}
 	}
-	asn1p_paramlist_free(nex->params);
-	nex->params = NULL;
-	nex->meta_type = expr->meta_type;
 
-	ret = asn1f_param_process_recursive(arg, nex, ptype, expr);
-	if(ret != 0) {
-		asn1p_expr_free(nex);
-		return ret;
+	rarg.resolver = resolve_expr;
+	rarg.arg = arg;
+	rarg.original_expr = expr;
+	rarg.lhs_params = expr->lhs_params;
+	rarg.rhs_pspecs = rhs_pspecs;
+	exc = asn1p_expr_clone_with_resolver(expr, resolve_expr, &rarg);
+	rpc = asn1p_expr_clone(rhs_pspecs, 0);
+	assert(exc && rpc);
+
+	/*
+	 * Create a new specialization.
+	 */
+	npspecs = expr->specializations.pspecs_count;
+	p = realloc(expr->specializations.pspec,
+			(npspecs + 1) * sizeof(expr->specializations.pspec[0]));
+	assert(p);
+	expr->specializations.pspec = p;
+	pspec = &expr->specializations.pspec[npspecs];
+	memset(pspec, 0, sizeof *pspec);
+
+	pspec->rhs_pspecs = rpc;
+	pspec->my_clone = exc;
+	exc->spec_index = npspecs;
+
+	/* Update LHS->RHS specialization in target */
+	target = TQ_FIRST(&rpc->members);
+	for(i = 0; i < exc->lhs_params->params_count;
+			i++, target = TQ_NEXT(target, next)) {
+		if(!target) { target = (void *)0xdeadbeef; break; }
+
+		assert(exc->lhs_params->params[i].into_expr == 0);
+		exc->lhs_params->params[i].into_expr = target;
+	}
+	if(target) {
+		asn1p_expr_free(exc);
+		asn1p_expr_free(rpc);
+		FATAL("Parameterization of %s failed: "
+			"parameters number mismatch", expr->Identifier);
+		errno = EPERM;
+		return NULL;
 	}
 
-	SUBSTITUTE(expr, nex);
+	DEBUG("Forked new parameterization for %s", expr->Identifier);
 
-	return ret;
+	/* Commit */
+	expr->specializations.pspecs_count = npspecs + 1;
+	return exc;
 }
 
 static int
-asn1f_param_process_recursive(arg_t *arg, asn1p_expr_t *expr, asn1p_expr_t *ptype, asn1p_expr_t *actargs) {
-	asn1p_expr_t *child;
+compare_specializations(arg_t *arg, asn1p_expr_t *a, asn1p_expr_t *b) {
+	asn1p_expr_t *ac = TQ_FIRST(&a->members);
+	asn1p_expr_t *bc = TQ_FIRST(&b->members);
 
+	for(;ac && bc; ac = TQ_NEXT(ac, next), bc = TQ_NEXT(bc, next)) {
+	  retry:
+		if(ac == bc) continue;
+		if(ac->meta_type != bc->meta_type) break;
+		if(ac->expr_type != bc->expr_type) break;
 
-	TQ_FOR(child, &(expr->members), next) {
-		asn1p_expr_t *ra;
-		asn1p_expr_t *ne;	/* new expression (clone) */
+		if(!ac->reference && !bc->reference)
+			continue;
 
-		if(asn1f_param_process_constraints(arg, child, ptype, actargs))
-			return -1;
-
-		ra = _referenced_argument(child->reference, ptype, actargs);
-		if(ra) {
-			DEBUG("Substituting parameter for %s %s at line %d",
-				child->Identifier,
-				asn1f_printable_reference(child->reference),
-				child->_lineno
-			);
-	
-			assert(child->meta_type == AMT_TYPEREF);
-			assert(child->expr_type == A1TC_REFERENCE);
-	
-			ne = asn1p_expr_clone(ra, 0);
-			if(ne == NULL) return -1;
-			assert(ne->Identifier == 0);
-			ne->Identifier = strdup(child->Identifier);
-			if(ne->Identifier == 0) {
-				asn1p_expr_free(ne);
-				return -1;
-			}
-			SUBSTITUTE(child, ne);
+		if(ac->reference) {
+			ac = asn1f_lookup_symbol(arg,
+				ac->module, ac->rhs_pspecs, ac->reference);
+			if(!ac) break;
 		}
+		if(bc->reference) {
+			bc = asn1f_lookup_symbol(arg,
+				bc->module, bc->rhs_pspecs, bc->reference);
+			if(!bc) break;
+		}
+	  goto retry;
 	}
 
+	if(ac || bc)
+		/* Specializations do not match: different size option sets */
+		return -1;
+
 	return 0;
 }
 
-/*
- * Check that the given ref looks like an argument of a parametrized type.
- */
 static asn1p_expr_t *
-_referenced_argument(asn1p_ref_t *ref, asn1p_expr_t *ptype, asn1p_expr_t *actargs) {
-	asn1p_expr_t *aa;
-	int i;
+resolve_expr(asn1p_expr_t *expr_to_resolve, void *resolver_arg) {
+	resolver_arg_t *rarg = resolver_arg;
+	arg_t *arg = rarg->arg;
+	asn1p_expr_t *expr;
+	asn1p_expr_t *nex;
 
-	if(ref == NULL || ref->comp_count != 1)
+	DEBUG("Resolving %s (meta %d)",
+		expr_to_resolve->Identifier, expr_to_resolve->meta_type);
+
+	if(expr_to_resolve->meta_type == AMT_TYPEREF) {
+		expr = find_target_specialization_byref(rarg,
+				expr_to_resolve->reference);
+		if(!expr) return NULL;
+	} else if(expr_to_resolve->meta_type == AMT_VALUE) {
+		assert(expr_to_resolve->value);
+		expr = find_target_specialization_bystr(rarg,
+				expr_to_resolve->Identifier);
+		if(!expr) return NULL;
+	} else {
+		errno = ESRCH;
 		return NULL;
+	}
 
-	aa = TQ_FIRST(&(actargs->members));
-	for(i = 0; i < ptype->params->params_count;
-				i++, aa = TQ_NEXT(aa, next)) {
-		if(strcmp(ref->components[0].name,
-			ptype->params->params[i].argument) == 0)
-			return aa;
+	DEBUG("Found target %s", expr->Identifier);
+	if(expr->meta_type == AMT_TYPE
+	|| expr->meta_type == AMT_VALUE) {
+		DEBUG("Target is a simple type %s",
+			ASN_EXPR_TYPE2STR(expr->expr_type));
+		nex = asn1p_expr_clone(expr, 0);
+		free(nex->Identifier);
+		nex->Identifier = expr_to_resolve->Identifier
+			? strdup(expr_to_resolve->Identifier) : 0;
+		return nex;
+	} else {
+		FATAL("Feature not implemented for %s",
+			rarg->original_expr->Identifier);
+		errno = EPERM;
+		return NULL;
 	}
 
 	return NULL;
 }
 
-/*
- * Search for parameters inside constraints.
- */
-static int
-asn1f_param_process_constraints(arg_t *arg, asn1p_expr_t *expr, asn1p_expr_t *ptype, asn1p_expr_t *actargs) {
-	asn1p_constraint_t *cts;
-	int ret;
+static asn1p_expr_t *
+find_target_specialization_byref(resolver_arg_t *rarg, asn1p_ref_t *ref) {
+	char *refstr;
 
-	if(!expr->constraints) return 0;
-
-	cts = asn1p_constraint_clone(expr->constraints);
-	assert(cts);
-
-	ret = _process_constraints(arg, cts, ptype, actargs);
-	if(ret == 1) {
-		asn1p_constraint_free(expr->constraints);
-		expr->constraints = cts;
-		ret = 0;
-	} else {
-		asn1p_constraint_free(cts);
+	if(!ref || ref->comp_count != 1) {
+		errno = ESRCH;
+		return NULL;
 	}
 
-	return ret;
+	refstr = ref->components[0].name;	/* T */
+
+	return find_target_specialization_bystr(rarg, refstr);
 }
 
-static int
-_process_constraints(arg_t *arg, asn1p_constraint_t *ct, asn1p_expr_t *ptype, asn1p_expr_t *actargs) {
-	asn1p_value_t *values[3];
-	int rvalue = 0;
-	size_t i;
+static asn1p_expr_t *
+find_target_specialization_bystr(resolver_arg_t *rarg, char *refstr) {
+	arg_t *arg = rarg->arg;
+	asn1p_expr_t *target;
+	int i;
 
-	values[0] = ct->value;
-	values[1] = ct->range_start;
-	values[2] = ct->range_stop;
+	target = TQ_FIRST(&rarg->rhs_pspecs->members);
+	for(i = 0; i < rarg->lhs_params->params_count;
+			i++, target = TQ_NEXT(target, next)) {
+		struct asn1p_param_s *param = &rarg->lhs_params->params[i];
+		if(!target) break;
 
-	for(i = 0; i < sizeof(values)/sizeof(values[0]); i++) {
-		asn1p_value_t *v = values[i];
-		asn1p_expr_t *ra;
-		asn1p_ref_t *ref;
-		char *str;
+		if(strcmp(param->argument, refstr))
+			continue;
 
-		if(!v || v->type != ATV_REFERENCED) continue;
-
-		ref = v->value.reference;
-		ra = _referenced_argument(ref, ptype, actargs);
-		if(!ra) continue;
-
-		DEBUG("_process_constraints(%s), ra=%s",
-			asn1f_printable_reference(ref), ra->Identifier);
-
-		if(ra->expr_type == A1TC_PARAMETRIZED) {
-			DEBUG("Double %s", "parametrization");
-		}
-
-		assert(ra->Identifier);
-		str = strdup(ra->Identifier);
-		if(!str) return -1;
-
-		assert(ref->comp_count == 1);
-		ref = asn1p_ref_new(ref->_lineno);
-		if(!ref) { free(str); return -1; }
-
-		if(asn1p_ref_add_component(ref, str, 0)) {
-			free(str);
-			return -1;
-		}
-
-		asn1p_ref_free(v->value.reference);
-		v->value.reference = ref;
-		rvalue = 1;
+		return target;
+	}
+	if(i != rarg->lhs_params->params_count) {
+		FATAL("Parameterization of %s failed: "
+			"parameters number mismatch",
+				rarg->original_expr->Identifier);
+		errno = EPERM;
+		return NULL;
 	}
 
-	/* Process the rest of constraints recursively */
-	for(i = 0; i < ct->el_count; i++) {
-		int ret = _process_constraints(arg, ct->elements[i],
-			ptype, actargs);
-		if(ret == -1)
-			rvalue = -1;
-		else if(ret == 1 && rvalue != -1)
-			rvalue = 1;
-	}
-
-	return rvalue;
+	errno = ESRCH;
+	return NULL;
 }
-