added for reverse scan purpose only
489324
public boolean isPredicatesOptimizableForAggregate() {
        // for reverse scan, need to examine "added" predicates
        List<AbstractExpression> predicates = ExpressionUtil.uncombinePredicate(m_predicate);
        // if the size of predicates doesn't equal 1, can't be our added artifact predicates
        if (predicates.size() != 1) {
            return false;
        }
        // examin the possible "added" predicates: NOT NULL expr.
        AbstractExpression expr = predicates.get(0);
        if (expr.getExpressionType() != ExpressionType.OPERATOR_NOT) {
            return false;
        }
        if (expr.getLeft().getExpressionType() != ExpressionType.OPERATOR_IS_NULL) {
            return false;
        }
        // Not reverse scan.
        if (m_lookupType != IndexLookupType.LT && m_lookupType != IndexLookupType.LTE) {
            return false;
        }

        return true;
    }
608102
function reverse (data, callback) {
  if (Math.random() > 0.9) {
    callback('oh noes!')
  } else {
    callback(null, data.split('').reverse().join(''))
  }
}
1346963
def backwards(self, orm):
        ""
        orm['avocado.DataField'].objects.filter(app_name='samples', model_name='batch',
            field_name='id').delete()
1740
def scan(backend, timeout=10):
    
    result = []
    for (mac, name) in backend.scan_for_devices(timeout):
        if (name is not None and name.lower() in VALID_DEVICE_NAMES) or \
                mac is not None and mac.upper().startswith(DEVICE_PREFIX):
            result.append(mac.upper())
    return result
303165
def __undo_filter_sub(self, scanline):
        """"""
        ai = 0
        # Loops starts at index fu.
        for i in range(self.fu, len(scanline)):
            x = scanline[i]
            a = scanline[ai]  # result
            scanline[i] = (x + a) & 0xff  # result
            ai += 1
883657
def scan(self, match="*", count=1000, cursor=0):
        
        if self.serialized:
            cursor, data = self._client.zscan(
                self.key_prefix, cursor=cursor, match=match, count=count)
            return (cursor, list(map(
                lambda x: (self._loads(x[0]), self.cast(x[1])), data)))
        else:
            cursor, data = self._client.zscan(
                self.key_prefix, cursor=cursor, match=match, count=count)
            return (cursor, list(map(
                lambda x: (self._decode(x[0]), self.cast(x[1])), data)))
677727
def reverse(self):
        """"""
        r = self[:]
        r.reverse()
        self.clear()
        self.extend(r)
1158202
public function reverse() : void
    {
        $newBits = new SplFixedArray(count($this->bits));

        for ($i = 0; $i < $this->size; ++$i) {
            if ($this->get($this->size - $i - 1)) {
                $newBits[$i >> 5] = $newBits[$i >> 5] | (1 << ($i & 0x1f));
            }
        }

        $this->bits = $newBits;
    }
330663
@Deprecated
    public static void reverseForEach(String string, CodePointProcedure procedure)
    {
        StringIterate.reverseForEachCodePoint(string, procedure);
    }
855902
def reverse_search_history(event):
    
    event.cli.current_search_state.direction = IncrementalSearchDirection.BACKWARD
    event.cli.push_focus(SEARCH_BUFFER)
533380
function reverse (arr) {
  const reversedArray = [];
  for (let i = arr.length - 1; i >= 0; i--) {
    reversedArray.push(arr[i]);
  }
  return reversedArray;
}
1158796
def reverse(self):
        
        enabled = self.lib.iperf_get_test_reverse(self._test)

        if enabled:
            self._reverse = True
        else:
            self._reverse = False

        return self._reverse
675776
function addReverseLookupsForExtendeds (reverseDict, dict) {
  Object.keys(dict).forEach(function (key) {
    let pair = dict[key]
    let quality = pair[0]
    let extendedsArr = pair[1]
    extendedsArr.forEach(function (element) {
      reverseDict[element] = {
        quality: quality,
        extended: key
      }
    })
  })
}
890395
def reverse(self):
        
        return BBox((self.min_y, self.min_x, self.max_y, self.max_x), crs=self.crs)
1042890
def reverse(self, search: str):
        
        url_path = "/api/reverse/{search}".format(search=search)
        return self._request(path=url_path)
446187
final long reversePart(long v, int maxBits) {
        long rest = v & (~((1L << maxBits) - 1));
        return rest | reverse(v, maxBits);
    }
1093744
public static byte[] reverse(byte... bytes) {
        byte[] res = new byte[bytes.length];
        int j = 0;
        for (int i = bytes.length - 1; i >= 0; i--) {
            res[j] = bytes[i];
            j++;
        }
        return res;
    }