EDB processing instruction.
TODO: Problem with one-letter variable names in <?input name="a" type="TestData"?>
@param {string} pi
971526
function Instruction(pi) {
  _classCallCheck(this, Instruction);

  this.tag = pi.split('<?')[1].split(' ')[0];
  this.att = Object.create(null);
  var hit,
      atexp = Instruction._ATEXP;

  while (hit = atexp.exec(pi)) {
    var n = hit[1],
        v = hit[2];
    this.att[n] = cast(v);
  }
}
641735
function raspi_i2c_devname()
{
    try {
        var revisionBuffer = fs.readFileSync('/sys/module/bcm2708/parameters/boardrev');
        var revisionInt = parseInt(revisionBuffer.toString(), 10);
        //console.log('Raspberry Pi board revision: ', revisionInt);
        // Older boards use i2c-0, newer boards use i2c-1
        if ((revisionInt === 2) || (revisionInt === 3)) {
            return '/dev/i2c-0';
        }
        else {
            return '/dev/i2c-1';
        }
    }
    catch(e) {
        if (e.code === 'ENOENT') {
            //console.log('Not a Raspberry Pi');
            return '';
        }
        else {
            throw e;
        }
    }
}
83327
private void step1(DBIDRef id, WritableDBIDDataStore pi, WritableDoubleDataStore lambda) {
    // P(n+1) = n+1:
    pi.put(id, id);
    // L(n+1) = infinity
    // Initialized already.
    // lambda.putDouble(id, Double.POSITIVE_INFINITY);
  }
25257
function (e) {

/*Line 162 - 'AtomUI.js' */        var t = e.target;
/*Line 163 - 'AtomUI.js' */        if (t && /input/gi.test(t.nodeName) && /checkbox/gi.test(t.type))
/*Line 164 - 'AtomUI.js' */            return;

/*Line 166 - 'AtomUI.js' */        if (e.preventDefault) { e.preventDefault(); }
/*Line 167 - 'AtomUI.js' */        else { e.stop(); }

/*Line 169 - 'AtomUI.js' */        e.returnValue = false;
/*Line 170 - 'AtomUI.js' */        e.stopPropagation();
/*Line 171 - 'AtomUI.js' */        return false;
/*Line 172 - 'AtomUI.js' */    }
780611
public void visitPubapi(Element e) {
        Name n = ((ClassSymbol)e).fullname;
        Name p = ((ClassSymbol)e).packge().fullname;
        StringBuffer sb = publicApiPerClass.get(n);
        assert(sb == null);
        sb = new StringBuffer();
        PubapiVisitor v = new PubapiVisitor(sb);
        v.visit(e);
        if (sb.length()>0) {
            publicApiPerClass.put(n, sb);
        }
        explicitPackages.add(p);
     }
576836
function(pis) {
			if (pis) {
				var optional = [];
				var required = [];
				if (pis.reduce(function(hasinput, pi) {
					var keys = Object.keys(pi);
					var name = keys[0];
					var atts = pi[name];
					if (name === "input") {
						var list = atts.required === false ? optional : required;
						list.push(gui.Object.lookup(atts.type));
						return true;
					}
					return hasinput;
				}, false)) {
					this.$input = new edb.InputPlugin();
					this.$input.add(required, this, true);
					this.$input.add(optional, this, false);
				}
			}
		}
891923
function(eventName, cpuNumber, pid, ts, eventBase) {
      var event = /frequency=(\d+)/.exec(eventBase.details);
      if (!event)
        return false;

      this.exynosBusfreqSample('INT Frequency', ts, parseInt(event[1]));
      return true;
    }
223249
function (ch) {
      // DEBUG "Processing `" + ch + "`:"
      var nextStates = this.nextStates,
          child,
          charSpec,
          chars;

      // DEBUG "  " + debugState(this)
      var returned = [];

      for (var i = 0, l = nextStates.length; i < l; i++) {
        child = nextStates[i];

        charSpec = child.charSpec;

        if (typeof (chars = charSpec.validChars) !== 'undefined') {
          if (chars.indexOf(ch) !== -1) {
            returned.push(child);
          }
        } else if (typeof (chars = charSpec.invalidChars) !== 'undefined') {
          if (chars.indexOf(ch) === -1) {
            returned.push(child);
          }
        }
      }

      return returned;
    }
924482
function(pname, pi) {
      forge.task.start({
        type: pname,
        run: function(task) {
           subrun[pi](task);
        },
        success: function(task) {
           ptask.unblock();
        },
        failure: function(task) {
           ptask.unblock();
        }
      });
    }
835236
function (name, test) {
                        try {
                            if (_.isFunction (test)) {                               test () }
                                                else { _.each (test, function (fn) { fn () }) } }
                        catch (e) {
                            if (_.isAssertionError (e)) { var printedName = ((_.isArray (name) && name) || [name]).join ('.')
                                                          console.log (printedName + ':', e.message, '\n' + _.times (printedName.length, _.constant ('~')).join ('') + '\n')
                                                         _.each (e.notMatching, function (x) { console.log ('  •', x) }) }
                            throw e } }
187227
function(){
		if(this.type!==FILE_PZPR){ return;}
		
		switch(this.pid){
		case 'ichimaga':
			var pzlflag = this.body.split('\n')[0];
			if     (pzlflag==='mag')  { this.pid = 'ichimagam';}
			else if(pzlflag==='cross'){ this.pid = 'ichimagax';}
			break;
		case 'icelom':
			var pzltype = this.body.split('\n')[2];
			if(pzltype==='skipwhite'){ this.pid = 'icelom2';}
			break;
		case 'pipelink':
			var lines = this.body.split('\n'), row = 1, len = this.rows;
			if(lines.slice(row, row+len).join('').match(/o/)){
				this.pid = 'pipelinkr';
			}
			break;
		case 'bonsan':
			var lines = this.body.split('\n'), row = 2*this.rows, len = 2*this.rows-1;
			if(lines.slice(row, row+len).join('').match(/1/)){
				this.pid = 'heyabon';
			}
			break;
		case 'kramma':
			var lines = this.body.split('\n'), row = this.rows, len = this.rows+1;
			if(lines.slice(row, row+len).join('').match(/1/)){
				this.pid = 'kramman';
			}
			break;
		}
	}
672883
private void qrBinary(int[] datastream, int version, int target_binlen, QrMode[] inputMode, int[] inputData, boolean gs1, int eciMode, int est_binlen) {

        // TODO: make encodeInfo a StringBuilder, make this method static?

        int position = 0;
        int short_data_block_length, i;
        int padbits;
        int current_binlen, current_bytes;
        int toggle;
        QrMode data_block;

        StringBuilder binary = new StringBuilder(est_binlen + 12);

        if (gs1) {
            binary.append("0101"); /* FNC1 */
        }

        if (eciMode != 3) {
            binary.append("0111"); /* ECI (Table 4) */
            if (eciMode <= 127) {
                binaryAppend(eciMode, 8, binary); /* 000000 to 000127 */
            } else if (eciMode <= 16383) {
                binaryAppend(0x8000 + eciMode, 16, binary); /* 000000 to 016383 */
            } else {
                binaryAppend(0xC00000 + eciMode, 24, binary); /* 000000 to 999999 */
            }
        }

        encodeInfo += "Encoding: ";

        do {
            data_block = inputMode[position];
            short_data_block_length = 0;
            do {
                short_data_block_length++;
            } while (((short_data_block_length + position) < inputMode.length)
                    && (inputMode[position + short_data_block_length] == data_block));

            switch (data_block) {

                case KANJI:
                    /* Kanji mode */
                    /* Mode indicator */
                    binary.append("1000");

                    /* Character count indicator */
                    binaryAppend(short_data_block_length, tribus(version, 8, 10, 12), binary);

                    encodeInfo += "KNJI ";

                    /* Character representation */
                    for (i = 0; i < short_data_block_length; i++) {
                        int jis = inputData[position + i];
                        if (jis >= 0x8140 && jis <= 0x9ffc) {
                            jis -= 0x8140;
                        } else if (jis >= 0xe040 && jis <= 0xebbf) {
                            jis -= 0xc140;
                        }
                        int prod = ((jis >> 8) * 0xc0) + (jis & 0xff);
                        binaryAppend(prod, 13, binary);
                        encodeInfo += Integer.toString(prod) + " ";
                    }

                    break;

                case BINARY:
                    /* Byte mode */
                    /* Mode indicator */
                    binary.append("0100");

                    /* Character count indicator */
                    binaryAppend(short_data_block_length, tribus(version, 8, 16, 16), binary);

                    encodeInfo += "BYTE ";

                    /* Character representation */
                    for (i = 0; i < short_data_block_length; i++) {
                        int b = inputData[position + i];
                        if (b == FNC1) {
                            b = 0x1d; /* FNC1 */
                        }
                        binaryAppend(b, 8, binary);
                        encodeInfo += Integer.toString(b) + " ";
                    }

                    break;

                case ALPHANUM:
                    /* Alphanumeric mode */
                    /* Mode indicator */
                    binary.append("0010");

                    /* If in GS1 mode, expand FNC1 -> '%' and expand '%' -> '%%' in a new array */
                    int percentCount = 0;
                    if (gs1) {
                        for (i = 0; i < short_data_block_length; i++) {
                            if (inputData[position + i] == '%') {
                                percentCount++;
                            }
                        }
                    }
                    int[] inputExpanded = new int[short_data_block_length + percentCount];
                    percentCount = 0;
                    for (i = 0; i < short_data_block_length; i++) {
                        int c = inputData[position + i];
                        if (c == FNC1) {
                            inputExpanded[i + percentCount] = '%'; /* FNC1 */
                        } else {
                            inputExpanded[i + percentCount] = c;
                            if (gs1 && c == '%') {
                                percentCount++;
                                inputExpanded[i + percentCount] = c;
                            }
                        }
                    }

                    /* Character count indicator */
                    binaryAppend(inputExpanded.length, tribus(version, 9, 11, 13), binary);

                    encodeInfo += "ALPH ";

                    /* Character representation */
                    for (i = 0; i + 1 < inputExpanded.length; i += 2) {
                        int first = positionOf((char) inputExpanded[i], RHODIUM);
                        int second = positionOf((char) inputExpanded[i + 1], RHODIUM);
                        int prod = (first * 45) + second;
                        int count = 2;
                        binaryAppend(prod, 1 + (5 * count), binary);
                        encodeInfo += Integer.toString(prod) + " ";
                    }
                    if (inputExpanded.length % 2 != 0) {
                        int first = positionOf((char) inputExpanded[inputExpanded.length - 1], RHODIUM);
                        int prod = first;
                        int count = 1;
                        binaryAppend(prod, 1 + (5 * count), binary);
                        encodeInfo += Integer.toString(prod) + " ";
                    }

                    break;

                case NUMERIC:
                    /* Numeric mode */
                    /* Mode indicator */
                    binary.append("0001");

                    /* Character count indicator */
                    binaryAppend(short_data_block_length, tribus(version, 10, 12, 14), binary);

                    encodeInfo += "NUMB ";

                    /* Character representation */
                    i = 0;
                    while (i < short_data_block_length) {

                        int first = Character.getNumericValue(inputData[position + i]);
                        int count = 1;
                        int prod = first;

                        if (i + 1 < short_data_block_length) {
                            int second = Character.getNumericValue(inputData[position + i + 1]);
                            count = 2;
                            prod = (prod * 10) + second;

                            if (i + 2 < short_data_block_length) {
                                int third = Character.getNumericValue(inputData[position + i + 2]);
                                count = 3;
                                prod = (prod * 10) + third;
                            }
                        }

                        binaryAppend(prod, 1 + (3 * count), binary);

                        encodeInfo += Integer.toString(prod) + " ";

                        i += count;
                    };

                    break;
            }

            position += short_data_block_length;

        } while (position < inputMode.length);

        encodeInfo += "\n";

        /* Terminator */
        binary.append("0000");

        current_binlen = binary.length();
        padbits = 8 - (current_binlen % 8);
        if (padbits == 8) {
            padbits = 0;
        }
        current_bytes = (current_binlen + padbits) / 8;

        /* Padding bits */
        for (i = 0; i < padbits; i++) {
            binary.append('0');
        }

        /* Put data into 8-bit codewords */
        for (i = 0; i < current_bytes; i++) {
            datastream[i] = 0x00;
            for (int p = 0; p < 8; p++) {
                if (binary.charAt((i * 8) + p) == '1') {
                    datastream[i] += (0x80 >> p);
                }
            }
        }

        /* Add pad codewords */
        toggle = 0;
        for (i = current_bytes; i < target_binlen; i++) {
            if (toggle == 0) {
                datastream[i] = 0xec;
                toggle = 1;
            } else {
                datastream[i] = 0x11;
                toggle = 0;
            }
        }

        encodeInfo += "Codewords: ";
        for (i = 0; i < target_binlen; i++) {
            encodeInfo += Integer.toString(datastream[i]) + " ";
        }
        encodeInfo += "\n";
    }
41845
function me(Me){// Don't use UCS-2
var Ue=[],Fe=Me.length,Ke=0,qe=Be,Ve=Pe,He,Ge,Ye,We,Xe,Je,Ze,Qe,$e,/** Cached calculation results */et;// Handle the basic code points: let `basic` be the number of input code
// points before the last delimiter, or `0` if there is none, then copy
// the first basic code points to the output.
for(Ge=Me.lastIndexOf(Re),0>Ge&&(Ge=0),Ye=0;Ye<Ge;++Ye)128<=Me.charCodeAt(Ye)&&de("not-basic"),Ue.push(Me.charCodeAt(Ye));// Main decoding loop: start just after the last delimiter if any basic code
// points were copied; start at the beginning otherwise.
for(We=0<Ge?Ge+1:0;We<Fe;)/* no final expression */{// `index` is the index of the next character to be consumed.
// Decode a generalized variable-length integer into `delta`,
// which gets added to `i`. The overflow checking is easier
// if we increase `i` as we go, then subtract off its starting
// value at the end to obtain `delta`.
for(Xe=Ke,Je=1,Ze=Ae;;/* no condition */Ze+=Ae){if(We>=Fe&&de("invalid-input"),Qe=ue(Me.charCodeAt(We++)),(Qe>=Ae||Qe>Le((Ie-Ke)/Je))&&de("overflow"),Ke+=Qe*Je,$e=Ze<=Ve?we:Ze>=Ve+Ee?Ee:Ze-Ve,Qe<$e)break;et=Ae-$e,Je>Le(Ie/et)&&de("overflow"),Je*=et}He=Ue.length+1,Ve=he(Ke-Xe,He,0==Xe),Le(Ke/He)>Ie-qe&&de("overflow"),qe+=Le(Ke/He),Ke%=He,Ue.splice(Ke++,0,qe)}return pe(Ue)}
334905
async function runSample(projectId = 'your-project-id') {
  // A unique identifier for the given session
  const sessionId = uuid.v4();

  // Create a new session
  const sessionClient = new dialogflow.SessionsClient();
  const sessionPath = sessionClient.sessionPath(projectId, sessionId);

  // The text query request.
  const request = {
    session: sessionPath,
    queryInput: {
      text: {
        // The query to send to the dialogflow agent
        text: 'hello',
        // The language used by the client (en-US)
        languageCode: 'en-US',
      },
    },
  };

  // Send request and log result
  const responses = await sessionClient.detectIntent(request);
  console.log('Detected intent');
  const result = responses[0].queryResult;
  console.log(`  Query: ${result.queryText}`);
  console.log(`  Response: ${result.fulfillmentText}`);
  if (result.intent) {
    console.log(`  Intent: ${result.intent.displayName}`);
  } else {
    console.log(`  No intent matched.`);
  }
}
322844
function(eventName, cpuNumber, pid, ts, eventBase) {
      var event = /obj=(\w+), size=(\d+)/.exec(eventBase.details);
      if (!event)
        return false;

      var obj = event[1];
      var size = parseInt(event[2]);
      this.i915GemObjectSlice(ts, eventName, obj,
          {
            obj: obj,
            size: size
          });
      return true;
    }
378020
function process(data) {
  var flags = parseInt(data, 16);
  var result = [];
  if(flags & 0x01) {
    result.push(BIT0_NAME);
  }
  if(flags & 0x02) {
    result.push(BIT1_NAME);
  }
  if(flags & 0x04) {
    result.push(BIT2_NAME);
  }
  if(flags & 0x08) {
    result.push(BIT3_NAME);
  }
  if(flags & 0x10) {
    result.push(BIT4_NAME);
  }
  if(flags & 0x20) {
    result.push(BIT5_NAME);
  }
  return result;
}
1047568
function printHeadingCB(err, heading) {
    if (err) {
        console.log(err);
        return;
    }
    console.log(heading * 180 / Math.PI);
}