diff --git a/gen/argument_info.go b/gen/argument_info.go
index d4e572c..97d4ee5 100644
--- a/gen/argument_info.go
+++ b/gen/argument_info.go
@@ -9,7 +9,7 @@ type ArgumentInfo interface {
 	GetType() *ReferencedTypeInfo
 
 	// The location where the argument appears in the source code.
-	Declaration() core.UnmanagedSourceView
+	Declaration() *core.UnmanagedSourceView
 
 	// Returns the argument string, as it should appear in the code code.
 	String() string
diff --git a/gen/function_generator_test.go b/gen/function_generator_test.go
index 966a7ce..f66d0fd 100644
--- a/gen/function_generator_test.go
+++ b/gen/function_generator_test.go
@@ -39,8 +39,8 @@ func generateFunctionFromSource(
 
 func TestSimpleFunctionGeneration(t *testing.T) {
 	src := `func $32 @add $32 %a {
-	%b = ADD %a $32 #1
-	%c = ADD %b %a
+	$32 %b = ADD %a $32 #1
+	$32 %c = ADD %b %a
 	RET
 }`
 
@@ -82,7 +82,10 @@ func TestSimpleFunctionGeneration(t *testing.T) {
 
 	assert.EqualValues(t,
 		[]gen.ReferencedTypeInfo{
-			{Base: &gen.NamedTypeInfo{Name: "$32", Size: 4}, Descriptors: []gen.TypeDescriptorInfo{}},
+			{
+				Base:        &gen.NamedTypeInfo{Name: "$32", Size: 4},
+				Descriptors: []gen.TypeDescriptorInfo{},
+			},
 		},
 		function.Targets,
 	)
@@ -94,10 +97,10 @@ func TestIfElseFunctionGeneration(t *testing.T) {
 	src := `func @toBool $32 %n {
 	JZ %n .zero
 .nonzero
-	%bool = ADD $32 #1 $32 #0
+	$32 %bool = ADD $32 #1 $32 #0
 	JMP .end
 .zero
-	%bool = ADD $32 #0 $32 #0
+	$32 %bool = ADD $32 #0 $32 #0
 .end
 	RET
 }`
@@ -132,7 +135,7 @@ func TestEmptyFunctionGeneration(t *testing.T) {
 
 func TestNoReturnFunctionGeneration(t *testing.T) {
 	src := `func @noReturn {
-				%n = ADD $32 #1 $32 #2
+				$32 %n = ADD $32 #1 $32 #2
 			}`
 	function, results := generateFunctionFromSource(t, src)
 	assert.False(t, results.IsEmpty())
@@ -140,3 +143,16 @@ func TestNoReturnFunctionGeneration(t *testing.T) {
 	details := results.Head.Value
 	assert.Contains(t, details[0].Message, "end a function")
 }
+
+func TestNoExplicitRegisterType(t *testing.T) {
+	src := `func @noExplicitType {
+				%a = ADD $32 #1 $32 #2
+				RET
+			}`
+
+	function, results := generateFunctionFromSource(t, src)
+	assert.False(t, results.IsEmpty())
+	assert.Nil(t, function)
+	details := results.Head.Value
+	assert.Contains(t, details[0].Message, "untyped register")
+}
diff --git a/gen/immediate_info.go b/gen/immediate_info.go
index 71c4357..8c89ef7 100644
--- a/gen/immediate_info.go
+++ b/gen/immediate_info.go
@@ -17,8 +17,8 @@ func (i *ImmediateInfo) GetType() *ReferencedTypeInfo {
 	return &i.Type
 }
 
-func (i *ImmediateInfo) Declaration() core.UnmanagedSourceView {
-	return i.declaration
+func (i *ImmediateInfo) Declaration() *core.UnmanagedSourceView {
+	return &i.declaration
 }
 
 func (i *ImmediateInfo) String() string {
diff --git a/gen/instruction_generator.go b/gen/instruction_generator.go
index 10d6034..eb2e2c8 100644
--- a/gen/instruction_generator.go
+++ b/gen/instruction_generator.go
@@ -8,7 +8,7 @@ import (
 
 type InstructionGenerator struct {
 	ArgumentGenerator InstructionContextGenerator[parse.ArgumentNode, ArgumentInfo]
-	TargetGenerator   InstructionContextGenerator[parse.TargetNode, registerPartialInfo]
+	TargetGenerator   InstructionContextGenerator[parse.TargetNode, *TargetInfo]
 }
 
 func NewInstructionGenerator() FunctionContextGenerator[
@@ -45,23 +45,41 @@ func (g *InstructionGenerator) generateArguments(
 	return arguments, results
 }
 
-func (g *InstructionGenerator) generatePartialTargetsInfo(
+func (g *InstructionGenerator) generateTargets(
 	ctx *InstructionGenerationContext,
 	node parse.InstructionNode,
-) ([]registerPartialInfo, core.ResultList) {
-	targets := make([]registerPartialInfo, len(node.Targets))
+) ([]*TargetInfo, core.ResultList) {
+	targets := make([]*TargetInfo, len(node.Targets))
 	results := core.ResultList{}
 
-	// Different targets should not effect one another.
-	// Thus, we just collect all of the errors along the way, and return
-	// them in one chunk.
 	for i, target := range node.Targets {
-		typeInfo, curResults := g.TargetGenerator.Generate(ctx, target)
+		v := target.View()
+		targetInfo, curResults := g.TargetGenerator.Generate(ctx, target)
 		results.Extend(&curResults)
-		targets[i] = typeInfo
+
+		if targetInfo.Register == nil {
+			// TODO: improve error message
+			results.Append(core.Result{
+				{
+					Type:     core.ErrorResult,
+					Message:  "Undefined or untyped register",
+					Location: &v,
+				},
+				{
+					Type:    core.HintResult,
+					Message: "A register must be defined with an explicit type at least once",
+				},
+			})
+		}
+
+		targets[i] = targetInfo
+	}
+
+	if !results.IsEmpty() {
+		return nil, results
 	}
 
-	return targets, results
+	return targets, core.ResultList{}
 }
 
 func (g *InstructionGenerator) generateLabels(
@@ -87,115 +105,6 @@ func (g *InstructionGenerator) generateLabels(
 	return labels, core.ResultList{}
 }
 
-func partialTargetsToTypes(targets []registerPartialInfo) []*ReferencedTypeInfo {
-	types := make([]*ReferencedTypeInfo, len(targets))
-	for i, target := range targets {
-		types[i] = target.Type
-	}
-	return types
-}
-
-func argumentsToTypes(arguments []ArgumentInfo) []*ReferencedTypeInfo {
-	types := make([]*ReferencedTypeInfo, len(arguments))
-	for i, arg := range arguments {
-		types[i] = arg.GetType()
-	}
-	return types
-}
-
-func (g *InstructionGenerator) getTargetRegister(
-	ctx *InstructionGenerationContext,
-	node parse.TargetNode,
-	targetType ReferencedTypeInfo,
-) (*RegisterInfo, core.ResultList) {
-	registerName := nodeToSourceString(ctx.FileGenerationContext, node.Register)
-	registerInfo := ctx.Registers.GetRegister(registerName)
-	nodeView := node.View()
-
-	if registerInfo == nil {
-		// register is defined here; we should create the register and define
-		// it's type.
-		newRegisterInfo := &RegisterInfo{
-			Name:        registerName,
-			Type:        targetType,
-			Declaration: nodeView,
-		}
-
-		return newRegisterInfo, ctx.Registers.NewRegister(newRegisterInfo)
-	}
-
-	// register is already defined
-	if !registerInfo.Type.Equal(targetType) {
-		// notest: sanity check only
-		return nil, list.FromSingle(core.Result{{
-			Type:     core.InternalErrorResult,
-			Message:  "Internal register type mismatch",
-			Location: &nodeView,
-		}})
-	}
-
-	return registerInfo, core.ResultList{}
-}
-
-// Registers can be defined by being a target of an instruction.
-// After we have determined 100% of the instruction targets types (either
-// if they were explicitly declared or not), we call this function with the
-// target types, and here we iterate over all target types and define missing
-// registers.
-//
-// This also returns the full list of register targets for the provided
-// instruction.
-func (g *InstructionGenerator) defineAndGetTargetRegisters(
-	ctx *InstructionGenerationContext,
-	node parse.InstructionNode,
-	targetTypes []ReferencedTypeInfo,
-) ([]*RegisterArgumentInfo, core.ResultList) {
-	if len(node.Targets) != len(targetTypes) {
-		// notest: sanity check: ensure lengths match.
-		v := node.View()
-		return nil, list.FromSingle(core.Result{{
-			Type:     core.InternalErrorResult,
-			Message:  "Targets length mismatch",
-			Location: &v,
-		}})
-	}
-
-	registers := make([]*RegisterArgumentInfo, len(node.Targets))
-	results := core.ResultList{}
-	for i, target := range node.Targets {
-		// register errors should not effect one another, so we collect them.
-		registerInfo, curResults := g.getTargetRegister(
-			ctx,
-			target,
-			targetTypes[i],
-		)
-
-		if !results.IsEmpty() {
-			results.Extend(&curResults)
-		}
-
-		if registerInfo == nil {
-			// notest: sanity check, should not happen.
-			v := target.View()
-			results.Append(core.Result{{
-				Type:     core.InternalErrorResult,
-				Message:  "Unexpected nil register",
-				Location: &v,
-			}})
-		}
-
-		registerArgument := &RegisterArgumentInfo{
-			Register:    registerInfo,
-			declaration: node.View(),
-		}
-
-		registerInfo.AddDefinition(ctx.InstructionInfo)
-		registers[i] = registerArgument
-	}
-
-	return registers, results
-}
-
 // Convert an instruction parsed node into an instruction that is in the
 // instruction set.
 // If new registers are defined in the instruction (by assigning values to
@@ -209,8 +118,6 @@ func (g *InstructionGenerator) Generate(
 	// and processing the targets and arguments. We accumulate the results,
 	// since those processes do not effect each other.
 
-	// TODO: tidy this mess.
-
 	v := node.View()
 	instCtx := InstructionGenerationContext{
 		FunctionGenerationContext: ctx,
@@ -223,7 +130,7 @@ func (g *InstructionGenerator) Generate(
 	arguments, curResults := g.generateArguments(&instCtx, node)
 	results.Extend(&curResults)
 
-	partialTargets, curResults := g.generatePartialTargetsInfo(&instCtx, node)
+	targets, curResults := g.generateTargets(&instCtx, node)
 	results.Extend(&curResults)
 
 	labels, curResults := g.generateLabels(&instCtx, node)
@@ -234,25 +141,9 @@ func (g *InstructionGenerator) Generate(
 		return nil, results
 	}
 
-	instCtx.InstructionInfo.Arguments = arguments
-	instCtx.InstructionInfo.Labels = labels
-
-	explicitTargetTypes := partialTargetsToTypes(partialTargets)
-	argumentTypes := argumentsToTypes(arguments)
-	targetTypes, results := instDef.InferTargetTypes(ctx, explicitTargetTypes, argumentTypes)
-	// TODO: validate that the returned target types matches expected constraints.
-
-	if !results.IsEmpty() {
-		return nil, results
-	}
-
-	targets, results := g.defineAndGetTargetRegisters(&instCtx, node, targetTypes)
-
-	if !results.IsEmpty() {
-		return nil, results
-	}
-
-	instCtx.InstructionInfo.Targets = targets
+	instCtx.InstructionInfo.AppendTarget(targets...)
+	instCtx.InstructionInfo.AppendArgument(arguments...)
+	instCtx.InstructionInfo.AppendLabels(labels...)
 
 	instruction, results := instDef.BuildInstruction(instCtx.InstructionInfo)
 	if !results.IsEmpty() {
diff --git a/gen/instruction_generator_test.go b/gen/instruction_generator_test.go
index 1de9086..7ffdffc 100644
--- a/gen/instruction_generator_test.go
+++ b/gen/instruction_generator_test.go
@@ -183,7 +183,7 @@ func (m *InstructionMap) GetInstructionDefinition(
 }
 
 func TestInstructionCreateTarget(t *testing.T) {
-	src := core.NewSourceView("%c = ADD %a %b\n")
+	src := core.NewSourceView("$32 %c = ADD %a %b\n")
 	tkns, err := lex.NewTokenizer().Tokenize(src)
 	assert.NoError(t, err)
 
@@ -221,5 +221,5 @@ func TestInstructionCreateTarget(t *testing.T) {
 	assert.NotNil(t, target)
 	assert.Equal(t, "%c", target.Name)
 	assert.Equal(t, intType, target.Type.Base)
-	assert.Equal(t, src.Unmanaged().Subview(0, 2), target.Declaration)
+	assert.Equal(t, src.Unmanaged().Subview(0, 6), target.Declaration)
 }
diff --git a/gen/instruction_info.go b/gen/instruction_info.go
index a88a1d6..c420a7a 100644
--- a/gen/instruction_info.go
+++ b/gen/instruction_info.go
@@ -7,7 +7,7 @@ type InstructionInfo struct {
 
 	// The targets of the instruction.
 	// TODO: is a pointer reference really required here?
-	Targets []*RegisterArgumentInfo
+	Targets []*TargetInfo
 
 	// The arguments of the instruction.
 	Arguments []ArgumentInfo
@@ -29,7 +29,7 @@ func NewEmptyInstructionInfo(
 ) *InstructionInfo {
 	return &InstructionInfo{
 		BasicBlockInfo: nil,
-		Targets:        []*RegisterArgumentInfo{},
+		Targets:        []*TargetInfo{},
 		Arguments:      []ArgumentInfo{},
 		Labels:         []*LabelInfo{},
 		Instruction:    nil,
@@ -44,11 +44,18 @@ func (i *InstructionInfo) linkToBasicBlock(basicBlock *BasicBlockInfo) {
 	}
 }
 
-// Appends the given register as a target of the instruction,
+// Appends the given register(s) as a target(s) of the instruction,
 // including updating the required instruction and register information fields.
-func (i *InstructionInfo) AppendTarget(target *RegisterArgumentInfo) {
-	target.Register.AddDefinition(i)
-	i.Targets = append(i.Targets, target)
+func (i *InstructionInfo) AppendTarget(targets ...*TargetInfo) {
+	for _, target := range targets {
+		target.Register.AddDefinition(i)
+	}
+
+	i.Targets = append(i.Targets, targets...)
+}
+
+func (i *InstructionInfo) AppendArgument(arguments ...ArgumentInfo) {
+	i.Arguments = append(i.Arguments, arguments...)
 }
 
 func (i *InstructionInfo) AppendLabels(labels ...*LabelInfo) {
diff --git a/gen/label_argument.go b/gen/label_argument.go
index 3871beb..159bc40 100644
--- a/gen/label_argument.go
+++ b/gen/label_argument.go
@@ -11,15 +11,15 @@ import (
 type LabelArgumentInfo struct {
 	Label *LabelInfo
 
-	// TODO: make this not required.
-	declaration core.UnmanagedSourceView
+	declaration *core.UnmanagedSourceView
 }
 
 func NewLabelArgumentInfo(
 	label *LabelInfo,
 ) *LabelArgumentInfo {
 	return &LabelArgumentInfo{
-		Label: label,
+		Label:       label,
+		declaration: nil,
 	}
 }
 
@@ -27,7 +27,7 @@ func (i *LabelArgumentInfo) GetType() *ReferencedTypeInfo {
 	return nil // Label argument does not have a type
 }
 
-func (i *LabelArgumentInfo) Declaration() core.UnmanagedSourceView {
+func (i *LabelArgumentInfo) Declaration() *core.UnmanagedSourceView {
 	return i.declaration
 }
 
@@ -63,9 +63,10 @@ func (g *LabelArgumentGenerator) Generate(
 		})
 	}
 
+	v := node.View()
 	argument := &LabelArgumentInfo{
 		Label:       labelInfo,
-		declaration: node.View(),
+		declaration: &v,
 	}
 
 	return argument, core.ResultList{}
diff --git a/gen/regisrer_partial_info.go b/gen/regisrer_partial_info.go
deleted file mode 100644
index c0ba63b..0000000
--- a/gen/regisrer_partial_info.go
+++ /dev/null
@@ -1,15 +0,0 @@
-package gen
-
-import "alon.kr/x/usm/core"
-
-// This represents partial register information, possibly without an associated
-// type (yet). This is used internally before the compiler has finally determined
-// the type of the register, if the type is implicit.
-type registerPartialInfo struct {
-	Name string
-
-	// Possibly nil, if type is implicitly defined.
-	Type *ReferencedTypeInfo
-
-	Declaration core.UnmanagedSourceView
-}
diff --git a/gen/register_argument.go b/gen/register_argument.go
index 4ec84cd..39b8a87 100644
--- a/gen/register_argument.go
+++ b/gen/register_argument.go
@@ -10,10 +10,7 @@ import (
 type RegisterArgumentInfo struct {
 	Register *RegisterInfo
 
-	// TODO: make this not required, for generated arguments, for example after
-	// SSA construction (phi register arguments which do not appear in the
-	// source code).
-	declaration core.UnmanagedSourceView
+	declaration *core.UnmanagedSourceView
 }
 
 func NewRegisterArgument(register *RegisterInfo) RegisterArgumentInfo {
@@ -30,7 +27,7 @@ func (i *RegisterArgumentInfo) GetType() *ReferencedTypeInfo {
 	return &i.Register.Type
 }
 
-func (i *RegisterArgumentInfo) Declaration() core.UnmanagedSourceView {
+func (i *RegisterArgumentInfo) Declaration() *core.UnmanagedSourceView {
 	return i.declaration
 }
 
@@ -64,9 +61,10 @@ func (g *RegisterArgumentGenerator) Generate(
 		return nil, results
 	}
 
+	v := node.View()
 	argument := RegisterArgumentInfo{
 		Register:    register,
-		declaration: node.View(),
+		declaration: &v,
 	}
 
 	register.AddUsage(ctx.InstructionInfo)
diff --git a/gen/register_info.go b/gen/register_info.go
index 4e09f44..1095b76 100644
--- a/gen/register_info.go
+++ b/gen/register_info.go
@@ -51,11 +51,3 @@ func (i *RegisterInfo) AddDefinition(info *InstructionInfo) {
 func (i *RegisterInfo) AddUsage(info *InstructionInfo) {
 	i.Usages = append(i.Usages, info)
 }
-
-func (i *RegisterInfo) toPartialRegisterInfo() registerPartialInfo {
-	return registerPartialInfo{
-		Name:        i.Name,
-		Type:        &i.Type,
-		Declaration: i.Declaration,
-	}
-}
diff --git a/gen/target_generator.go b/gen/target_generator.go
index 5093fa8..2184e96 100644
--- a/gen/target_generator.go
+++ b/gen/target_generator.go
@@ -10,8 +10,8 @@ type TargetGenerator struct {
 	ReferencedTypeGenerator FileContextGenerator[parse.TypeNode, ReferencedTypeInfo]
 }
 
-func NewTargetGenerator() InstructionContextGenerator[parse.TargetNode, registerPartialInfo] {
-	return InstructionContextGenerator[parse.TargetNode, registerPartialInfo](
+func NewTargetGenerator() InstructionContextGenerator[parse.TargetNode, *TargetInfo] {
+	return InstructionContextGenerator[parse.TargetNode, *TargetInfo](
 		&TargetGenerator{
 			ReferencedTypeGenerator: NewReferencedTypeGenerator(),
 		},
@@ -36,54 +36,72 @@ func NewRegisterTypeMismatchResult(
 	})
 }
 
+// The target generator creates returns the register information that matches
+// the provided target node.
+//
+// If the targe node does not have an explicit type, and the register has not
+// been defined and processed yet, the generator will return nil.
 func (g *TargetGenerator) Generate(
 	ctx *InstructionGenerationContext,
 	node parse.TargetNode,
-) (registerPartialInfo, core.ResultList) {
-	var explicitType *ReferencedTypeInfo
+) (*TargetInfo, core.ResultList) {
+	registerName := nodeToSourceString(ctx.FileGenerationContext, node.Register)
+	registerInfo := ctx.Registers.GetRegister(registerName)
+	nodeView := node.View()
 
-	// if an explicit type is provided to the target, get the type info.
 	explicitTypeProvided := node.Type != nil
-	if explicitTypeProvided {
-		explicitTypeValue, results := g.ReferencedTypeGenerator.Generate(
+	if !explicitTypeProvided {
+		// If an explicit type is not provided, the best we can do is to return
+		// the previously defined register information. If it is not have been
+		// defined yet, we return nil here.
+		return &TargetInfo{
+			Register:    registerInfo,
+			Declaration: &nodeView,
+		}, core.ResultList{}
+
+	} else {
+		targetType, results := g.ReferencedTypeGenerator.Generate(
 			ctx.FileGenerationContext,
 			*node.Type,
 		)
+
 		if !results.IsEmpty() {
-			return registerPartialInfo{}, results
+			return nil, results
 		}
 
-		explicitType = &explicitTypeValue
-	}
-
-	registerName := nodeToSourceString(ctx.FileGenerationContext, node.Register)
-	registerInfo := ctx.Registers.GetRegister(registerName)
-
-	registerAlreadyDefined := registerInfo != nil
-	if registerAlreadyDefined {
-		if explicitType != nil {
-			// ensure explicit type matches the previously declared one.
-			if !explicitType.Equal(registerInfo.Type) {
-				return registerPartialInfo{}, NewRegisterTypeMismatchResult(
+		registerAlreadyDefined := registerInfo != nil
+		if registerAlreadyDefined {
+			// Register is already defined, so we just ensure that the explicit type
+			// we got now matches the previously defined one.
+			if !registerInfo.Type.Equal(targetType) {
+				return nil, NewRegisterTypeMismatchResult(
 					node.View(),
 					registerInfo.Declaration,
 				)
 			}
-		}
 
-		// all checks passed; return previously defined register type.
-		return registerInfo.toPartialRegisterInfo(), core.ResultList{}
+			return &TargetInfo{
+				Register:    registerInfo,
+				Declaration: &nodeView,
+			}, core.ResultList{}
 
-	} else {
-		// this is the first appearance of the register; if the type is provided
-		// explicitly, use it. otherwise, there is no way to know the type of
-		// the target register at this.
-		// the type and register will be finalized when the instruction is built,
-		// and only then it is added to the register manager.
-		return registerPartialInfo{
-			Name:        registerName,
-			Type:        explicitType,
-			Declaration: node.View(),
-		}, core.ResultList{}
+		} else {
+			// Register is not defined yet, so we define it now.
+			registerInfo = &RegisterInfo{
+				Name:        registerName,
+				Type:        targetType,
+				Declaration: nodeView,
+			}
+
+			results := ctx.Registers.NewRegister(registerInfo)
+			if !results.IsEmpty() {
+				return nil, results
+			}
+
+			return &TargetInfo{
+				Register:    registerInfo,
+				Declaration: &nodeView,
+			}, core.ResultList{}
+		}
 	}
 }
diff --git a/gen/target_generator_test.go b/gen/target_generator_test.go
index 14d4a06..3b5dfb4 100644
--- a/gen/target_generator_test.go
+++ b/gen/target_generator_test.go
@@ -49,5 +49,5 @@ func TestTargetRegisterAlreadyDefined(t *testing.T) {
 	generator := gen.NewTargetGenerator()
 	info, results := generator.Generate(&ctx, node)
 	assert.True(t, results.IsEmpty())
-	assert.Equal(t, intType, info.Type.Base)
+	assert.Equal(t, intType, info.Register.Type.Base)
 }
diff --git a/gen/target_info.go b/gen/target_info.go
new file mode 100644
index 0000000..7462559
--- /dev/null
+++ b/gen/target_info.go
@@ -0,0 +1,25 @@
+package gen
+
+import "alon.kr/x/usm/core"
+
+type TargetInfo struct {
+	Register *RegisterInfo
+
+	Declaration *core.UnmanagedSourceView
+}
+
+func NewTargetInfo(register *RegisterInfo) TargetInfo {
+	return TargetInfo{
+		Register:    register,
+		Declaration: nil,
+	}
+}
+
+func (i *TargetInfo) String() string {
+	return i.Register.Type.String() + " " + i.Register.String()
+}
+
+func (i *TargetInfo) SwitchRegister(register *RegisterInfo) {
+	// TODO: handle definitions and usages
+	i.Register = register
+}
diff --git a/parse/instruction.go b/parse/instruction.go
index 810283c..918e407 100644
--- a/parse/instruction.go
+++ b/parse/instruction.go
@@ -114,7 +114,7 @@ func (InstructionParser) parseOperator(v *TokenView, node *InstructionNode) core
 
 // Parsing of the following regular expression:
 //
-// > Lbl* (Reg+ Eql)? Opr? Arg+ !Arg \n+
+// > Lbl* ((Type? Reg)+ Eql)? Opr? Arg+ !Arg \n+
 func (p InstructionParser) Parse(v *TokenView) (node InstructionNode, err core.Result) {
 	node.Labels, _ = ParseManyIgnoreSeparators(p.LabelParser, v)
 	node.Targets = ParseMany(p.TargetParser, v)
diff --git a/usm64/core/emulation.go b/usm64/core/emulation.go
index a3843e8..7b0fe99 100644
--- a/usm64/core/emulation.go
+++ b/usm64/core/emulation.go
@@ -47,7 +47,7 @@ func (ctx *EmulationContext) ArgumentToValue(
 			return 0, list.FromSingle(core.Result{{
 				Type:     core.InternalErrorResult,
 				Message:  "Undefined register",
-				Location: &v,
+				Location: v,
 			}})
 		}
 
@@ -59,7 +59,7 @@ func (ctx *EmulationContext) ArgumentToValue(
 			return 0, list.FromSingle(core.Result{{
 				Type:     core.ErrorResult,
 				Message:  "Immediate overflows 64 bits",
-				Location: &v,
+				Location: v,
 			}})
 		}
 
@@ -70,7 +70,7 @@ func (ctx *EmulationContext) ArgumentToValue(
 		return 0, list.FromSingle(core.Result{{
 			Type:     core.ErrorResult,
 			Message:  "Expected valued argument",
-			Location: &v,
+			Location: v,
 		}})
 
 	default:
@@ -78,7 +78,7 @@ func (ctx *EmulationContext) ArgumentToValue(
 		return 0, list.FromSingle(core.Result{{
 			Type:     core.InternalErrorResult,
 			Message:  "Unexpected argument type",
-			Location: &v,
+			Location: v,
 		}})
 	}
 }
diff --git a/usm64/core/label.go b/usm64/core/label.go
index a77aa49..80e25f7 100644
--- a/usm64/core/label.go
+++ b/usm64/core/label.go
@@ -8,13 +8,12 @@ import (
 type Label struct {
 	Name             string
 	InstructionIndex uint64
-	declaration      core.UnmanagedSourceView
+	declaration      *core.UnmanagedSourceView
 }
 
 func NewLabel(arg gen.LabelArgumentInfo) (Label, core.ResultList) {
 	return Label{
-		Name: arg.Label.Name,
-
+		Name:        arg.Label.Name,
 		declaration: arg.Declaration(),
 	}, core.ResultList{}
 }
@@ -23,6 +22,6 @@ func (l Label) String(*EmulationContext) string {
 	return l.Name
 }
 
-func (l Label) Declaration() core.UnmanagedSourceView {
+func (l Label) Declaration() *core.UnmanagedSourceView {
 	return l.declaration
 }
diff --git a/usm64/core/register.go b/usm64/core/register.go
index d86b62a..6bb4a93 100644
--- a/usm64/core/register.go
+++ b/usm64/core/register.go
@@ -9,7 +9,7 @@ import (
 
 type Register struct {
 	Name        string
-	declaration core.UnmanagedSourceView
+	declaration *core.UnmanagedSourceView
 }
 
 func NewRegister(arg *gen.RegisterArgumentInfo) (Register, core.ResultList) {
@@ -27,6 +27,6 @@ func (r Register) String(ctx *EmulationContext) string {
 	return fmt.Sprintf("%s (#%d)", r.Name, r.Value(ctx))
 }
 
-func (r Register) Declaration() core.UnmanagedSourceView {
+func (r Register) Declaration() *core.UnmanagedSourceView {
 	return r.declaration
 }
diff --git a/usm64/isa/fixed.go b/usm64/isa/fixed.go
index 54839c9..1f21416 100644
--- a/usm64/isa/fixed.go
+++ b/usm64/isa/fixed.go
@@ -40,7 +40,7 @@ func (d *FixedInstructionDefinition) InferTargetTypes(
 }
 
 func (d *FixedInstructionDefinition) assertTargetAmount(
-	targets []*gen.RegisterArgumentInfo,
+	targets []*gen.TargetInfo,
 ) core.ResultList {
 	// TODO: possible overflow?
 	if core.UsmUint(len(targets)) != d.Targets {
@@ -70,7 +70,7 @@ func (d *FixedInstructionDefinition) assertArgumentAmount(
 }
 
 func (d *FixedInstructionDefinition) assertInputLengths(
-	targetInfos []*gen.RegisterArgumentInfo,
+	targetInfos []*gen.TargetInfo,
 	argumentInfos []gen.ArgumentInfo,
 ) (results core.ResultList) {
 	targetResults := d.assertTargetAmount(targetInfos)
diff --git a/usm64/ssa/ssa_construction.go b/usm64/ssa/ssa_construction.go
index e17ecc2..7cc10cb 100644
--- a/usm64/ssa/ssa_construction.go
+++ b/usm64/ssa/ssa_construction.go
@@ -26,7 +26,7 @@ func (s *ConstructionScheme) NewPhiInstruction(
 	register *gen.RegisterInfo,
 ) (ssa.PhiInstruction, core.ResultList) {
 	info := gen.NewEmptyInstructionInfo(nil)
-	target := gen.NewRegisterArgument(register)
+	target := gen.NewTargetInfo(register)
 	info.AppendTarget(&target)
 	instruction, results := usm64isa.NewPhiInstruction(info)
 	info.SetBaseInstruction(instruction)
@@ -57,7 +57,7 @@ func (s *ConstructionScheme) renameArgument(
 }
 
 func (s *ConstructionScheme) renameTarget(
-	target *gen.RegisterArgumentInfo,
+	target *gen.TargetInfo,
 	reachingSet ssa.ReachingDefinitionsSet,
 ) core.ResultList {
 	baseRegister := target.Register