for push mode, there is no optimization
333648
@Override
  public Optional<List<CopyRoute>> getPushRoutes(ReplicationConfiguration rc, EndPoint copyFrom) {
    if (rc.getCopyMode() == ReplicationCopyMode.PULL)
      return Optional.absent();

    DataFlowTopology topology = rc.getDataFlowToplogy();
    List<DataFlowTopology.DataFlowPath> paths = topology.getDataFlowPaths();

    for (DataFlowTopology.DataFlowPath p : paths) {
      /**
       * Routes are list of pairs that generated from config in the format of topology specification.
       * For example, source:[holdem, war] will end up with
       * List<(source, holdem), (source, war)>
       */
      List<CopyRoute> routes = p.getCopyRoutes();

      if (routes.isEmpty()) {
        continue;
      }

      // All the routes should has the same copyFrom but different copyTo.
      if (routes.get(0).getCopyFrom().equals(copyFrom)) {
        return Optional.of(routes);
      }
    }
    return Optional.absent();
  }
898576
@SuppressWarnings("unused")
    private void opSetOptionPush() {
        // option = code[ip++]; // final for now
        pushAlt(ip, s, sprev, pkeep);
        ip += OPSize.SET_OPTION + OPSize.FAIL;
    }
595858
final void orpush(CompletableFuture<?> b, BiCompletion<?, ?, ?> c) {
    if (c != null) {
      while (!tryPushStack(c)) {
        if (result != null) {
          lazySetNext(c, null);
          break;
        }
      }
      if (result != null)
        c.tryFire(SYNC);
      else
        b.unipush(new CoCompletion(c));
    }
  }
523958
def optimize(self, piter=3, pmaxf=300, ppert=0.1):
        '''
        

        '''

        self._save_npz()
        optimized = pPLD(self.ID, piter=piter, pmaxf=pmaxf,
                         ppert=ppert, debug=True, clobber=True)
        optimized.publish()
        self.reset()
1001912
def ps(ui, repo, *pats, **opts):
	
	opts['short'] = True
	return pending(ui, repo, *pats, **opts)
1285988
void push( int slots ) {
    assert 0 <= slots && slots < 1000;
    int len = _d.length;
    _sp += slots;
    while( _sp > len ) {
      _key= Arrays.copyOf(_key,len<<1);
      _ary= Arrays.copyOf(_ary,len<<1);
      _d  = Arrays.copyOf(_d  ,len<<1);
      _fcn= Arrays.copyOf(_fcn,len<<=1);
      _str= Arrays.copyOf(_str,len<<1);
    }
  }
782723
function configurePushDevice(options) {
    return Q.when(promiseRegistrationEventResponse, function (registrationEventResponse) {
        if (!registrationEventResponse) {
            // either there is no configuration or since this method was called,
            // registration was canceled
            return Q.resolve(undefined);
        }
        // remaining implementation in push.ts as this is independent of Cordova...
        return push.registerPushDevice(registrationEventResponse.registrationId, options);
    });
}
192955
public boolean enable(Jid pushJid, String node, HashMap<String, String> publishOptions)
            throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
        EnablePushNotificationsIQ enablePushNotificationsIQ = new EnablePushNotificationsIQ(pushJid, node,
                publishOptions);
        return changePushNotificationsStatus(enablePushNotificationsIQ);
    }
339693
def _press_pwr_btn(self, pushType="Press"):
        
        power_settings = {"Action": "PowerButton",
                          "Target": "/Oem/Hp",
                          "PushType": pushType}

        systems_uri = "/rest/v1/Systems/1"

        status, headers, response = self._rest_post(systems_uri, None,
                                                    power_settings)
        if status >= 300:
            msg = self._get_extended_error(response)
            raise exception.IloError(msg)
507178
def push(self, buf):
        
        self._src.emit('push-buffer', Gst.Buffer.new_wrapped(buf))
733779
def push_app(self, content, content_url=None):
        '''
        '''
        parameters = {
            'app_key': self.app_key,
            'app_secret': self.app_secret
        }
        return self._push(content, 'app', parameters, content_url)
622796
@SuppressWarnings({"unused", "WeakerAccess"})
    public void pushProfile(final Map<String, Object> profile) {
        if (profile == null || profile.isEmpty())
            return;

        postAsyncSafely("profilePush", new Runnable() {
            @Override
            public void run() {
                _push(profile);
            }
        });
    }
151499
def optimize_no(self):
        ''' 
        '''
        self.optimization = 0
        self.relax = False
        self.gc_sections = False
        self.ffunction_sections = False
        self.fdata_sections = False
        self.fno_inline_small_functions = False
472968
def PushState(self, **_):
    """"""
    if self.verbose:
      logging.debug("Storing state %r", self.state)
    self.state_stack.append(self.state)
1310323
void performOptimizations() {
    checkState(options.shouldOptimize());
    List<PassFactory> optimizations = getPassConfig().getOptimizations();
    if (optimizations.isEmpty()) {
      return;
    }

    phaseOptimizer = createPhaseOptimizer();
    phaseOptimizer.consume(optimizations);
    phaseOptimizer.process(externsRoot, jsRoot);
    phaseOptimizer = null;
  }
651285
def push_single_device(device_token, message_type, message, params = {})
      params.merge!({
        device_token: device_token,
        message:      message,
        message_type: message_type
        })
      self.send_request('push','single_device',params)
    end
73632
def check_minimal_push(data, opcode)
      if data.bytesize == 0
        # Could have used OP_0.
        return opcode == OP_0
      elsif data.bytesize == 1 && data.bytes[0] >= 1 && data.bytes[0] <= 16
        # Could have used OP_1 .. OP_16.
        return opcode == OP_1 + (data.bytes[0] - 1)
      elsif data.bytesize == 1 && data.bytes[0] == 0x81
        # Could have used OP_1NEGATE.
        return opcode == OP_1NEGATE
      elsif data.bytesize <= 75
        # Could have used a direct push (opcode indicating number of bytes pushed + those bytes).
        return opcode == data.bytesize
      elsif data.bytesize <= 255
        # Could have used OP_PUSHDATA.
        return opcode == OP_PUSHDATA1
      elsif (data.bytesize <= 65535)
        # Could have used OP_PUSHDATA2.
        return opcode == OP_PUSHDATA2
      end
      return true
    end