--- Arc enforcings
488497
private void enfArc(int from, int to) throws ContradictionException {
		if (from != to) {
			ISet ker = g.getMandSuccOrNeighOf(to);
			ISet env = g.getPotSuccOrNeighOf(to);
			for (int i : env) {
				if (i != to && i != from) {
					if (ker.contains(i)) {
						if (g.enforceArc(from, i, this)) {
							arcEnforced(from, i);
						}
					} else if (!g.getPotSuccOrNeighOf(from).contains(i)) {
						if (g.removeArc(to, i, this)) {
							arcRemoved(to, i);
						}
					}
				}
			}
			ker = g.getMandPredOrNeighOf(from);
			env = g.getPotPredOrNeighOf(from);
			for (int i : env) {
				if (i != to && i != from) {
					if (ker.contains(i)) {
						if (g.enforceArc(i, to, this)) {
							arcEnforced(i, to);
						}
					} else if (!g.getPotSuccOrNeighOf(i).contains(to)) {
						if (g.removeArc(i, from, this)) {
							arcRemoved(i, from);
						}
					}
				}
			}
		}
	}
898061
private void checkACL(String path, int perm) throws KeeperException.NoAuthException {
        DataAndVersion node = _data.get(path);
        if (node == null) {
            return;
        }
        List<ACL> acl = node.getAcl();
        if (acl == null || acl.size() == 0) {
            return;
        }
        for (Id authId : _ids) {
            if (authId.getScheme().equals("super")) {
                return;
            }
        }
        for (ACL a : acl) {
            Id id = a.getId();
            if ((a.getPerms() & perm) != 0) {
                if (id.getScheme().equals("world") && id.getId().equals("anyone")) {
                    return;
                }
                for (Id authId : _ids) {
                    if (authId.getScheme().equals(id.getScheme()) && authId.getId().equals(id.getId())) {
                        return;
                    }
                }
            }
        }
        throw new KeeperException.NoAuthException();
    }
287654
private int freezeState(final int activePathIndex) {
    final int start = activePath[activePathIndex];
    final int end = nextArcOffset[activePathIndex];
    final int len = end - start;

    // Set the last arc flag on the current active path's state.
    serialized[end - ARC_SIZE + FLAGS_OFFSET] |= BIT_ARC_LAST;

    // Try to locate a state with an identical content in the hash set.
    final int bucketMask = (hashSet.length - 1);
    int slot = hash(start, len) & bucketMask;
    for (int i = 0;;) {
      int state = hashSet[slot];
      if (state == 0) {
        state = hashSet[slot] = serialize(activePathIndex);
        if (++hashSize > hashSet.length / 2)
          expandAndRehash();
        return state;
      } else if (equivalent(state, start, len)) {
        return state;
      }

      slot = (slot + (++i)) & bucketMask;
    }
  }
153451
function validateInclusion(attr, conf, err) {
    if (nullCheck.call(this, attr, conf, err)) return;

    if (!~conf.in.indexOf(this[attr])) {
        err();
    }
}
457489
def enforce_bounds(self, v):
        
        self._enforce_bounds = v
        self.k.enforce_bounds = v
        self.w.enforce_bounds = v
770570
def enforcement_action(self, column=None, value=None, **kwargs):
        
        return self._resolve_call('PCS_ENFOR_ACTION', column, value, **kwargs)
884109
function Arc(start, end, height) {
    this.start = start;
    this.end = end;
    this.height = height;
}
941312
def enforce_policy(rule):
    """"""
    def wrapper(func):
        """Decorator used for wrap API."""
        @functools.wraps(func)
        def wrapped(*args, **kwargs):
            if enforcer.enforce(rule, {}, g.cred):
                return func(*args, **kwargs)

        return wrapped

    return wrapper
511181
def set_arc(self, arc):
        
        _send_vendor_setup(self.handle, SET_RADIO_ARC, arc, 0, ())
        self.arc = arc
1334975
private void removeRoutingConstraintsOnAttribute(String attribute, boolean notifyListeners) {
                for (String activity : activities) {
                        removeRoutingConstraintsOnAttribute(activity, attribute, notifyListeners);
                }
        }
1091417
function () {
            var out = this._curblock.out;
            if (this._curindent) {
                out.push(this._curindent);
            }
            out.push.apply(out, arguments);
            out.push('\n');
        }
648841
private function enforceRuleset($ruleSet, array $base)
    {
        if (!isset($this->rules['ruleSets'][$ruleSet])) {
            throw new InvalidAclRuleException("Invalid ACL configuration $ruleSet");
        }
        foreach ($this->rules['ruleSets'][$ruleSet] as $rule) {
            $this->enforceRule(array_merge($rule, $base));
        }
    }
645522
def arcfour(key, csbN=1):
	''''''
	if isinstance(key, str):
		key = [ord(c) for c in key]
	s = range(256)
	j = 0
	for n in range(csbN):
		for i in range(256):
			j = (j + s[i] + key[i % len(key)]) % 256
			t = s[i]
			s[i] = s[j]
			s[j] = t
	i = 0
	j = 0
	while True:
		i = (i + 1) % 256
		j = (j + s[i]) % 256
		t = s[i] 
		s[i] = s[j]
		s[j] = t
		yield s[(s[i] + s[j]) % 256]
1211349
def enforce_timezone(&block)
      begin
        if @force_timezone
          zone = ActiveRecord::Base.default_timezone
          ActiveRecord::Base.default_timezone = @force_timezone
        end

        yield if block_given?
      ensure
        ActiveRecord::Base.default_timezone = zone if @force_timezone
      end
    end
81934
void isLegal(boolean checkCdDaSubset) throws Violation {

        if (checkCdDaSubset) {
            if (leadIn < 2 * 44100) {
                    throw new Violation("CD-DA cue sheet must have a lead-in length of at least 2 seconds");
            }
            if (leadIn % 588 != 0) {
                throw new Violation("CD-DA cue sheet lead-in length must be evenly divisible by 588 samples");
            }
        }

        if (numTracks == 0) {
            throw new Violation("cue sheet must have at least one track (the lead-out)");
        }

        if (checkCdDaSubset && tracks[numTracks - 1].number != 170) {
            throw new Violation("CD-DA cue sheet must have a lead-out track number 170 (0xAA)");
        }

        for (int i = 0; i < numTracks; i++) {
            if (tracks[i].number == 0) {
                throw new Violation("cue sheet may not have a track number 0");
            }

            if (checkCdDaSubset) {
                if (!((tracks[i].number >= 1 && tracks[i].number <= 99) || tracks[i].number == 170)) {
                        throw new Violation("CD-DA cue sheet track number must be 1-99 or 170");
                }
            }

            if (checkCdDaSubset && tracks[i].offset % 588 != 0) {
                throw new Violation("CD-DA cue sheet track offset must be evenly divisible by 588 samples");
            }

            if (i < numTracks - 1) {
                if (tracks[i].numIndices == 0) {
                    throw new Violation("cue sheet track must have at least one index point");
                }

                if (tracks[i].indices[0].number > 1) {
                    throw new Violation("cue sheet track's first index number must be 0 or 1");
                }
            }

            for (int j = 0; j < tracks[i].numIndices; j++) {
                if (checkCdDaSubset && tracks[i].indices[j].offset % 588 != 0) {
                    throw new Violation("CD-DA cue sheet track index offset must be evenly divisible by 588 samples");
                }

                if (j > 0) {
                    if (tracks[i].indices[j].number != tracks[i].indices[j - 1].number + 1) {
                        throw new Violation("cue sheet track index numbers must increase by 1");
                    }
                }
            }
        }
    }
560566
def on_arc_right(self, speed, radius_mm, distance_mm, brake=True, block=True):
        
        self._on_arc(speed, radius_mm, distance_mm, brake, block, True)
675208
function prohibits(p) {
	var s = '';
	var m = toArray(p.mixin);
	for (var i in m) {
		s += '* Prohibits mixin '+m[i].name+'\n';
	}
	var f = toArray(p.filter);
	for (var i in f) {
		s += '* Prohibits filter '+f[i].name+'\n';
	}
	return s;
}