}
				prog.Reg = reg
			}
			break
		}
		if p.arch.Family == sys.MIPS || p.arch.Family == sys.MIPS64 || p.arch.Family == sys.RISCV64 {
			// 3-operand jumps.
			// First two must be registers
			target = &a[2]
			prog.From = a[0]
			prog.Reg = p.getRegister(prog, op, &a[1])
			break
		}
		if p.arch.Family == sys.Loong64 {
			// 3-operand jumps.
			// First two must be registers

                        && (!isFamily(FAMILY_MAC, actualOsName) || actualOsName.endsWith("x"));
            case FAMILY_ZOS:
                return actualOsName.contains(FAMILY_ZOS) || actualOsName.contains(FAMILY_OS390);
            case FAMILY_OS400:
                return actualOsName.contains(FAMILY_OS400);
            case FAMILY_OPENVMS:
                return actualOsName.contains(FAMILY_OPENVMS);

    /**
     * The "none" language. It is not versioned, family is same to itself, and compatible with itself only.
     * In turn, every {@link Language} implementation must be compatible with {@code NONE} language.
     */
    Language NONE = language("none");

    // TODO: this should be moved out from here to Java Support (builtin into core)
    Language JAVA_FAMILY = language("java");

        "black":       "#ffffff",
        "white":       "#000000"
      }[primary] or "#ffffff" }}
    {%- endif -%}

  # Font family (default: Roboto)
  - &font_family >-
    {%- if layout.font_family -%}
      {{ layout.font_family }}
    {%- elif config.theme.font != false -%}
      {{ config.theme.font.get("text", "Roboto") }}
    {%- else -%}
      Roboto
    {%- endif -%}

                // j2ee types
                new DefaultType("ejb", Language.JAVA_FAMILY, "jar", null, false, JavaPathType.CLASSES),
                new DefaultType("ejb-client", Language.JAVA_FAMILY, "jar", "client", false, JavaPathType.CLASSES),
                new DefaultType("war", Language.JAVA_FAMILY, "war", null, true),

}

type realDeps struct{}

func (m *realDeps) ipsetIPHashCreate(name string, v6 bool) error {
	var family uint8

	if v6 {
		family = unix.AF_INET6
	} else {
		family = unix.AF_INET
	}
	err := netlink.IpsetCreate(name, "hash:ip", netlink.IpsetCreateOptions{Comments: true, Replace: true, Family: family})
	if ipsetErr, ok := err.(nl.IPSetError); ok && ipsetErr == nl.IPSET_ERR_EXIST {
		return nil
	}

	return err

        if (reverse) {
            return !result;
        } else {
            return result;
        }
    }

    private boolean determineFamilyMatch(String family) {
        String test = family;
        boolean reverse = false;

        if (test.startsWith("!")) {
            reverse = true;
            test = test.substring(1);
        }

		//
		// TODO largely identical/copied from tools/istio-iptables/pkg/capture/run_linux.go
		inpodMarkRule := netlink.NewRule()
		inpodMarkRule.Family = family
		inpodMarkRule.Table = RouteTableInbound
		inpodMarkRule.Mark = InpodTProxyMark
		inpodMarkRule.Mask = InpodTProxyMask
		inpodMarkRule.Priority = 32764
		rules = append(rules, inpodMarkRule)
	}

	for _, rule := range rules {
		log.Debugf("Iterating netlink rule : %+v", rule)

                        .arch(settingsOs.getArch())
                        .family(settingsOs.getFamily())
                        .name(settingsOs.getName())
                        .version(settingsOs.getVersion())
                        .location("arch", toLocation(settingsOs.getLocation("arch")))
                        .location("family", toLocation(settingsOs.getLocation("family")))

			}
			a.Index = r1
			if scale != 0 && scale != 1 && (p.arch.Family == sys.ARM64 ||
				p.arch.Family == sys.PPC64) {
				// Support (R1)(R2) (no scaling) and (R1)(R2*1).
				p.errorf("%s doesn't support scaled register format", p.arch.Name)
			} else {
				a.Scale = int16(scale)
			}
		}
		p.get(')')
	} else if scale != 0 {
		if p.arch.Family == sys.ARM64 {