1.5 and on, 2.0 and on, 3.0 and on.
964523
private void parseLdapAuthorization_1_5(final XMLExtendedStreamReader reader,
            final ModelNode realmAddress, final List<ModelNode> list) throws XMLStreamException {
        ModelNode addr = realmAddress.clone().add(AUTHORIZATION, LDAP);
        ModelNode ldapAuthorization = Util.getEmptyOperation(ADD, addr);

        list.add(ldapAuthorization);

        Set<Attribute> required = EnumSet.of(Attribute.CONNECTION);
        final int count = reader.getAttributeCount();
        for (int i = 0; i < count; i++) {
            final String value = reader.getAttributeValue(i);
            if (!isNoNamespaceAttribute(reader, i)) {
                throw unexpectedAttribute(reader, i);
            } else {
                final Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i));
                required.remove(attribute);
                switch (attribute) {
                    case CONNECTION: {
                        LdapAuthorizationResourceDefinition.CONNECTION.parseAndSetParameter(value, ldapAuthorization, reader);
                        break;
                    }
                    default: {
                        throw unexpectedAttribute(reader, i);
                    }
                }
            }
        }

        if (required.isEmpty() == false) {
            throw missingRequired(reader, required);
        }

        Set<Element> foundElements = new HashSet<Element>();
        while (reader.hasNext() && reader.nextTag() != END_ELEMENT) {
            requireNamespace(reader, namespace);
            final Element element = Element.forName(reader.getLocalName());
            if (foundElements.add(element) == false) {
                throw unexpectedElement(reader); // Only one of each allowed.
            }
            switch (element) {
                case USERNAME_TO_DN: {
                    switch (namespace.getMajorVersion()) {
                        case 1: // 1.5 up to but not including 2.0
                            parseUsernameToDn_1_5(reader, addr, list);
                            break;
                        default: // 2.0 and onwards
                            parseUsernameToDn_2_0(reader, addr, list);
                            break;
                    }

                    break;
                }
                case GROUP_SEARCH: {
                    switch (namespace) {
                        case DOMAIN_1_5:
                        case DOMAIN_1_6:
                            parseGroupSearch_1_5(reader, addr, list);
                            break;
                        default:
                            parseGroupSearch_1_7_and_2_0(reader, addr, list);
                            break;
                    }
                    break;
                }
                default: {
                    throw unexpectedElement(reader);
                }
            }
        }
    }
474607
def add(v1, v2):
    '''
    '''
    return tuple(a + b for a, b in zip(v1, v2))
75563
def set_minor(self):
        
        old_version = self.get_version()
        new_version = str(int(old_version.split('.', 5)[0])) + '.' + \
            str(int(old_version.split('.', 5)[1])+1) + '.0'
        self.set_version(old_version, new_version)
902896
public void polyScale(GrowQueue_I8 input , int scale , GrowQueue_I8 output) {

		output.resize(input.size);

		for (int i = 0; i < input.size; i++) {
			output.data[i] = (byte)multiply(input.data[i]&0xFF, scale);
		}
	}
444716
function Version(major, minor, micro, build) {

    if (typeof major === "number" && major % 1 === 0)
        this._major = major;
    else
        throw new Error("Invalid major version number '" + major + "'");

    if (typeof minor === "number" && minor % 1 === 0)
        this._minor = minor;
    else
        throw new Error("Invalid minor version number '" + minor + "'");

    if (typeof micro === "number" && micro % 1 === 0)
        this._micro = micro;
    else
        throw new Error("Invalid micro version number '" + micro + "'");

    if (typeof build === "number" && build % 1 === 0)
        this._build = build;
    else
        throw new Error("Invalid build version number '" + build + "'");
}
1315566
function installVersion(version) {
    return __awaiter(this, void 0, void 0, function () {
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    if (!INSTALL_VERSIONS_CACHE[version]) return [3 /*break*/, 2];
                    return [4 /*yield*/, INSTALL_VERSIONS_CACHE[version]];
                case 1:
                    _a.sent();
                    return [2 /*return*/, false];
                case 2:
                    INSTALL_VERSIONS_CACHE[version] = _installVersion(version);
                    return [4 /*yield*/, INSTALL_VERSIONS_CACHE[version]];
                case 3:
                    _a.sent();
                    return [2 /*return*/, true];
            }
        });
    });
}
1000765
def _exceeds_version(self, major, minor, v_major, v_minor):
        """"""
        return (major > v_major or (major == v_major and minor > v_minor))
514471
function() {
		this.cpu = new CPU( this );
		this.apu = new APU( this );
		this.ppu = new PPU( this );
		this.memory = new Memory( this );

		this.loadCartridge( this.cartridge );
	}
1124125
function tightenDependenciesVersions(grunt, deps) {
  console.assert(deps, 'missing deps object');
  Object.keys(deps).forEach(function (name) {
    var version = deps[name];
    warnOnLooseVersion(grunt, name, version);
    version = tightenVersion(version);
    deps[name] = version;
  });
}
134590
public void initializationPhase() {
    population = new ArrayList<>(populationSize) ;
    while (population.size() < populationSize) {
      S newSolution = diversificationGeneration() ;
      S improvedSolution = improvement(newSolution) ;
      population.add(improvedSolution) ;
    }
  }
683099
def increment_version(context):
    """"""

    attributes.replace_attribute(
        context.module_name, '__version__', context.new_version, dry_run=context.dry_run
    )
    log.info(
        'Bumped version from %s to %s' % (context.current_version, context.new_version)
    )
645111
function addDeps(a, b) {
  if (a && a.cache && b) {
    if (b.cache) {
      a.cache.mergeDeps(b.cache);
    }
    a.cache.addDeps(b.realpath || b);
  }
}
1245713
private static Version[] buildVersions() {
    return new Version[]{
        new Version(1, 10, 10, 8, 8,
            new ECBlocks(5, new ECB(1, 3))),
        new Version(2, 12, 12, 10, 10,
            new ECBlocks(7, new ECB(1, 5))),
        new Version(3, 14, 14, 12, 12,
            new ECBlocks(10, new ECB(1, 8))),
        new Version(4, 16, 16, 14, 14,
            new ECBlocks(12, new ECB(1, 12))),
        new Version(5, 18, 18, 16, 16,
            new ECBlocks(14, new ECB(1, 18))),
        new Version(6, 20, 20, 18, 18,
            new ECBlocks(18, new ECB(1, 22))),
        new Version(7, 22, 22, 20, 20,
            new ECBlocks(20, new ECB(1, 30))),
        new Version(8, 24, 24, 22, 22,
            new ECBlocks(24, new ECB(1, 36))),
        new Version(9, 26, 26, 24, 24,
            new ECBlocks(28, new ECB(1, 44))),
        new Version(10, 32, 32, 14, 14,
            new ECBlocks(36, new ECB(1, 62))),
        new Version(11, 36, 36, 16, 16,
            new ECBlocks(42, new ECB(1, 86))),
        new Version(12, 40, 40, 18, 18,
            new ECBlocks(48, new ECB(1, 114))),
        new Version(13, 44, 44, 20, 20,
            new ECBlocks(56, new ECB(1, 144))),
        new Version(14, 48, 48, 22, 22,
            new ECBlocks(68, new ECB(1, 174))),
        new Version(15, 52, 52, 24, 24,
            new ECBlocks(42, new ECB(2, 102))),
        new Version(16, 64, 64, 14, 14,
            new ECBlocks(56, new ECB(2, 140))),
        new Version(17, 72, 72, 16, 16,
            new ECBlocks(36, new ECB(4, 92))),
        new Version(18, 80, 80, 18, 18,
            new ECBlocks(48, new ECB(4, 114))),
        new Version(19, 88, 88, 20, 20,
            new ECBlocks(56, new ECB(4, 144))),
        new Version(20, 96, 96, 22, 22,
            new ECBlocks(68, new ECB(4, 174))),
        new Version(21, 104, 104, 24, 24,
            new ECBlocks(56, new ECB(6, 136))),
        new Version(22, 120, 120, 18, 18,
            new ECBlocks(68, new ECB(6, 175))),
        new Version(23, 132, 132, 20, 20,
            new ECBlocks(62, new ECB(8, 163))),
        new Version(24, 144, 144, 22, 22,
            new ECBlocks(62, new ECB(8, 156), new ECB(2, 155))),
        new Version(25, 8, 18, 6, 16,
            new ECBlocks(7, new ECB(1, 5))),
        new Version(26, 8, 32, 6, 14,
            new ECBlocks(11, new ECB(1, 10))),
        new Version(27, 12, 26, 10, 24,
            new ECBlocks(14, new ECB(1, 16))),
        new Version(28, 12, 36, 10, 16,
            new ECBlocks(18, new ECB(1, 22))),
        new Version(29, 16, 36, 14, 16,
            new ECBlocks(24, new ECB(1, 32))),
        new Version(30, 16, 48, 14, 22,
            new ECBlocks(28, new ECB(1, 49)))
    };
  }
1195618
private Version versionOf(int major, int minor, int patch) {
    return Version.forIntegers(major, minor, patch);
  }
1273124
private void setVersions(long[] newVersions, int fromReplica) {
        int fromIndex = fromReplica - 1;
        int len = newVersions.length - fromIndex;
        arraycopy(newVersions, fromIndex, versions, fromIndex, len);
    }
200130
def with_versioning
      was_enabled = ::PaperTrail.enabled?
      ::PaperTrail.enabled = true
      begin
        yield
      ensure
        ::PaperTrail.enabled = was_enabled
      end
    end
1284092
private void round() {
        this.v0 += this.v1;
        this.v2 += this.v3;
        this.v1 = rotateLeft(this.v1, 13);
        this.v3 = rotateLeft(this.v3, 16);

        this.v1 ^= this.v0;
        this.v3 ^= this.v2;
        this.v0 = rotateLeft(this.v0, 32);

        this.v2 += this.v1;
        this.v0 += this.v3;
        this.v1 = rotateLeft(this.v1, 17);
        this.v3 = rotateLeft(this.v3, 21);

        this.v1 ^= this.v2;
        this.v3 ^= this.v0;
        this.v2 = rotateLeft(this.v2, 32);
    }