propertyNode.setTarget(null);
                        } else if (value instanceof ManagedInstance) {
                            ManagedInstance managedInstance = (ManagedInstance) value;
                            MutableModelNode targetNode = managedInstance.getBackingNode();
                            propertyNode.setTarget(targetNode);
                        } else {

    }

    public String getName() {
        return name;
    }

    public PBXGroup getMainGroup() {
        return mainGroup;
    }

    public List<PBXTarget> getTargets() {
        return targets;
    }

    public XCConfigurationList getBuildConfigurationList() {
        return buildConfigurationList;
    }

    public String getCompatibilityVersion() {

        // Use the result of previous rules as the input for dependency substitution
        ComponentSelector requested = dependencySubstitution.getTarget();
        if (requested instanceof ModuleComponentSelector) {
            ModuleComponentSelector selector = (ModuleComponentSelector) requested;
            ProjectComponentIdentifier replacement = getReplacementFor(selector);

            }
            m = unwrap(replacements.get(m));
        }
    }

    private static ModuleIdentifier unwrap(Replacement replacement) {
        return replacement == null ? null : replacement.getTarget();
    }

    private static NotationParser<Object, ModuleIdentifier> parser(ImmutableModuleIdentifierFactory moduleIdentifierFactory) {
        return NotationParserBuilder

			p.To.Type = TYPE_NONE
		}

		p.To.SetTarget(q)
	}

	if !ctxt.Flag_optimize {
		return
	}

	// Collapse series of jumps to jumps.
	for p := sym.Func().Text; p != nil; p = p.Link {
		if p.To.Target() == nil {
			continue
		}
		p.To.SetTarget(brloop(p.To.Target()))
		if p.To.Target() != nil && p.To.Type == TYPE_BRANCH {

		if v.AuxInt != 0 {
			plwsync2 := s.Prog(ppc64.ALWSYNC)
			plwsync2.To.Type = obj.TYPE_NONE
			p2.To.SetTarget(plwsync2)
		} else {
			// done (label)
			p6 := s.Prog(obj.ANOP)
			p2.To.SetTarget(p6)
		}

	case ssa.OpPPC64LoweredPubBarrier:
		// LWSYNC
		s.Prog(v.Op.Asm())

	case ssa.OpPPC64LoweredGetClosurePtr:

        }

        String namespace = toNamespace(settings.getProjectName());

        return templateOperationFactory.newTemplateOperation()
            .withTemplate(template)
            .withTarget(settings.getTarget().file(settings.getSubprojects().get(0) + "/src/" + sourceSetName + "/" + sourceDir + "/" + targetFileName).getAsFile())
            .withBinding("projectName", settings.getProjectName())

	loop := p
	p = pp.Append(p, riscv.AADD, obj.TYPE_CONST, 0, int64(types.PtrSize), obj.TYPE_REG, riscv.REG_T0, 0)
	p = pp.Append(p, riscv.ABNE, obj.TYPE_REG, riscv.REG_T0, 0, obj.TYPE_BRANCH, 0, 0)
	p.Reg = riscv.REG_T1
	p.To.SetTarget(loop)
	return p

	spfix.As = obj.ANOP
	spfix.Spadj = -framesize

	pcdata := c.ctxt.EmitEntryStackMap(c.cursym, spfix, c.newprog)
	pcdata = c.ctxt.StartUnsafePoint(pcdata, c.newprog)

	if q != nil {
		q.To.SetTarget(pcdata)
	}
	bls.To.SetTarget(pcdata)

	spill := c.cursym.Func().SpillRegisterArgs(pcdata, c.newprog)

	// MOV	LR, R3
	movlr := obj.Appendp(spill, c.newprog)
	movlr.As = AMOVD
	movlr.From.Type = obj.TYPE_REG

				q.From.Reg = REG_R24
				q.To.Type = obj.TYPE_MEM
				q.To.Reg = REG_R20
				q.To.Offset = 0 // Panic.argp

				q = obj.Appendp(q, newprog)

				q.As = obj.ANOP
				p1.To.SetTarget(q)
				p2.To.SetTarget(q)
			}

		case ARET:
			if p.From.Type == obj.TYPE_CONST {
				ctxt.Diag("using BECOME (%v) is not supported!", p)
				break
			}

			retSym := p.To.Sym