c.set_sp(sp)
	*(*uint64)(unsafe.Pointer(uintptr(sp))) = c.link()

	pc := gp.sigpc

	if shouldPushSigpanic(gp, pc, uintptr(c.link())) {
		// Make it look the like faulting PC called sigpanic.
		c.set_link(uint64(pc))
	}

	// In case we are panicking from external C code
	c.set_r0(0)
	c.set_r30(uint64(uintptr(unsafe.Pointer(gp))))
	c.set_r12(uint64(abi.FuncPCABIInternal(sigpanic)))

    public Container(Node node) {
        super(node);
    }

    public Container(String path) {
        super(path);
    }

    @Override
    public String getKind() {
        return "con";
    }

    @Override
    public String toString() {
        return "Container" + super.toString();
    }

    private final int kind;
    private final String pattern;

    public DefaultAccessRule(int kind, String pattern) {
        this.kind = kind;
        this.pattern = pattern;
    }

    public int getKind() {
        return kind;
    }

    public String getPattern() {
        return pattern;
    }

}

// ApplyObject creates or updates an object in the API server depending on whether it already exists.
// It mutates obj.
func (h *HelmReconciler) ApplyObject(obj *unstructured.Unstructured) error {
	if obj.GetKind() == "List" {
		var errs util.Errors
		list, err := obj.ToList()
		if err != nil {
			scope.Errorf("error converting List object: %s", err)
			return err
		}
		for _, item := range list.Items {

  Status RegisterFunction(AbstractFunction*) override;
  Status RemoveFunction(const string& func) override;
  // For LLVM style RTTI.
  static bool classof(const AbstractContext* ptr) {
    return ptr->getKind() == kTape;
  }
  ~TapeContext() override;

 private:
  AbstractContext* parent_ctx_;  // Not owned.
  Tape* tape_;
  const GradientRegistry& registry_;
};
}  // namespace gradients

    public String getName() {
        return name;
    }

    @Override
    public Type getParameterType() {
        return parameterType;
    }

    @Override
    public ParameterKindInfo getKind() {
        return kind;
    }

    }

    public Variable(FileReference library) {
        super(library);
    }

    @Override
    public String getKind() {
        return "var";
    }

    @Override
    public String toString() {
        return "Variable" + super.toString();
    }

        this.owner = owner;
        this.callableName = callableName;
        this.returnType = returnType;
        this.parameters = parameters;
    }

    @Override
    public CallableKindInfo getKind() {
        return kind;
    }

    @Override
    public CallableOwnerInfo getOwner() {
        return owner;
    }

    @Override
    public String getCallableName() {
        return callableName;

        super(file);
        this.kind = kind;
        this.expected = expected;
        this.actual = actual;
    }

    public ChecksumKind getKind() {
        return kind;
    }

    public String getExpected() {
        return expected;
    }

    public String getActual() {
        return actual;
    }

    @Override

        this.allowedModifiers = allowedModifiers;
    }

    @Override
    public Class<? extends Annotation> getAnnotationType() {
        return annotationType;
    }

    @Override
    public Kind getKind() {
        return kind;
    }

    @Override
    public ImmutableSet<Class<? extends Annotation>> getAllowedModifiers() {
        return allowedModifiers;
    }