List<Restriction> restrictions = range.getRestrictions();
        assertEquals(1, restrictions.size(), CHECK_NUM_RESTRICTIONS);
        Restriction restriction = restrictions.get(0);
        assertNull(restriction.getLowerBound(), CHECK_LOWER_BOUND);
        assertFalse(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
        assertEquals("1.0", restriction.getUpperBound().toString(), CHECK_UPPER_BOUND);

        return new VersionRange(version, restrictions);
    }

    private List<Restriction> intersection(List<Restriction> r1, List<Restriction> r2) {
        List<Restriction> restrictions = new ArrayList<>(r1.size() + r2.size());
        Iterator<Restriction> i1 = r1.iterator();
        Iterator<Restriction> i2 = r2.iterator();
        Restriction res1 = i1.next();
        Restriction res2 = i2.next();

    private final Range<C> restriction;

    SubRangeSet(Range<C> restriction) {
      super(
          new SubRangeSetRangesByLowerBound<C>(
              Range.<Cut<C>>all(), restriction, TreeRangeSet.this.rangesByLowerBound));
      this.restriction = restriction;
    }

    @Override
    public boolean encloses(Range<C> range) {
      if (!restriction.isEmpty() && restriction.encloses(range)) {

    /** Logon failure: unknown user name or bad password */
    int NT_STATUS_LOGON_FAILURE = 0xC000006d;
    /** Logon failure: user account restriction */
    int NT_STATUS_ACCOUNT_RESTRICTION = 0xC000006e;
    /** Logon failure: account logon time restriction violation */
    int NT_STATUS_INVALID_LOGON_HOURS = 0xC000006f;
    /** Logon failure: user not allowed to log on to this computer */

    /** Logon failure: unknown user name or bad password */
    int NT_STATUS_LOGON_FAILURE = 0xC000006d;
    /** Logon failure: user account restriction */
    int NT_STATUS_ACCOUNT_RESTRICTION = 0xC000006e;
    /** Logon failure: account logon time restriction violation */
    int NT_STATUS_INVALID_LOGON_HOURS = 0xC000006f;
    /** Logon failure: user not allowed to log on to this computer */

  All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10.  If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term.  If a license document contains
a further restriction but permits relicensing or conveying under this

        // This node is not referenced in inputs. Add it to the body.
        body_nodes->push_back(node);
      } else {
        // This node is referenced in inputs. Currently, we place an
        // artificial restriction and require that when num_opers=-1, such
        // nodes must have a single output.
        if (node->num_outputs() != 1) {
          return InvalidArgument(

                            // TODO shouldn't need to double up on this work, only done for simplicity of handling
                            // recommended
                            // version but the restriction is identical
                            VersionRange newRange = previousRange.restrict(currentRange);
                            // TODO ick. this forces the OCE that should have come from the previous call. It is still

automatically defined in the preamble. Note that there is no way for C
code to create a value of this type; this is only useful for passing
string values from Go to C and back to Go.

Using //export in a file places a restriction on the preamble:
since it is copied into two different C output files, it must not
contain any definitions, only declarations. If a file contains both
definitions and declarations, then the two output files will produce

        /** Timeout for process destruction in milliseconds. */
        private final long timeout;

        /**
         * Constructor for ProcessDestroyer.
         * @param p The process to monitor.
         * @param ist The input stream thread.
         * @param timeout The destruction timeout.
         */