.jstree-default .jstree-no-icons a .jstree-icon { display:none; }

.jstree-default .jstree-search { font-style:italic; }

.jstree-default .jstree-no-icons .jstree-checkbox { display:inline-block; }
.jstree-default .jstree-no-checkboxes .jstree-checkbox { display:none !important; }
.jstree-default .jstree-checked > a > .jstree-checkbox { background-position:-38px -19px; }

//
// Misc operations must do incref/decref.
// Misc operations include functions like setsockopt and setDeadline.
// They need to use incref/decref to ensure that they operate on the
// correct fd in presence of a concurrent close call (otherwise fd can
// be closed under their feet).
//
// Close operations must do increfAndClose/decref.

// incref adds a reference to mu.

func (fd *FD) Fchdir() error {
	if err := fd.incref(); err != nil {
		return err
	}
	defer fd.decref()
	return syscall.Fchdir(fd.Sysfd)
}

// ReadDirent wraps syscall.ReadDirent.
// We treat this like an ordinary system call rather than a call
// that tries to fill the buffer.
func (fd *FD) ReadDirent(buf []byte) (int, error) {
	if err := fd.incref(); err != nil {
		return 0, err
	}
	defer fd.decref()

	if err := fd.incref(); err != nil {
		return err
	}
	defer fd.decref()
	return syscall.SetsockoptIPMreq(fd.Sysfd, level, name, mreq)
}

// SetsockoptIPv6Mreq wraps the setsockopt network call with an IPv6Mreq argument.
func (fd *FD) SetsockoptIPv6Mreq(level, name int, mreq *syscall.IPv6Mreq) error {
	if err := fd.incref(); err != nil {
		return err
	}
	defer fd.decref()

		println("BUG bug344b", y)
	}
	
	i = 1<<32
	if y := x << i; y != 0 {
		println("BUG bug344c", y)
	}
}
	

/*
typecheck [1008592b0]
.   INDREG a(1) l(15) x(24) tc(2) runtime.ret G0 string
bug343.go:15: internal compiler error: typecheck INDREG

// but we still want the locking semantics that fdMutex provides.

// FDMutex is an exported fdMutex, only for Plan 9.
type FDMutex struct {
	fdmu fdMutex
}

func (fdmu *FDMutex) Incref() bool {
	return fdmu.fdmu.incref()
}

func (fdmu *FDMutex) Decref() bool {
	return fdmu.fdmu.decref()
}

func (fdmu *FDMutex) IncrefAndClose() bool {
	return fdmu.fdmu.increfAndClose()
}

    }

    private boolean implementedDirectly(CtClass interf, CtClass c) {
        return c.interfaces.any { it.name == interf.name }
    }

    private boolean addedInterfaceIsIncubatingOrInternal(CtClass interf, CtClass c) {
        return (isIncubating(interf) && !isIncubating(c)) || isInternal(interf)
    }

    private boolean isIncubating(CtClass c) {

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.


# Usage: ./integ-suite-kind.sh TARGET
# Example: ./integ-suite-kind.sh test.integration.pilot.kube.presubmit

WD=$(dirname "$0")
WD=$(cd "$WD"; pwd)
ROOT=$(dirname "$WD")

# Exit immediately for non zero status
set -e
# Check unset variables

	}
	return err
}

// Shutdown wraps syscall.Shutdown.
func (fd *FD) Shutdown(how int) error {
	if err := fd.incref(); err != nil {
		return err
	}
	defer fd.decref()
	return syscall.Shutdown(fd.Sysfd, how)
}

// Fchown wraps syscall.Fchown.
func (fd *FD) Fchown(uid, gid int) error {
	if err := fd.incref(); err != nil {
		return err
	}
	defer fd.decref()
	return ignoringEINTR(func() error {

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

package poll

import "syscall"

// Fsync wraps syscall.Fsync.
func (fd *FD) Fsync() error {
	if err := fd.incref(); err != nil {
		return err
	}
	defer fd.decref()
	return syscall.Fsync(fd.Sysfd)