// one step newton iteration to 53 bits with error less than 0.667ulps
	s = t * t // t*t is exact
	r = x / s
	w := t + t
	r = (r - t) / (w + r) // r-s is exact
	t = t + t*r

	// restore the sign bit
	if sign {
		t = -t
	}
	return t

/**
 * [KaSymbol] is valid only during read action it was created in
 * To pass the symbol from one read action to another the KtSymbolPointer should be used
 *
 * We can restore the symbol
 *  * for symbol which came from Kotlin source it will be restored based on [com.intellij.psi.SmartPsiElementPointer]
 *  * restoring symbols which came from Java source is not supported yet
 *  * for library symbols:

    Arg<TF_StrTensor, [{shape {N}.  The names of the tensors to be restored. This is tensor name in the model.}]>:$tensor_names,
    Arg<TF_StrTensor, [{shape {N}.  The slice specs of the tensors to be restored.
Empty strings indicate that they are non-partitioned tensors.}]>:$shape_and_slices,
    // VarHandles for restored tensors.
    Variadic<TF_Tensor>:$var_handles,
    // Data types for restored tensor.
    TypeArrayAttr: $restored_dtypes,

        synchronized (lock) {
            // Currently only snapshot the console output listener. Should snapshot all output listeners, and cleanup in restore()
            return new SnapshotImpl(logLevel.get(), console);
        }
    }

    @Override
    public void restore(Snapshot state) {
        synchronized (lock) {
            SnapshotImpl snapshot = (SnapshotImpl) state;
            if (snapshot.logLevel != logLevel.get()) {

-A OUTPUT ! -d 127.0.0.1/32 -p tcp -o lo -m owner --uid-owner 1337 -j MARK --set-mark 1338
-A OUTPUT ! -d 127.0.0.1/32 -p tcp -o lo -m owner --gid-owner 1337 -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

     * capability that is added by
     * {@link JavaPluginExtension#registerFeature(String, org.gradle.api.Action)}.
     * If you want to keep the default capability and add a new one you need to
     * restore the default capability:
     *
     * <pre>
     * registerFeature("myFeature") {
     *     capability("${project.group}", "${project.name}-my-feature", "${project.version}")

nil_fn:
#endif
	MOVD	R3, FIXED_FRAME+0(R1)	// fn unsafe.Pointer
	MOVD	R4, FIXED_FRAME+8(R1)	// a unsafe.Pointer
	// Skip R5 = n uint32
	MOVD	R6, FIXED_FRAME+16(R1)	// ctxt uintptr
	BL	runtime·cgocallback(SB)

	// Restore the old frame, and R2.
	MOVD	24(R1), R2
	UNSTACK_AND_RESTORE_GO_TO_HOST_ABI(32)

			if len(existing.ResourceVersion) == 0 {
				return nil, fmt.Errorf("cannot allocate resources of type %s at this time", e.resource.String())
			}
			if existing.ResourceVersion != e.last {
				if err := e.alloc.Restore(existing.Range, existing.Data); err != nil {
					return nil, err
				}
			}
			if err := fn(); err != nil {
				return nil, err
			}
			e.last = existing.ResourceVersion

	std	%r0, 8(%r1)	// Save CR in caller's frame
	stdu	%r1, -FRAME_SIZE(%r1)
	std	%r2, 24(%r1)

	FOR_EACH_GPR std
	FOR_EACH_FPR stfd
	FOR_EACH_VR stvx

	// Set up Go ABI constant registers
	li	%r0, 0

	// Restore g pointer (r30 in Go ABI, which may have been clobbered by C)
	mr	%r30, %r4

	// Call fn
	mr	%r12, %r3
	mtctr	%r3
	bctrl

	FOR_EACH_GPR ld
	FOR_EACH_FPR lfd
	FOR_EACH_VR lvx

	ld	%r2, 24(%r1)

//
//   1) For each function def in the SavedModel, register it with the runtime.
//   2) For each object in the object graph def, build it.
//   3) For each variable stored in the checkpoint in the SavedModel,
//      restore it, and attach it to the associated variable object.
//   4) For each polymorphic function, associate it with the appropriate
//      concrete function(s).
//   5) For each function with captures, bind the appropriate objects as