abstract val psiPointer: SmartPsiElementPointer<out PSI>
    abstract fun getType(psi: PSI): TYPE

    override val type: TYPE
        get() {
            val psi = psiPointer.element
                ?: error("Cannot restore $psiPointer")
            return getType(psi)
        }
}

internal class JavaElementDelegatingVariableReturnTypeSourceWithSmartPointer<TYPE : PsiType>(

	Get(version *EtcdVersion, key string) (string, error)
	Put(version *EtcdVersion, key, value string) error
	Backup(version *EtcdVersion, backupDir string) error
	Snapshot(version *EtcdVersion, snapshotFile string) error
	Restore(version *EtcdVersion, snapshotFile string) error
	Migrate(version *EtcdVersion) error
	AttachLease(leaseDuration time.Duration) error
	Close() error
}

// Migrator manages etcd data migrations.
type Migrator struct {

      (trackable_object->attributes_size() > 0 ||
       trackable_object->slot_variables_size() > 0)) {
    TF_RETURN_WITH_CONTEXT_IF_ERROR(
        callback(saved_object_node_id, *trackable_object), "Unable to restore ",
        object_name);
  }

  for (const auto& trackable_child_ref : trackable_object->children()) {
    const auto& local_name = trackable_child_ref.local_name();

    // Compute the full child name.

  string init_node_name = 2;

  // Path to the directory where checkpoint files are saved. This directoy is
  // not expected to be persistent (usually a temporary directory). When
  // fetching the restore op (see `restore_node_name`), this value is provided
  // to the "file_prefix" tensor to identify the checkpoint directory.
  string checkpoint_dir = 5;

  // Function name -> function alias mapping. This associates the quantized

		args := &debugCallWrapArgs{
			dispatch: dispatch,
			callingG: gp,
		}
		newg.param = unsafe.Pointer(args)

		// Transfer locked-ness to the new goroutine.
		// Save lock state to restore later.
		mp := gp.m
		if mp != gp.lockedm.ptr() {
			throw("inconsistent lockedm")
		}
		// Save the external lock count and clear it so
		// that it can't be unlocked from the debug call.

		// Darwin libsystem has a bug where it checks ss_size
		// even if SS_DISABLE is set. (The kernel gets it right.)
		ost.ss_size = CSIGSTKSZ;
	}
	if (sigaltstack(&ost, NULL) < 0) {
		perror("sigaltstack restore failed");
		abort();
	}
	mprotect(base, CSIGSTKSZ, PROT_NONE);
	return NULL;
}

static void* WithoutSigStack(void* arg __attribute__((unused))) {
	SigStackCallback();
	return NULL;
}

}

func getState(fd int) (*State, error) {
	termios, err := unix.IoctlGetTermios(fd, ioctlReadTermios)
	if err != nil {
		return nil, err
	}

	return &State{state{termios: *termios}}, nil
}

func restore(fd int, state *State) error {
	return unix.IoctlSetTermios(fd, ioctlWriteTermios, &state.termios)
}

func getSize(fd int) (width, height int, err error) {
	ws, err := unix.IoctlGetWinsize(fd, unix.TIOCGWINSZ)

	// Build a 32-byte stack frame for us for this call.
	// Saved LR (none available) is at the bottom,
	// then the PC argument for setsigsegv,
	// then a copy of the LR for us to restore.
	MOVD.W $0, -32(RSP)
	MOVD R1, 8(RSP)
	MOVD R2, 16(RSP)
	BL runtime·setsigsegv(SB)
	MOVD 8(RSP), R1
	MOVD 16(RSP), R2

	// Build a 16-byte stack frame for the simulated

-A OUTPUT ! -d 127.0.0.1/32 -p tcp -o lo -m owner --gid-owner 1000670001 -j MARK --set-mark 1338
-A OUTPUT -p tcp -m connmark --mark 1337 -j CONNMARK --restore-mark
-I ISTIO_INBOUND 1 -p tcp -m mark --mark 1337 -j RETURN
-I ISTIO_INBOUND 2 -p tcp -s 127.0.0.6/32 -i lo -j RETURN
-I ISTIO_INBOUND 3 -p tcp -i lo -m mark ! --mark 1338 -j RETURN
COMMIT
* nat
-N ISTIO_INBOUND

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Macros for transitioning from the host ABI to Go ABI0.
//
// These macros save and restore the callee-saved registers
// from the stack, but they don't adjust stack pointer, so
// the user should prepare stack space in advance.
// SAVE_R22_TO_R31(offset) saves R22 ~ R31 to the stack space